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

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

模拟服务器

开发平台：

C/C++

S3PDBSocketPool.cpp：源码内容
  1. //-----------------------------------------//
  2. //                                         //
  3. //  File : S3PDBSocketPool.cpp    //
  4. // Author : Yang Xiaodong            //
  5. // Modified : 8/26/2002                //
  6. //                                         //
  7. //-----------------------------------------//
  8. #pragma warning(disable: 4786)
  10. #include "S3PDBSocketPool.h"
  12. #include "../../../Headers/inoutmac.h"
  14. #include "S3PAccount.h"
  15. #include "GlobalFun.h"
  16. #include "S3PDBConnectionPool.h"
  20. #include "../../Multiserver/Heaven/Interface/IServer.h"
  21. #include "../../../Headers/KProtocolDef.h"
  22. #include "../../../Headers/KRelayProtocol.h"
  23. #include "../../../Headers/KGmProtocol.h"
  24. #include "../../../Headers/KProtocol.h"
  25. #include "../S3AccServer/AccountLoginDef.h"
  26. #include "crtdbg.h"
  28. #include "string.h"
  29. #include "malloc.h"
  31. S3PDBSocketPool* S3PDBSocketPool::m_pInstance = NULL;
  32. DWORD S3PDBSocketPool::m_SelfAddress = 0;
  34. S3PDBSocketPool::S3PDBSocketPool()
  35. {
  36. m_pServer = NULL;
  37. }
  39. S3PDBSocketPool::~S3PDBSocketPool()
  40. {
  41. assert(m_pServer == NULL);
  42. assert(m_clientIDs.size() == 0);
  43. }
  45. S3PDBSocketPool* S3PDBSocketPool::Instance()
  46. {
  47. if ( NULL == m_pInstance )
  48. {
  49. m_pInstance = new S3PDBSocketPool;
  51. gGetMacAndIPAddress(NULL, NULL, NULL, &m_pInstance->m_SelfAddress);
  52. }
  53. return m_pInstance;
  54. }
  56. void S3PDBSocketPool::ReleaseInstance()
  57. {
  58. delete m_pInstance;
  59. m_pInstance = NULL;
  60. }
  62. HANDLE S3PDBSocketPool::Start(IServer* pServer)
  63. {
  64. assert(pServer);
  65. if (NULL == m_pServer)
  66. {
  67. m_pServer = pServer;
  68. pServer->AddRef();
  69. }
  71. return 0;
  72. }
  74. BOOL S3PDBSocketPool::Stop()
  75. {
  76. BOOL bRet = TRUE;
  77. if (bRet && m_pServer)
  78. {
  79. StopAllUserClientConnect();
  80. m_pServer->Release();
  81. m_pServer = NULL;
  82. }
  84. return bRet;
  85. }
  87. BOOL S3PDBSocketPool::SendData(unsigned long uID, const void * const pData, const size_t &datalength)
  88. {
  89. if (m_pServer == NULL || pData == NULL || datalength <= 0)
  90. return FALSE;
  92. BOOL bRet = FALSE;
  93. try
  94. {
  95. m_pServer->SendData(uID, pData, datalength);
  96. bRet = TRUE;
  97. }
  98. catch(...)
  99. {
  100. //printf("Failed to feed back( S3PDBSocketPool::SendData )");
  101. bRet = FALSE;
  102. }
  103. return bRet;
  104. }
  106. BOOL S3PDBSocketPool::CustomSend(unsigned long uID, char nProtocol, KAccountHead* pSend)
  107. {
  108. if (m_pServer == NULL)
  109. return FALSE;
  111. BOOL bRet = FALSE;
  112. try
  113. {
  114. assert(pSend);
  115. pSend->Version = ACCOUNT_CURRENT_VERSION;
  116. char send[MAX_PATH + 1];
  117. assert(pSend->Size < MAX_PATH);
  118. send[0] = pf_normal;
  119. send[1] = nProtocol;
  120. memcpy(send + 2, pSend, pSend->Size);
  122. m_pServer->SendData(uID, send, pSend->Size + 2);
  124. bRet = TRUE;
  125. }
  126. catch(...)
  127. {
  128. //printf("Failed to feed back( S3PDBSocketPool::CustomSend )");
  129. bRet = FALSE;
  130. }
  131. return bRet;
  132. }
  134. void S3PDBSocketPool::SendRelayData(unsigned long uID, char* szAccount, const void * const pSrcData1, const size_t& datalength1, const void * const pSrcData2, const size_t& datalength2)
  135. {
  136. if (szAccount == NULL || pSrcData1 == NULL || datalength1 == 0)
  137. return;
  139. RELAY_ASKWAY_DATA relay;
  140. relay.ProtocolFamily = pf_relay;
  141. relay.ProtocolID = relay_c2c_askwaydata;
  142. relay.nFromIP = 0; //由于是服务器主动发给客户端,所以无法填nFromIP,只好填0
  143. relay.nFromRelayID = 0; //由于是服务器主动发给客户端,所以无法填nFromRelayID,只好填0
  144. relay.seekRelayCount = 0;
  145. relay.seekMethod = rm_account_id;
  146. relay.wMethodDataLength = defACCOUNT_STRING_LENGTH;
  147. relay.routeDateLength = datalength1 + datalength2;
  149. BYTE *pData = (BYTE *)_alloca(sizeof(relay) + relay.wMethodDataLength + relay.routeDateLength);
  151. BYTE *pDataOrg = pData;
  152. memcpy(pData, &relay, sizeof(relay));
  153. pData += sizeof(relay);
  155. strncpy((char*)pData, szAccount, defACCOUNT_STRING_LENGTH);
  156. pData += relay.wMethodDataLength;
  158. memcpy(pData, pSrcData1, datalength1);
  159. pData += datalength1;
  161. if (pSrcData2 && datalength2 > 0)
  162. memcpy(pData, pSrcData2, datalength2);
  164. m_pServer->SendData(uID ,(const void *)pDataOrg, sizeof(relay) + relay.wMethodDataLength + relay.routeDateLength);
  165. }
  167. void S3PDBSocketPool::SendRelayData(unsigned long uID, const void * const pSrcData1, const size_t& datalength1, const void * const pSrcData2, const size_t& datalength2)
  168. {
  169. if (pSrcData1 == NULL || datalength1 == 0)
  170. return;
  172. RELAY_DATA relayIP;
  173. relayIP.ProtocolFamily = pf_relay;
  174. relayIP.ProtocolID = relay_c2c_data;
  175. relayIP.nToIP = 0;
  176. relayIP.nToRelayID = 0;
  177. relayIP.nFromIP = 0; //由于是服务器主动发给客户端,所以无法填nFromIP,只好填0
  178. relayIP.nFromRelayID = 0; //由于是服务器主动发给客户端,所以无法填nFromRelayID,只好填0
  179. relayIP.routeDateLength = datalength1 + datalength2;
  181. BYTE *pData = (BYTE *)_alloca(sizeof(relayIP) + relayIP.routeDateLength);
  183. BYTE *pDataOrg = pData;
  184. memcpy(pData, &relayIP, sizeof(relayIP));
  185. pData += sizeof(relayIP);
  187. memcpy(pData, pSrcData1, datalength1);
  188. pData += datalength1;
  190. if (pSrcData2 && datalength2 > 0)
  191. memcpy(pData, pSrcData2, datalength2);
  193. m_pServer->SendData(uID ,(const void *)pDataOrg, sizeof(relayIP) + relayIP.routeDateLength);
  194. }
  197. BOOL S3PDBSocketPool::AddUserClientID(unsigned long uID)
  198. {
  199. GatewayIDMap::iterator i = m_clientIDs.find(uID);
  200. if (i != m_clientIDs.end())
  201. {
  202. if (i->second)
  203. {
  204. i->second->Stop();
  205. delete i->second;
  206. }
  207. }
  208. assert(m_pServer);
  210. Lock();
  211. const char* pInfo = m_pServer->GetClientInfo(uID);
  212. unsigned long Address = inet_addr(pInfo);
  213. int offset = 0;
  214. while(*(pInfo + offset) != ':')
  215. offset++;
  216. offset += 2; //skip : and blank
  217. short Port = atoi(pInfo + offset);
  218. KGatewayDataProcess* p = new KGatewayDataProcess(uID, Address, Port);
  219. m_clientIDs[uID] = p;
  220. Unlock();
  222. p->Start(m_pServer);
  223. gTrace("Add Relay(%s) Client %d ! -- Count %d", pInfo, uID, m_clientIDs.size());
  224. return TRUE;
  225. }
  227. BOOL S3PDBSocketPool::RemoveUserClientID(unsigned long uID)
  228. {
  229. BOOL b = FALSE;
  230. DWORD Address;
  231. std::string ServerName;
  232. KGatewayDataProcess* p = NULL;
  233. Lock();
  234. GatewayIDMap::iterator i = m_clientIDs.find(uID);
  235. if (i != m_clientIDs.end ())
  236. {
  237. if (i->second)
  238. {
  239. p = i->second;
  240. b = TRUE;
  241. }
  242. m_clientIDs.erase(i);
  243. }
  244. Unlock();
  245. gTrace("Remove Relay Client %d ! -- Count %d", uID, m_clientIDs.size());
  247. if (b && p)
  248. {
  249. p->Stop();
  250. Address = p->m_Address;
  251. ServerName = p->m_ServerName;
  252. delete p;
  253. NotifyRelayLogoutInfo(Address, ServerName);
  254. }
  256. return b;
  257. }
  259. BOOL S3PDBSocketPool::ShowAllClientInfo()
  260. {
  261. if (IsLocked())
  262. return FALSE;
  263. Lock();
  264. BOOL b = FALSE;
  265. GatewayIDMap::iterator i = m_clientIDs.begin();
  266. int n = 0;
  267. while (i != m_clientIDs.end())
  268. {
  269. KGatewayDataProcess* p = i->second;
  270. if (p)
  271. {
  272. in_addr add;
  273. add.s_addr = p->m_Address;
  274. gTrace("Client %d: %s(%s)", n, p->m_ServerName.c_str(), inet_ntoa(in_addr(add))); 
  275. }
  276. i++;
  277. n++;
  278. }
  279. b = TRUE;
  280. Unlock();
  281. return b;
  282. }
  284. BOOL S3PDBSocketPool::FindGatewayByServerName(const char* szServerName, DWORD& nGameID)
  285. {
  286. if (szServerName == NULL ||
  287. szServerName[0] == 0)
  288. {
  289. return FALSE;
  290. }
  291. Lock();
  292. BOOL b = FALSE;
  293. GatewayIDMap::iterator i = m_clientIDs.begin();
  294. while (i != m_clientIDs.end())
  295. {
  296. if (i->second && strcmp(i->second->m_ServerName.c_str(), szServerName) == 0)
  297. {
  298. nGameID = i->second->m_nGameID;
  299. b = TRUE;
  300. break;
  301. }
  302. i++;
  303. }
  304. Unlock();
  305. return b;
  306. }
  308. KGatewayDataProcess* S3PDBSocketPool::FindGatewayByID(unsigned long nGameID)
  309. {
  310. KGatewayDataProcess* p = NULL;
  311. Lock();
  312. GatewayIDMap::iterator i = m_clientIDs.begin();
  313. while (i != m_clientIDs.end())
  314. {
  315. if (i->second && i->second->m_nGameID == nGameID)
  316. {
  317. p = i->second;
  318. break;
  319. }
  320. i++;
  321. }
  322. Unlock();
  323. return p;
  324. }
  326. BOOL S3PDBSocketPool::FindGatewayClientByAddress(DWORD nAddress, DWORD& nClientID)
  327. {
  328. Lock();
  329. BOOL b = FALSE;
  330. GatewayIDMap::iterator i = m_clientIDs.begin();
  331. while (i != m_clientIDs.end())
  332. {
  333. if (i->second && i->second->m_Address == nAddress)
  334. {
  335. nClientID = i->first;
  336. b = TRUE;
  337. break;
  338. }
  339. i++;
  340. }
  341. Unlock();
  342. return b;
  343. }
  345. void S3PDBSocketPool::BroadGMData(const IBYTE* lpData, const DWORD dwDataSize)
  346. {
  347. Lock();
  348. GatewayIDMap::iterator i = m_clientIDs.begin();
  349. while (i != m_clientIDs.end())
  350. {
  351. if (i->second &&
  352. i->second->m_ServerName[0] == 'g' &&
  353. i->second->m_ServerName[1] == 'm' &&
  354. i->second->m_ServerName[2] == '-')
  355. {
  356. SendData(i->first, lpData, dwDataSize);
  357. }
  358. i++;
  359. }
  360. Unlock();
  361. }
  362. BOOL S3PDBSocketPool::StopAllUserClientConnect()
  363. {
  364. while(m_clientIDs.size() > 0)
  365. {
  366. GatewayIDMap::iterator i = m_clientIDs.begin();
  367. if (i != m_clientIDs.end() && i->second)
  368. i->second->Stop();
  369. Sleep(10);
  370. }
  371. return TRUE;
  372. }
  374. void S3PDBSocketPool::NotifyRelayLoginInfo(DWORD nGameID, DWORD nClientID, DWORD Address, const std::string& ServerName)
  375. {
  376. KServerInfo aInfo;
  377. aInfo.Size = sizeof(KServerInfo);
  378. aInfo.Type = ServerInfo;
  379. aInfo.Operate = 0;
  380. aInfo.Version = ACCOUNT_CURRENT_VERSION;
  381. aInfo.nValue = 0;
  383. Lock();
  384. GatewayIDMap::iterator i = m_clientIDs.begin();
  385. aInfo.nServerType = server_Login;
  386. aInfo.nValue = Address;
  387. strncpy(aInfo.Account, ServerName.c_str(), LOGIN_USER_ACCOUNT_MAX_LEN);
  388. while (i != m_clientIDs.end()) //先给已登陆者发送刚登陆者的信息
  389. {
  390. if (i->second)
  391. {
  392. if (i->second->m_nGameID != nGameID)
  393. {
  394. CustomSend(i->first, s2c_gatewayinfo, &aInfo);
  395. }
  396. }
  397. i++;
  398. }
  399. //再给刚登陆者发送已登陆者的信息
  400. aInfo.nServerType = server_LoginAlready;
  401. i = m_clientIDs.begin();
  402. while (i != m_clientIDs.end())
  403. {
  404. if (i->second)
  405. {
  406. if (i->second->m_nGameID != nGameID)
  407. {
  408. aInfo.nValue = i->second->m_Address;
  409. strncpy(aInfo.Account, i->second->m_ServerName.c_str(), LOGIN_USER_ACCOUNT_MAX_LEN);
  410. CustomSend(nClientID, s2c_gatewayinfo, &aInfo);
  411. }
  412. }
  413. i++;
  414. }
  415. Unlock();
  416. }
  418. void S3PDBSocketPool::NotifyRelayLogoutInfo(DWORD Address, const std::string& ServerName)
  419. {
  420. KServerInfo aInfo;
  421. aInfo.Size = sizeof(KServerInfo);
  422. aInfo.Type = ServerInfo;
  423. aInfo.Operate = 0;
  424. aInfo.Version = ACCOUNT_CURRENT_VERSION;
  425. aInfo.nValue = 0;
  427. Lock();
  428. GatewayIDMap::iterator i = m_clientIDs.begin();
  429. aInfo.nServerType = server_Logout;
  430. strncpy(aInfo.Account, ServerName.c_str(), LOGIN_USER_ACCOUNT_MAX_LEN);
  431. aInfo.nValue = Address;
  432. while (i != m_clientIDs.end())
  433. {
  434. if (i->second)
  435. {
  436. CustomSend(i->first, s2c_gatewayinfo, &aInfo);
  437. }
  438. i++;
  439. }
  440. Unlock();
  441. }
  443. //////////////////////////////////////////////////////////////////////////////////////
  445. KGatewayDataProcess::KGatewayDataProcess(unsigned long nID, unsigned long Address, short Port)
  446. {
  447. m_nClientID = nID;
  448. m_Address = Address;
  449. m_Port = Port;
  451. m_nGameID = 0;
  452. m_hClosed = KPICreateEvent(NULL, TRUE, FALSE, NULL);
  454. m_hStartAutoTime = KPICreateEvent(NULL, TRUE, FALSE, NULL);
  456. m_pServer = NULL;
  458. m_pConn = NULL;
  459. }
  461. KGatewayDataProcess::~KGatewayDataProcess()
  462. {
  463. assert(m_pServer == NULL);
  464. }
  466. void KGatewayDataProcess::Close()
  467. {
  468. if (m_nGameID > 0)
  469. {
  470. S3PDBConVBC* pCon = GetDB(1);
  471. KAccountUser acc;
  472. acc.Size = sizeof(KAccountUser);
  473. acc.Type = AccountUser;
  474. acc.Version = ACCOUNT_CURRENT_VERSION;
  475. acc.Operate = m_nGameID;
  476. acc.Account[0] = 0;
  477. ProRelayClose(pCon, (const IBYTE*)&acc, acc.Size);
  479. KPIWaitForSingleObject(m_hClosed, INFINITE);
  480. }
  481. }
  483. void KGatewayDataProcess::AutoTime()
  484. {
  485. if (!IsStartAutoTime())
  486. return;
  487. DWORD nNow = GetTickCount();
  488. if (nNow - m_LastMoneyTime >= 600000) //十分钟催一次钱
  489. {
  490. m_LastMoneyTime = nNow;
  491. S3PDBConVBC* pConn = GetDB(0);
  492. if (pConn)
  493. ProAutoTime(pConn);
  494. }
  496. if (nNow - m_LastPingTime >= 180000) //三分钟没有Ping
  497. {
  498. KPISetEvent(m_hStop);
  499. }
  500. }
  502. BOOL KGatewayDataProcess::CheckConnectAddress()
  503. {
  504. S3PDBConVBC* pConn = GetDB(0);
  505. if (pConn)
  506. return S3PAccount::CheckAddress(pConn, m_Address, m_Port) == ACTION_SUCCESS;
  507. return FALSE;
  508. }
  510. BOOL KGatewayDataProcess::IsStartAutoTime()
  511. {
  512. return KPIWaitForSingleObject(m_hStartAutoTime, 0) == 1;
  513. }
  515. BOOL KGatewayDataProcess::StartAutoTime()
  516. {
  517. if (!IsStartAutoTime())
  518. {
  519. m_LastPingTime = GetTickCount();
  520. m_LastMoneyTime = m_LastPingTime;
  521. KPISetEvent(m_hStartAutoTime);
  522. }
  524. return TRUE;
  525. }
  527. void KGatewayDataProcess::ProcessClientData(const void * pData, DWORD dwDataSize)
  528. {
  529. if (pData && dwDataSize > 0)
  530. {
  531. BYTE nFamily = *((char*)pData);
  532. BYTE nProtocol = *(((char*)pData) + 1);
  533. if (nFamily == pf_normal && nProtocol == c2s_ping)
  534. {
  535. DWORD nSecond = m_LastPingTime;
  536. m_LastPingTime = GetTickCount();
  537. #pragma pack(push, 1)
  538. typedef struct
  539. {
  540. BYTE nFamily;
  541. BYTE ProtocolType;
  542. DWORD m_dwTime;
  543. } PING_COMMAND;
  544. #pragma pack(pop)
  545. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  546. PING_COMMAND* p = (PING_COMMAND*)pData;
  547. PING_COMMAND PingCmd;
  548. PingCmd.nFamily = pf_normal;
  549. PingCmd.ProtocolType = s2c_ping;
  550. PingCmd.m_dwTime = p->m_dwTime;
  551. pSocket->SendData(m_nClientID, &PingCmd, sizeof(PING_COMMAND));
  552. in_addr ar;
  553. ar.s_addr = m_Address;
  554. gTrace("Relay %s(%s): Ping %d(s)", m_ServerName.c_str(), inet_ntoa(ar), (m_LastPingTime - nSecond) / 1000);
  555. }
  556. else if (nFamily == pf_relay && (nProtocol == relay_c2c_data || nProtocol == relay_s2c_loseway))
  557. {
  558. ProRelayIPData((const IBYTE*)pData, dwDataSize);
  559. }
  560. else
  561. {
  562. //不需要数据库的在前面处理
  563. S3PDBConVBC* pConn = GetDB(10);
  564. ProcessData(pConn, pData, dwDataSize);
  565. }
  566. }
  567. }
  569. DWORD KGatewayDataProcess::ProcessData(S3PDBConVBC* pConn, const void* pData, DWORD dwDataSize)
  570. {
  571. BOOL bRet = FALSE;
  572. if (pConn == NULL || pData == NULL || dwDataSize <= 0)
  573. {
  574. return bRet;
  575. }
  577. BYTE nFamily = *((char*)pData);
  578. BYTE nProtocol = *(((char*)pData) + 1);
  580. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  582. BOOL bStopConn = FALSE;
  584. if (nFamily == pf_normal && nProtocol == c2s_gatewayverify)
  585. {
  586. if (m_nGameID > 0)
  587. {
  588. KAccountUserReturn aReturn;
  589. aReturn.Size = sizeof(KAccountUserReturn);
  590. aReturn.Type = AccountUserReturn;
  591. aReturn.Operate = ((KAccountUserLoginInfo*)(((char*)pData) + 1))->Operate;
  592. aReturn.nReturn = E_ACCOUNT_ACCESSDENIED;
  593. aReturn.Account[0] = 0;
  594. pSocket->CustomSend(m_nClientID, s2c_gatewayverify, &aReturn);
  595. bRet = FALSE;
  596. bStopConn = TRUE;
  597. }
  598. else
  599. {
  600. bRet = ProRelayVerify(pConn, ((char*)pData) + 2, dwDataSize - 2);
  601. if (bRet)
  602. {
  603. StartAutoTime();
  605. pSocket->NotifyRelayLoginInfo(m_nGameID, m_nClientID, m_Address, m_ServerName);
  606. }
  607. else
  608. bStopConn = TRUE;
  609. }
  610. }
  611. else if (nFamily == pf_normal && nProtocol == c2s_gatewayinfo)
  612. {
  613. if (m_nGameID == 0)
  614. {
  615. bStopConn = TRUE;
  616. }
  617. else
  618. {
  619. bRet = ProRelayInfo(pConn, ((char*)pData) + 2, dwDataSize - 2);
  620. }
  621. }
  622. else if (nFamily == pf_normal && nProtocol == c2s_accountlogout) //unlock account
  623. {
  624. if (m_nGameID == 0)
  625. {
  626. bStopConn = TRUE;
  627. }
  628. else
  629. {
  630. bRet = ProAccountLogout(pConn, ((char*)pData) + 2, dwDataSize - 2);
  631. }
  632. }
  633. else if (nFamily == pf_normal && nProtocol == c2s_gamelogin) //freeze account
  634. {
  635. if (m_nGameID == 0)
  636. {
  637. bStopConn = TRUE;
  638. }
  639. else
  640. {
  641. bRet = ProGameLogin(pConn, ((char*)pData) + 2, dwDataSize - 2);
  642. }
  643. }
  644. else
  645. {
  646. if (m_nGameID > 0)
  647. {
  648. if (nFamily == pf_relay && nProtocol == relay_c2c_askwaydata)
  649. {
  650. bRet = ProRelayAskData(pConn, (const IBYTE*)pData, dwDataSize);
  651. }
  652. else if (nFamily == pf_gamemaster)
  653. {
  654. bRet = ProGMFamily(pConn, (const IBYTE*)pData, dwDataSize);
  655. }
  656. }
  657. else
  658. bStopConn = TRUE;
  659. }
  661. if (bStopConn)
  662. {
  663. KPISetEvent(m_hStop);
  664. }
  666. return bRet;
  667. }
  669. BOOL KGatewayDataProcess::ProRelayVerify(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  670. {
  671. BOOL bRet = FALSE;
  672. if (NULL != lpData && dwDataSize == sizeof(KServerAccountUserLoginInfo))
  673. {
  674. KServerAccountUserLoginInfo* pAccInfo = (KServerAccountUserLoginInfo*)(lpData);
  675. if (pAccInfo->Version == ACCOUNT_CURRENT_VERSION &&
  676. pAccInfo->Type == ServerAccountUserLoginInfo)
  677. {
  678. KAccountUserReturn aReturn;
  679. aReturn.Size = sizeof(KAccountUserReturn);
  680. aReturn.Type = AccountUserReturn;
  681. aReturn.Operate = pAccInfo->Operate;
  682. memcpy(aReturn.Account, pAccInfo->Account, LOGIN_USER_ACCOUNT_MAX_LEN);
  683. DWORD nGameID = 0;
  684. aReturn.nReturn = S3PAccount::ServerLogin(pConn, pAccInfo->Account, pAccInfo->Password, m_Address, m_Port, pAccInfo->MacAddress, nGameID);
  686. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  688. in_addr ar;
  689. ar.s_addr = m_Address;
  691. if (aReturn.nReturn == ACTION_SUCCESS)
  692. {
  693. assert(nGameID > 0);
  694. if (pSocket->FindGatewayByID(nGameID) == NULL)
  695. {
  696. m_ServerName = pAccInfo->Account;
  697. m_nGameID = nGameID;
  698. bRet = TRUE;
  699. }
  700. else
  701. {
  702. aReturn.nReturn = E_ACCOUNT_EXIST;
  703. }
  704. }
  706. char szmac[15];
  707. sprintf(szmac, "%02X%02X-%02X%02X-%02X%02X", pAccInfo->MacAddress[0], pAccInfo->MacAddress[1], pAccInfo->MacAddress[2], pAccInfo->MacAddress[3], pAccInfo->MacAddress[4], pAccInfo->MacAddress[5]);
  708. szmac[14] = 0;
  709. if (bRet)
  710. gTrace("Relay %s(%s)%s: Verify OK !", m_ServerName.c_str(), inet_ntoa(ar), szmac);
  711. else
  712. {
  713. if (aReturn.nReturn == E_ACCOUNT_EXIST)
  714. gTrace("Relay %s(%s)%s: Already login !", m_ServerName.c_str(), inet_ntoa(ar), szmac);
  715. else if (aReturn.nReturn == E_ACCOUNT_OR_PASSWORD)
  716. gTrace("Relay %s(%s)%s: Name, Password !", m_ServerName.c_str(), inet_ntoa(ar), szmac);
  717. else if (aReturn.nReturn == E_ADDRESS_OR_PORT)
  718. gTrace("Relay %s(%s)%s: Address, Port !", m_ServerName.c_str(), inet_ntoa(ar), szmac);
  719. }
  721. pSocket->CustomSend(m_nClientID, s2c_gatewayverify, &aReturn);
  722. }
  723. else
  724. gTrace("Protocol %d data is error", c2s_gatewayverify);
  725. }
  726. else
  727. gTrace("Protocol %d data is error", c2s_gatewayverify);
  728. return bRet;
  729. }
  731. BOOL KGatewayDataProcess::ProRelayClose(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  732. {
  733. BOOL bRet = FALSE;
  734. if (NULL != lpData && dwDataSize == sizeof(KAccountUser))
  735. {
  736. KAccountUser* pAccInfo = (KAccountUser*)(lpData);
  737. if (pAccInfo->Version == ACCOUNT_CURRENT_VERSION &&
  738. pAccInfo->Type == AccountUser)
  739. {
  740. S3PAccount::ServerLogout(pConn, pAccInfo->Operate, 0);
  742. bRet = TRUE;
  743. KPISetEvent(m_hClosed);
  744. }
  745. }
  746. return bRet;
  747. }
  749. BOOL KGatewayDataProcess::ProRelayInfo(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  750. {
  751. BOOL bRet = FALSE;
  752. if (NULL != lpData && dwDataSize == sizeof(KServerInfo))
  753. {
  754. KServerInfo* pSerInfo = (KServerInfo*)(lpData);
  755. if (pSerInfo->Version == ACCOUNT_CURRENT_VERSION &&
  756. pSerInfo->Type == ServerInfo)
  757. {
  758. DWORD dValue = 0;
  759. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  760. unsigned long nGameID;
  761. if (pSerInfo->nServerType & server_OnlinePlayerCount)
  762. {
  763. nGameID = 0;
  764. pSocket->FindGatewayByServerName(pSerInfo->Account, nGameID);
  765. S3PAccount::GetAccountCount(pConn, nGameID, TRUE, dValue);
  766. }
  767. else if (pSerInfo->nServerType & server_RegisterCount)
  768. {
  769. //所有注册用户
  770. S3PAccount::GetAccountCount(pConn, 0, FALSE, dValue);
  771. }
  772. else if (pSerInfo->nServerType & server_PlayerWhere)
  773. {
  774. DWORD nID = 0;
  775. int iRet = S3PAccount::GetAccountGameID(pConn, pSerInfo->Account, nID);
  776. if (iRet == E_ACCOUNT_OR_PASSWORD)
  777. dValue = 0xFFFFFFFF;
  778. else if (iRet == ACTION_SUCCESS)
  779. {
  780. if (nID >= 0)
  781. {
  782. KGatewayDataProcess* p = pSocket->FindGatewayByID(nID);
  783. if (p)
  784. {
  785. dValue = p->m_Address;
  786. }
  787. }
  788. else
  789. dValue = 0;
  790. }
  791. }
  792. else if (pSerInfo->nServerType & server_PlayerWhereID)
  793. {
  794. DWORD nID = 0;
  795. int iRet = S3PAccount::GetAccountGameID(pConn, pSerInfo->Account, nID);
  796. if (iRet == E_ACCOUNT_OR_PASSWORD)
  797. dValue = 0xFFFFFFFF;
  798. else if (iRet == ACTION_SUCCESS)
  799. {
  800. if (nID >= 0)
  801. {
  802. KGatewayDataProcess* p = pSocket->FindGatewayByID(nID);
  803. if (p)
  804. {
  805. dValue = p->m_nClientID;
  806. }
  807. }
  808. else
  809. dValue = 0xFFFFFFFF;
  810. }
  811. }
  812. else if (pSerInfo->nServerType & server_GWRelayID)
  813. {
  814. if (pSocket->FindGatewayByServerName(pSerInfo->Account, nGameID))
  815. {
  816. if (nGameID >= 0)
  817. {
  818. KGatewayDataProcess* p = pSocket->FindGatewayByID(nGameID);
  819. if (p)
  820. {
  821. dValue = p->m_nClientID;
  822. }
  823. }
  824. else
  825. dValue = 0xFFFFFFFF;
  826. }
  827. }
  828. else
  829. assert(0);
  831. KServerInfo aReturn;
  832. aReturn.Size = sizeof(KServerInfo);
  833. aReturn.Type = ServerInfo;
  834. aReturn.Operate = 0;
  835. aReturn.Version = ACCOUNT_CURRENT_VERSION;
  836. strncpy(aReturn.Account, pSerInfo->Account, LOGIN_USER_ACCOUNT_MAX_LEN);
  837. aReturn.nServerType = pSerInfo->nServerType;
  838. aReturn.nValue = dValue;
  840. pSocket->CustomSend(m_nClientID, s2c_gatewayinfo, &aReturn);
  842. bRet = TRUE;
  843. }
  844. else
  845. gTrace("Protocol %d data is error", c2s_gatewayinfo);
  846. }
  847. else
  848. gTrace("Protocol %d data is error", c2s_gatewayinfo);
  849. return bRet;
  850. }
  852. BOOL KGatewayDataProcess::ProAccountLogout(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  853. {
  854. BOOL bRet = FALSE;
  855. if (NULL != lpData && dwDataSize == sizeof(KAccountUserLogout))
  856. {
  857. KAccountUserLogout* pAccInfo = (KAccountUserLogout*)(lpData);
  858. if (pAccInfo->Version == ACCOUNT_CURRENT_VERSION &&
  859. pAccInfo->Type == AccountUserLogout)
  860. {
  861. KAccountUserReturn aReturn;
  862. aReturn.Size = sizeof(KAccountUserReturn);
  863. aReturn.Type = AccountUserReturn;
  864. aReturn.Operate = pAccInfo->Operate;
  865. memcpy(aReturn.Account, pAccInfo->Account, LOGIN_USER_ACCOUNT_MAX_LEN);
  867. aReturn.nReturn = S3PAccount::UnlockAccount(pConn, pAccInfo->Account);
  869. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  870. char* szDetail = NULL;
  871. in_addr ar;
  872. ar.s_addr = m_Address;
  873. if (aReturn.nReturn == ACTION_SUCCESS)
  874. {
  875. bRet = TRUE;
  876. szDetail = " Success !";
  877. }
  878. else
  879. {
  880. szDetail = " Failed !";
  881. }
  883. gTrace("Gateway %s(%s): User %s Unlock%s", m_ServerName.c_str(), inet_ntoa(ar), pAccInfo->Account, szDetail);
  885. pSocket->CustomSend(m_nClientID, s2c_accountlogout, &aReturn);
  886. }
  887. else
  888. gTrace("Protocol %d data is error", c2s_accountlogout);
  889. }
  890. else
  891. gTrace("Protocol %d data is error", c2s_accountlogout);
  892. return bRet;
  893. }
  895. BOOL KGatewayDataProcess::ProGameLogin(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  896. {
  897. BOOL bRet = FALSE;
  898. if (NULL != lpData && dwDataSize == sizeof(KAccountUser))
  899. {
  900. KAccountUser* pAccInfo = (KAccountUser*)(lpData);
  901. if (pAccInfo->Version == ACCOUNT_CURRENT_VERSION &&
  902. pAccInfo->Type == AccountUser)
  903. {
  904. KAccountUserReturn aReturn;
  905. aReturn.Size = sizeof(KAccountUserReturn);
  906. aReturn.Type = AccountUserReturn;
  907. aReturn.Operate = pAccInfo->Operate;
  908. memcpy(aReturn.Account, pAccInfo->Account, LOGIN_USER_ACCOUNT_MAX_LEN);
  909. aReturn.nReturn = S3PAccount::FreezeAccount(pConn, pAccInfo->Account);
  911. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  913. char* szDetail = NULL;
  914. in_addr ar;
  915. ar.s_addr = m_Address;
  916. if (aReturn.nReturn == ACTION_SUCCESS)
  917. {
  918. bRet = TRUE;
  919. char szS[200];
  920. sprintf(szS, "GlobalExecute("dw KickOutAccount([[%s]])")", pAccInfo->Account);
  921. ExecuteAction(szS);//踢人
  922. gTrace("Account(%s) is KickOff!", pAccInfo->Account);
  923. szDetail = " Success !";
  924. }
  925. else
  926. {
  927. szDetail = " Failed !";
  928. }
  930. gTrace("Gateway %s(%s): User %s Freeze Account%s", m_ServerName.c_str(), inet_ntoa(ar), pAccInfo->Account, szDetail);
  932. pSocket->CustomSend(m_nClientID, s2c_gamelogin, &aReturn);
  933. }
  934. else
  935. gTrace("Protocol %d data is error", c2s_gamelogin);
  936. }
  937. else
  938. gTrace("Protocol %d data is error", c2s_gamelogin);
  939. return bRet;
  940. }
  942. BOOL KGatewayDataProcess::ProRelayIPData(const IBYTE* lpData, const DWORD dwDataSize)
  943. {
  944. BOOL bRet = FALSE;
  945. if (NULL != lpData && dwDataSize >= sizeof(RELAY_DATA))
  946. {
  947. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  949. RELAY_DATA* pIPData = (RELAY_DATA*)lpData;
  950. if (pIPData->routeDateLength + sizeof(RELAY_DATA) != dwDataSize)
  951. return FALSE;
  953. if (pIPData->nFromIP == 0) //刚进入Relay体系，填写nFromIP和nFromRelayID
  954. {
  955. pIPData->nFromIP = m_Address;
  956. pIPData->nFromRelayID = m_nClientID;
  957. }
  959. if (pIPData->nToIP == 0) //目的地已经到达，开始处理实际协议
  960. {
  961. char* pRelayPackage = (char*)(pIPData + 1);
  962. ProcessClientData(pRelayPackage, pIPData->routeDateLength);
  963. bRet = TRUE;
  964. }
  965. else if (pIPData->nToIP == pSocket->m_SelfAddress) //最后一个Relay
  966. {
  967. DWORD nClient = pIPData->nToRelayID;
  968. pIPData->nToIP = 0;
  969. pIPData->nToRelayID = 0;
  971. pSocket->SendData(nClient, pIPData, dwDataSize);
  972. bRet = TRUE;
  973. }
  974. else
  975. {
  976. DWORD nClient = 0;
  977. if (pSocket->FindGatewayClientByAddress(pIPData->nToIP, nClient))
  978. {
  979. pSocket->SendData(nClient, pIPData, dwDataSize);
  980. bRet = TRUE;
  981. }
  982. }
  983. }
  984. return bRet;
  985. }
  987. BOOL KGatewayDataProcess::ProRelayAskData(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  988. {
  989. BOOL bRet = FALSE;
  990. if (NULL != lpData && dwDataSize >= sizeof(RELAY_ASKWAY_DATA))
  991. {
  992. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  994. RELAY_ASKWAY_DATA* pIPData = (RELAY_ASKWAY_DATA*)lpData;
  996. if (pIPData->routeDateLength + pIPData->wMethodDataLength + sizeof(RELAY_ASKWAY_DATA) != dwDataSize)
  997. return FALSE;
  999. if (pIPData->seekMethod == rm_account_id ||
  1000. pIPData->seekMethod == rm_gm)
  1001. {
  1002. if (pIPData->nFromIP == 0) //刚进入Relay体系，填写nFromIP和nFromRelayID
  1003. {
  1004. pIPData->nFromIP = m_Address;
  1005. pIPData->nFromRelayID = m_nClientID;
  1006. }
  1008. KGatewayDataProcess* p = NULL;
  1010. if (pIPData->seekMethod == rm_account_id)
  1011. {
  1012. DWORD nGameID = 0;
  1013. char name[33];
  1014. strncpy(name, lpData + sizeof(RELAY_ASKWAY_DATA), 32);
  1015. if (ACTION_SUCCESS == S3PAccount::GetAccountGameID(pConn, name, nGameID))
  1016. p = pSocket->FindGatewayByID(nGameID);
  1017. }
  1018. else if (pIPData->seekMethod == rm_gm)
  1019. {
  1020. pSocket->BroadGMData(lpData, dwDataSize);
  1021. bRet = TRUE;
  1022. }
  1024. if (p)
  1025. {
  1026. pSocket->SendData(p->m_nClientID, lpData, dwDataSize);
  1027. bRet = TRUE;
  1028. }
  1029. }
  1031. if (!bRet) //地址不可达，通知来源relay_s2c_loseway
  1032. {
  1033. size_t sizeLose = sizeof(RELAY_DATA) + dwDataSize;
  1034. RELAY_DATA* pLoseData = (RELAY_DATA*)_alloca(sizeLose);
  1036. pLoseData->ProtocolFamily = pIPData->ProtocolFamily;
  1037. pLoseData->ProtocolID = relay_s2c_loseway;
  1038. pLoseData->nToIP = pIPData->nFromIP;
  1039. pLoseData->nToRelayID = pIPData->nFromRelayID;
  1040. pLoseData->nFromIP = pSocket->m_SelfAddress;
  1041. pLoseData->nFromRelayID = -1;
  1042. pLoseData->routeDateLength = dwDataSize;
  1043. memcpy(pLoseData + 1, pIPData, dwDataSize);
  1045. pSocket->SendData(m_nClientID, pLoseData, sizeLose);
  1046. }
  1047. }
  1048. return bRet;
  1049. }
  1051. BOOL KGatewayDataProcess::ProGMFamily(S3PDBConVBC* pConn, const IBYTE* lpData, const DWORD dwDataSize)
  1052. {
  1053. int nResult = ACTION_SUCCESS;
  1054. switch(((GM_HEADER*)lpData)->ProtocolType)
  1055. {
  1056. case gm_c2s_execute:
  1057. _ASSERT(0);
  1058. break;
  1059. case gm_c2s_disable:
  1060. _ASSERT(0);
  1061. break;
  1062. case gm_c2s_enable:
  1063. _ASSERT(0);
  1064. break;
  1065. case gm_c2s_tracking:
  1066. _ASSERT(0);
  1067. break;
  1068. case gm_c2s_setrole:
  1069. _ASSERT(0);
  1070. break;
  1071. case gm_c2s_getrole:
  1072. _ASSERT(0);
  1073. break;
  1074. case gm_c2s_findplayer:
  1075. _ASSERT(0);
  1076. break;
  1077. case gm_c2s_unlock:
  1078. {
  1079. DWORD nGameID = 0;
  1080. S3PAccount::GetServerID(pConn, ((GM_UNLOCK_ACCOUNT*)lpData)->AccountName, nGameID);
  1081. if (nGameID > 0)
  1082. {
  1083. nResult = S3PAccount::UnlockServer(pConn, nGameID);
  1084. }
  1085. }
  1086. break;
  1087. default:
  1088. _ASSERT(0);
  1089. break;
  1090. }
  1091. return (ACTION_SUCCESS == nResult);
  1092. }
  1094. S3PDBConVBC* KGatewayDataProcess::GetDB(DWORD nSleep)
  1095. {
  1096. if (!m_pConn)
  1097. {
  1098. S3PDBConnectionPool* pDB = S3PDBConnectionPool::Instance();
  1099. if (nSleep)
  1100. {
  1101. while (m_pConn == NULL)
  1102. {
  1103. pDB->RemoveDBCon(&m_pConn);
  1104. Sleep(nSleep);
  1105. }
  1106. }
  1107. else
  1108. pDB->RemoveDBCon(&m_pConn);
  1109. }
  1111. return m_pConn;
  1112. }
  1114. DWORD KGatewayDataProcess::Main(LPVOID lpParam)
  1115. {
  1116. assert(m_hStop);
  1117. assert(m_pServer);
  1118. DWORD dwRet = 0;
  1119. DWORD LastTime = GetTickCount();
  1121. S3PDBConnectionPool* pDB = S3PDBConnectionPool::Instance();
  1123. BOOL bValidID = CheckConnectAddress();
  1125. while (bValidID)
  1126. {
  1127. DWORD dwResult =
  1128. KPIWaitForSingleObject(m_hStop, 0);
  1129. if (dwResult == 1)
  1130. break;
  1131. else if (dwResult == 2)
  1132. {
  1133. size_t datalength = 0;
  1135. const void *pData = m_pServer->GetPackFromClient(m_nClientID, datalength);
  1137. AutoTime();
  1139. if (pData && 0 != datalength)
  1140. {
  1141. ProcessClientData(pData, datalength);
  1142. LastTime = GetTickCount();
  1143. }
  1144. else
  1145. {
  1146. if (GetTickCount() - LastTime >= 1000)
  1147. {
  1148. if (m_pConn)
  1149. {
  1150. if (pDB->ReturnDBCon(m_pConn))
  1151. m_pConn = NULL;
  1152. }
  1153. }
  1154. Sleep(1);
  1155. }
  1156. }
  1157. }
  1159. Close();
  1161. if (m_pConn)
  1162. {
  1163. if (pDB->ReturnDBCon(m_pConn))
  1164. m_pConn = NULL;
  1165. }
  1167. m_pServer->ShutdownClient(m_nClientID);
  1169. return dwRet;
  1170. }
  1172. HANDLE KGatewayDataProcess::Start(IServer* pServer)
  1173. {
  1174. assert(pServer);
  1175. if (NULL == m_pServer)
  1176. {
  1177. m_pServer = pServer;
  1178. pServer->AddRef();
  1179. }
  1181. return KThread::Start();
  1182. }
  1184. BOOL KGatewayDataProcess::Stop()
  1185. {
  1186. BOOL bRet = KThread::Stop();
  1187. if (bRet && m_pServer)
  1188. {
  1189. m_pServer->Release();
  1190. m_pServer = NULL;
  1191. }
  1193. return bRet;
  1194. }
  1196. BOOL KGatewayDataProcess::ProAutoTime(S3PDBConVBC* pConn)
  1197. {
  1198. BOOL bRet = FALSE;
  1199. DWORD dwMin = 0;
  1200. dwMin = 1800; //默认30分钟
  1201. char szMessage[128];
  1202. if (dwMin > 0)
  1203. {
  1204. AccountTimeList TimeList;
  1205. if (S3PAccount::GetAccountsTime(pConn, m_nGameID, dwMin, TimeList) == ACTION_SUCCESS)
  1206. {
  1207. AccountTimeList::iterator i = TimeList.begin();
  1208. while (i != TimeList.end())
  1209. {
  1210. if (i->nTime == 0) //踢人
  1211. {
  1212. char szS[200];
  1213. sprintf(szS, "GlobalExecute("dw KickOutAccount([[%s]])")", i->Account);
  1214. ExecuteAction(szS);//踢人
  1215. gTrace("Account(%s) is KickOff!", i->Account);
  1216. }
  1217. else //催促充值
  1218. {
  1219. int nLen = 0;
  1220. if (i->nTime >= 60)
  1221. nLen = sprintf(szMessage, "您在游戏中还可以停留%d分钟, 请赶快充值!", i->nTime / 60);
  1222. else
  1223. nLen = sprintf(szMessage, "您在游戏中还可以停留%d秒, 请赶快充值!", i->nTime);
  1224. SendSystemInfo(m_nClientID, i->Account, "GM", szMessage, nLen);
  1225. }
  1226. i++;
  1227. }
  1228. bRet = TRUE;
  1229. }
  1230. }
  1231. return bRet;
  1232. }
  1234. void KGatewayDataProcess::ExecuteAction(char* szAccount, char* szScript)
  1235. {
  1236. int nszLen = 0;
  1237. if (szScript)
  1238. nszLen = strlen(szScript);
  1239. GM_EXECUTE_COMMAND exe;
  1240. exe.ProtocolFamily = pf_gamemaster;
  1241. exe.ProtocolType = gm_c2s_execute;
  1242. strncpy(exe.AccountName, szAccount, LOGIN_USER_ACCOUNT_MAX_LEN);
  1243. exe.wLength = nszLen;
  1244. exe.wExecuteID = 1;
  1246. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  1248. pSocket->SendRelayData(m_nClientID, szAccount, &exe, sizeof(exe), szScript, nszLen);
  1249. }
  1251. void KGatewayDataProcess::ExecuteAction(char* szScript)
  1252. {
  1253. int nszLen = 0;
  1254. if (szScript)
  1255. nszLen = strlen(szScript);
  1256. GM_EXECUTE_COMMAND exe;
  1257. exe.ProtocolFamily = pf_gamemaster;
  1258. exe.ProtocolType = gm_c2s_execute;
  1259. strncpy(exe.AccountName, "GM", LOGIN_USER_ACCOUNT_MAX_LEN);
  1260. exe.wLength = nszLen;
  1261. exe.wExecuteID = 1;
  1263. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  1265. pSocket->SendRelayData(m_nClientID, &exe, sizeof(exe), szScript, nszLen);
  1266. }
  1268. void KGatewayDataProcess::SendSystemInfo(unsigned long uID, char* szAccount, char *lpszSendName, char *lpszSentence, int nSentenceLength)
  1269. {
  1270. size_t chatsize = 1 + sizeof(CHAT_CHANNELCHAT_SYNC) + nSentenceLength;
  1272. BYTE* pFamily = (BYTE*)_alloca(chatsize);
  1273. *pFamily = pf_chat;
  1274. CHAT_CHANNELCHAT_SYNC* pCccSync= (CHAT_CHANNELCHAT_SYNC*)(pFamily + 1);
  1275. pCccSync->ProtocolType = chat_channelchat;
  1276. pCccSync->wSize = chatsize - 1;
  1277. pCccSync->packageID = -1;
  1278. strncpy(pCccSync->someone, lpszSendName, _NAME_LEN - 1); // 可能需要根据玩家身份改动
  1279. pCccSync->channelid = -1;
  1280. pCccSync->sentlen = nSentenceLength;
  1281. memcpy(pCccSync + 1, lpszSentence, nSentenceLength);
  1283. S3PDBSocketPool* pSocket = S3PDBSocketPool::Instance();
  1285. pSocket->SendRelayData(uID, szAccount, pFamily, chatsize, NULL, 0);
  1286. }