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

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

模拟服务器

开发平台：

C/C++

Global.cpp：源码内容
  1. // Global.cpp: implementation of the CGlobal class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Global.h"
  7. #include "S3Relay.h"
  9. #include <map>
  11. #include "../../../Headers/inoutmac.h"
  13. #include "DoScript.h"
  16. //////////////////////////////////////////////////////////////////////
  17. //////////////////////////////////////////////////////////////////////
  21. const _localmask = 0x0000FFFF;
  22. const _localtag = 0x0000A8C0;
  25. const DWORD delay_reclient = 30000;
  28. ////////////
  29. //variants
  32. CMemory g_memory;
  34. CHeavenLib g_libHeaven;
  35. CRainbowLib g_libRainbow;
  38. CSockThread g_threadSock;
  41. CRelayCenter g_RelayCenter;
  42. CRelayServer g_RelayServer;
  44. CRootCenter g_RootCenter;
  45. CRootClient g_RootClient(&g_RootCenter, FALSE);
  47. CDBCenter g_DBCenter;
  48. CDBClient g_DBClient(&g_DBCenter, FALSE);
  50. CGatewayCenter g_GatewayCenter;
  51. CGatewayClient g_GatewayClient(&g_GatewayCenter, FALSE);
  53. CHostServer g_HostServer;
  54. CTongServer g_TongServer;
  55. CChatServer g_ChatServer;
  57. CChannelMgr g_ChannelMgr;
  58. CFriendMgr g_FriendMgr;
  60. CTongSet g_cTongSet;
  64. //////////////////////////////////////////////////
  67. const char file_relaycfg[] = "relay_config.ini";
  70. const char sec_gateway[] = "gateway";
  71. const char sec_relay[] = "relay";
  72. const char sec_root[] = "root";
  73. const char sec_host[] = "host";
  74. const char sec_tong[] = "tong";
  75. const char sec_chat[] = "chat";
  76. const char sec_dbrole[] = "dbrole";
  79. const char key_ip[] = "ip";
  80. const char key_address[] = "address";
  81. const char key_playercnt[] = "playercnt";
  82. const char key_precision[] = "precision";
  83. const char key_freebuffer[] = "freebuffer";
  84. const char key_buffersize[] = "buffersize";
  85. const char key_account[] = "account";
  86. const char key_password[] = "password";
  87. const char key_retryinterval[] = "retryinterval";
  91. /////////////////////////////////////////////////
  93. static gs_reclient_enable = FALSE;
  95. static UINT gs_timerRoot = 0;
  96. static UINT gs_timerGateway = 0;
  97. static UINT gs_timerDB = 0;
  98. static UINT gs_timerFriendUdtDB = 0;
  102. /////////////////////////////////////////////////
  105. HWND gGetMainWnd();
  106. HWND gGetListBox();
  109. /////////////////////////////////////////////////
  110. // functions
  112. std::_tstring gGetLocateDirectory()
  113. {
  114. static struct _LOCALDIR
  115. {
  116. std::_tstring path;
  118. _LOCALDIR()
  119. {
  120. TCHAR buff[_MAX_PATH] = {0};
  121. ::GetModuleFileName(NULL, buff, _MAX_PATH);
  122. TCHAR* pCh = _tcsrchr(buff, _T('\'));
  123. assert(pCh);
  124. *(pCh + 1) = 0;
  125. path = buff;
  127. assert(!path.empty());
  128. }
  129. } s_locdir;
  131. return s_locdir.path;
  132. }
  135. std::_tstring gGetPrivateProfileStringEx(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpFileName, LPCSTR lpDefault)
  136. {
  137. std::_tstring path = gGetLocateDirectory() + lpFileName;
  139. TCHAR buffer[_MAX_PATH] = {0};
  140. ::GetPrivateProfileString(lpAppName, lpKeyName, lpDefault, buffer, _MAX_PATH, path.c_str());
  141. return buffer;
  142. }
  143. INT gGetPrivateProfileIntEx(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpFileName, INT nDefault)
  144. {
  145. std::_tstring path = gGetLocateDirectory() + lpFileName;
  147. return ::GetPrivateProfileInt(lpAppName, lpKeyName, nDefault, path.c_str());
  148. }
  150. TCHAR gGetPrivateProfileCharEx(LPCSTR lpAppName, LPCSTR lpKeyName, LPCSTR lpFileName, TCHAR chDefault)
  151. {
  152. std::_tstring theStr = ::gGetPrivateProfileStringEx(lpAppName, lpKeyName, lpFileName);
  154. return theStr.empty() ? chDefault : theStr[0];
  155. }
  157. const std::vector<std::_tstring>& gGetPrivateProfileSectionEx(LPCTSTR lpAppName, LPCTSTR lpFileName)
  158. {
  159. std::_tstring path = gGetLocateDirectory() + lpFileName;
  162. static std::vector<std::_tstring> s_vecstr;
  163. s_vecstr.clear();
  165. const DWORD MAX_BUFFSIZE = 4096;
  166. char buff[MAX_BUFFSIZE];
  167. DWORD cch = ::GetPrivateProfileSection(lpAppName, buff, MAX_BUFFSIZE, path.c_str());
  169. for (char* pc = buff; *pc != 0; pc += strlen(pc))
  170. s_vecstr.push_back(pc);
  172. return s_vecstr;
  173. }
  175. const std::vector<std::_tstring>& gGetPrivateProfileSectionNamesEx(LPCTSTR lpFileName)
  176. {
  177. std::_tstring path = gGetLocateDirectory() + lpFileName;
  180. static std::vector<std::_tstring> s_vecstr;
  181. s_vecstr.clear();
  183. const DWORD MAX_BUFFSIZE = 4096;
  184. char buff[MAX_BUFFSIZE];
  185. DWORD cch = ::GetPrivateProfileSectionNames(buff, MAX_BUFFSIZE, path.c_str());
  187. for (char* pc = buff; *pc != 0; pc += s_vecstr.back().size())
  188. s_vecstr.push_back(pc);
  190. return s_vecstr;
  191. }
  196. BOOL gInitialize()
  197. {
  198. InitScript();
  200. gs_reclient_enable = TRUE;
  203. //check the netcard, need 1 at least
  204. if (gGetMacAndIPAddress(NULL, NULL, NULL, NULL, _localtag, 0) <= 0)
  205. return FALSE;
  208. if (!g_memory.Initialize())
  209. return FALSE;
  212. if (!g_libHeaven.Initialize())
  213. return FALSE;
  214. if (!g_libRainbow.Initialize())
  215. return FALSE;
  218. if (!g_ChannelMgr.Initialize())
  219. return FALSE;
  220. if (!g_FriendMgr.Initialize())
  221. return FALSE;
  224. const size_t playercntRelay = gGetPrivateProfileIntEx(sec_relay, key_playercnt, file_relaycfg, 0);
  225. const size_t precisionRelay = gGetPrivateProfileIntEx(sec_relay, key_precision, file_relaycfg, 0);
  226. const size_t freebufferRelay = gGetPrivateProfileIntEx(sec_relay, key_freebuffer, file_relaycfg, 0);
  227. const size_t buffersizeRelay = gGetPrivateProfileIntEx(sec_relay, key_buffersize, file_relaycfg, 0);
  228. const DWORD listenaddrRelay = INADDR_ANY;
  229. const unsigned short listenportRelay = RELAY_SIBLING_PORT;
  231. if (!g_RelayCenter.Initialize())
  232. return FALSE;
  233. if (!g_RelayServer.Startup(playercntRelay, precisionRelay, freebufferRelay, buffersizeRelay, listenaddrRelay, listenportRelay))
  234. {
  235. rTRACE("FAIL: relay server");
  236. //return FALSE;
  237. }
  240. const size_t freebufferRoot = gGetPrivateProfileIntEx(sec_root, key_freebuffer, file_relaycfg, 0);
  241. const size_t buffersizeRoot = gGetPrivateProfileIntEx(sec_root, key_buffersize, file_relaycfg, 0);
  242. std::_tstring addrRoot = gGetPrivateProfileStringEx(sec_root, key_address, file_relaycfg);
  243. const unsigned short portRoot = RELAY_ROUTE_PORT;
  245. if (!g_RootCenter.Initialize())
  246. return FALSE;
  247. if (!g_RootClient.Startup(freebufferRoot, buffersizeRoot, addrRoot.c_str(), portRoot))
  248. {
  249. rTRACE("FAIL: root client - %s", addrRoot.c_str());
  250. gOnOneClientClose(oneclient_root);
  251. //return FALSE;
  252. }
  255. const size_t freebufferDB = gGetPrivateProfileIntEx(sec_dbrole, key_freebuffer, file_relaycfg, 0);
  256. const size_t buffersizeDB = gGetPrivateProfileIntEx(sec_dbrole, key_buffersize, file_relaycfg, 0);
  257. std::_tstring addrDB = gGetPrivateProfileStringEx(sec_dbrole, key_address, file_relaycfg);
  258. const unsigned short portDB = ROLEDBSVR_ROLEDB_PORT;
  260. if (!g_DBCenter.Initialize())
  261. return FALSE;
  262. if (!g_DBClient.Startup(freebufferDB, buffersizeDB, addrDB.c_str(), portDB))
  263. {
  264. rTRACE("FAIL: DBRole client - %s", addrDB.c_str());
  265. gOnOneClientClose(oneclient_db);
  266. //return FALSE;
  267. }
  270. const size_t freebufferGateway = gGetPrivateProfileIntEx(sec_gateway, key_freebuffer, file_relaycfg, 0);
  271. const size_t buffersizeGateway = gGetPrivateProfileIntEx(sec_gateway, key_buffersize, file_relaycfg, 0);
  272. std::_tstring addrGateway = gGetPrivateProfileStringEx(sec_gateway, key_address, file_relaycfg);
  273. const unsigned short portGateway = GATEWAY_GAMESVR_SERVICE_PORT;
  275. if (!g_GatewayCenter.Initialize())
  276. return FALSE;
  277. if (!g_GatewayClient.Startup(freebufferGateway, buffersizeGateway, addrGateway.c_str(), portGateway))
  278. {
  279. rTRACE("FAIL: gateway client - %s", addrGateway.c_str());
  280. gOnOneClientClose(oneclient_gateway);
  281. //return FALSE;
  282. }
  285. const size_t playercntHost = gGetPrivateProfileIntEx(sec_host, key_playercnt, file_relaycfg, 0);
  286. const size_t precisionHost = gGetPrivateProfileIntEx(sec_host, key_precision, file_relaycfg, 0);
  287. const size_t freebufferHost = gGetPrivateProfileIntEx(sec_host, key_freebuffer, file_relaycfg, 0);
  288. const size_t buffersizeHost = gGetPrivateProfileIntEx(sec_host, key_buffersize, file_relaycfg, 0);
  289. const DWORD listenaddrHost = INADDR_ANY;
  290. const unsigned short listenportHost = RELAY_GAMESVR_SERVICE_PORT;
  292. if (!g_HostServer.Startup(playercntHost, precisionHost, freebufferHost, buffersizeHost, listenaddrHost, listenportHost))
  293. {
  294. rTRACE("FAIL: host server");
  295. //return FALSE;
  296. }
  299. const size_t playercntTong = gGetPrivateProfileIntEx(sec_tong, key_playercnt, file_relaycfg, 0);
  300. const size_t precisionTong = gGetPrivateProfileIntEx(sec_tong, key_precision, file_relaycfg, 0);
  301. const size_t freebufferTong = gGetPrivateProfileIntEx(sec_tong, key_freebuffer, file_relaycfg, 0);
  302. const size_t buffersizeTong = gGetPrivateProfileIntEx(sec_tong, key_buffersize, file_relaycfg, 0);
  303. const DWORD listenaddrTong = INADDR_ANY;
  304. const unsigned short listenportTong = RELAY_GAMESVR_TONGSERVICE_PORT;
  306. if (!g_TongServer.Startup(playercntTong, precisionTong, freebufferTong, buffersizeTong, listenaddrTong, listenportTong))
  307. {
  308. rTRACE("FAIL: tong server");
  309. //return FALSE;
  310. }
  313. const size_t playercntChat = gGetPrivateProfileIntEx(sec_chat, key_playercnt, file_relaycfg, 0);
  314. const size_t precisionChat = gGetPrivateProfileIntEx(sec_chat, key_precision, file_relaycfg, 0);
  315. const size_t freebufferChat = gGetPrivateProfileIntEx(sec_chat, key_freebuffer, file_relaycfg, 0);
  316. const size_t buffersizeChat = gGetPrivateProfileIntEx(sec_chat, key_buffersize, file_relaycfg, 0);
  317. const DWORD listenaddrChat = INADDR_ANY;
  318. const unsigned short listenportChat = RELAY_GAMESVR_CHATSERVICE_PORT;
  320. if (!g_ChatServer.Startup(playercntChat, precisionChat, freebufferChat, buffersizeChat, listenaddrChat, listenportChat))
  321. {
  322. rTRACE("FAIL: chat server");
  323. //return FALSE;
  324. }
  326. #ifdef _WORKMODE_SINGLETHREAD
  327. if (!g_threadSock.Start())
  328. return FALSE;
  329. #endif
  331. // 帮会数据初始化
  332. if (g_cTongDB.Open())
  333. {
  334. rTRACE("tong database open ok!");
  335. if (g_cTongSet.InitFromDB())
  336. rTRACE("tongset init ok !");
  337. else
  338. rTRACE("FAIL: tongset init error!!!");
  339. }
  340. else
  341. {
  342. rTRACE("FAIL: tong database open error!!!");
  343. }
  345. return TRUE;
  346. }
  348. BOOL gUninitialize()
  349. {
  350. UninitScript();
  352. try
  353. {
  354. //disable reclient timer
  355. gOnOneClientCreate(oneclient_root);
  356. gOnOneClientCreate(oneclient_gateway);
  357. gOnOneClientCreate(oneclient_db);
  360. gs_reclient_enable = FALSE;
  363. #ifdef _WORKMODE_SINGLETHREAD
  364. g_threadSock.Stop();
  365. #endif
  368. g_ChatServer.Shutdown();
  369. g_TongServer.Shutdown();
  370. g_HostServer.Shutdown();
  372. g_GatewayClient.Shutdown();
  373. g_GatewayCenter.Uninitialize();
  375. g_DBClient.Shutdown();
  376. g_DBCenter.Uninitialize();
  378. g_RootClient.Shutdown();
  379. g_RootCenter.Uninitialize();
  381. g_RelayServer.Shutdown();
  382. g_RelayCenter.Uninitialize();
  386. //delay
  387. ::Sleep(2000);
  391. g_ChannelMgr.Uninitialize();
  392. g_FriendMgr.Uninitialize();
  395. g_libRainbow.Uninitialize();
  396. g_libHeaven.Uninitialize();
  398. g_memory.Uninitialize();
  400. g_cTongDB.Close();
  402. }
  403. catch (...)
  404. {
  405. return FALSE;
  406. }
  408. return TRUE;
  409. }
  412. BOOL gIsLocalIP(DWORD ip)
  413. {
  414. return (ip & _localmask) == _localtag;
  415. }
  418. const UCHAR* gGetHostMac(int adapt, size_t* pSize)
  419. {
  420. static struct _MACSTORE
  421. {
  422. enum {MAC_SIZE = 6};
  424. UCHAR macLocal[MAC_SIZE];
  425. UCHAR macGlobal[MAC_SIZE];
  428. _MACSTORE()
  429. {
  430. memset(macLocal, 0, sizeof(macLocal));
  431. memset(macGlobal, 0, sizeof(macGlobal));
  433. gGetMacAndIPAddress(macLocal, NULL, macGlobal, NULL, _localtag, MAC_SIZE);
  434. }
  435. } _macstore;
  437. if (!pSize == NULL)
  438. *pSize = _MACSTORE::MAC_SIZE;
  440. switch (adapt)
  441. {
  442. case local_adapt: return _macstore.macLocal;
  443. case global_adapt: return _macstore.macGlobal;
  444. }
  446. if (!pSize == NULL)
  447. *pSize = 0;
  449. assert(FALSE);
  450. return NULL;
  451. }
  454. DWORD gGetHostIP(int adapt)
  455. {
  456. static struct _IPSTORE
  457. {
  458. DWORD ipLocal;
  459. DWORD ipGlobal;
  461. _IPSTORE() : ipLocal(0), ipGlobal(0)
  462. {
  463. gGetMacAndIPAddress(NULL, &ipLocal, NULL, &ipGlobal, _localtag, 0);
  464. }
  465. } _ipstore;
  467. switch (adapt)
  468. {
  469. case local_adapt: return _ipstore.ipLocal;
  470. case global_adapt: return _ipstore.ipGlobal;
  471. }
  473. assert(FALSE);
  474. return 0;
  475. }
  479. BOOL gConnectToSibling(const char* addr)
  480. {
  481. const size_t freebuffer = gGetPrivateProfileIntEx(sec_relay, key_freebuffer, file_relaycfg, 0);
  482. const size_t buffersize = gGetPrivateProfileIntEx(sec_relay, key_buffersize, file_relaycfg, 0);
  484. CRelayClient* pRelayClient = new CRelayClient(&g_RelayCenter, TRUE);
  485. if (!pRelayClient->Startup(freebuffer, buffersize, addr, RELAY_SIBLING_PORT, FALSE))
  486. return FALSE;
  488. return TRUE;
  489. }
  492. size_t gFillClntwayPckg(DWORD nameid, unsigned long param, 
  493. const RELAY_ASKWAY_DATA* pAskWay, size_t sizeAskWay, RELAY_ASKWAY_DATA* pClntWay, size_t sizeClntWay)
  494. {
  495. assert(sizeAskWay >= sizeof(EXTEND_HEADER));
  496. assert(sizeClntWay >= sizeAskWay + sizeof(DWORD) * 2);
  498. size_t sizeNeed = sizeAskWay + sizeof(DWORD) * 2;
  500. if (sizeClntWay < sizeNeed)
  501. return 0;
  503. *pClntWay = *pAskWay;
  504. pClntWay->seekRelayCount ++;
  506. const void* pMethodData = pAskWay + 1;
  507. void* pMethodDataDup = pClntWay + 1;
  508. memcpy(pMethodDataDup, pMethodData, pAskWay->wMethodDataLength);
  510. DWORD* pp = (DWORD*)((BYTE*)pMethodDataDup + pClntWay->wMethodDataLength);
  511. pp[0] = nameid; pp[1] = param;
  512. pClntWay->wMethodDataLength += sizeof(DWORD) * 2;
  514. const void* pRouteData = (BYTE*)pMethodData + pAskWay->wMethodDataLength;
  515. void* pRouteDataDup = pp + 2;
  516. memcpy(pRouteDataDup, pRouteData, pAskWay->routeDateLength);
  518. return sizeNeed;
  519. }
  521. size_t gFillLosewayPckg(DWORD nToIP, DWORD nToRelayID, 
  522.    const void* pLosePckg, size_t sizeLosePckg, void* pLoseway, size_t sizeLoseway)
  523. {
  524. assert(sizeLosePckg >= sizeof(EXTEND_HEADER));
  525. assert(sizeLoseway >= sizeLosePckg + sizeof(RELAY_DATA));
  527. size_t sizeNeed = sizeLosePckg + sizeof(RELAY_DATA);
  529. if (sizeLoseway < sizeNeed)
  530. return 0;
  532. EXTEND_HEADER* pSrcHdr = (EXTEND_HEADER*)pLosePckg;
  534. RELAY_DATA* pLoseData = (RELAY_DATA*)pLoseway;
  536. pLoseData->ProtocolFamily = pSrcHdr->ProtocolFamily;
  537. pLoseData->ProtocolID = relay_s2c_loseway;
  539. pLoseData->nToIP = nToIP;
  540. pLoseData->nToRelayID = nToRelayID;
  541. pLoseData->nFromIP = 0;
  542. pLoseData->nFromRelayID = -1;
  543. pLoseData->routeDateLength = sizeLosePckg;
  545. void* pRouteData = pLoseData + 1;
  546. memcpy(pRouteData, pLosePckg, sizeLosePckg);
  548. return sizeNeed;
  549. }
  552. BOOL gIsLegalString(LPCTSTR sz, size_t lenlolmt, size_t lenhilmt)
  553. {
  554. if (sz == NULL || lenhilmt < lenlolmt)
  555. return FALSE;
  556. for (size_t pl = 0; pl < lenlolmt; pl++)
  557. if (sz[pl] == 0)
  558. return FALSE;
  559. for (size_t ph = lenlolmt; ph < lenhilmt; ph++)
  560. if (sz[ph] == 0)
  561. return TRUE;
  562. return TRUE;
  563. }
  565. DWORD g_String2Id(LPCSTR pString)
  566. {
  567. DWORD Id = 0;
  568. for (int i = 0; pString[i]; i++)
  569. {
  570. Id = (Id + (i + 1) * pString[i]) % 0x8000000b * 0xffffffef;
  571. }
  572. return Id ^ 0x12345678;
  573. }
  579. BOOL gOnOneClientCreate(ONECLIENT ct)
  580. {
  581. if (!gs_reclient_enable)
  582. return TRUE;
  585. HWND mainwnd = gGetMainWnd();
  586. if (mainwnd == NULL)
  587. return FALSE;
  589. switch (ct)
  590. {
  591. case oneclient_root:
  592. if (gs_timerRoot)
  593. {
  594. if (::KillTimer(mainwnd, gs_timerRoot))
  595. {
  596. gs_timerRoot = 0;
  597. rTRACE("disable reclient: root");
  598. }
  599. }
  600. break;
  601. case oneclient_gateway:
  602. if (gs_timerGateway)
  603. {
  604. if (::KillTimer(mainwnd, gs_timerGateway))
  605. {
  606. gs_timerGateway = 0;
  607. rTRACE("disable reclient: gateway");
  608. }
  609. }
  610. break;
  611. case oneclient_db:
  612. if (gs_timerDB)
  613. {
  614. if (::KillTimer(mainwnd, gs_timerDB))
  615. {
  616. gs_timerDB = 0;
  617. rTRACE("disable reclient: db");
  618. }
  619. }
  620. break;
  621. default:
  622. return FALSE;
  623. }
  625. return TRUE;
  626. }
  628. BOOL gOnOneClientClose(ONECLIENT ct)
  629. {
  630. if (!gs_reclient_enable)
  631. return FALSE;
  633. HWND mainwnd = gGetMainWnd();
  634. if (mainwnd == NULL)
  635. return FALSE;
  637. switch (ct)
  638. {
  639. case oneclient_root:
  640. if (!gs_timerRoot)
  641. {
  642. INT rootinterval = gGetPrivateProfileIntEx(sec_root, key_retryinterval, file_relaycfg, 0);
  643. if (rootinterval > 0)
  644. {
  645. gs_timerRoot = ::SetTimer(mainwnd, timer_rootclient, rootinterval, NULL);
  646. if (!gs_timerRoot)
  647. {
  648. rTRACE("FAIL: enable root reclient");
  649. return FALSE;
  650. }
  651. rTRACE("enable reclient: root");
  652. }
  653. }
  654. break;
  655. case oneclient_gateway:
  656. if (!gs_timerGateway)
  657. {
  658. INT gatewayinterval = gGetPrivateProfileIntEx(sec_gateway, key_retryinterval, file_relaycfg, 0);
  659. if (gatewayinterval > 0)
  660. {
  661. gs_timerGateway = ::SetTimer(mainwnd, timer_gatewayclient, gatewayinterval, NULL);
  662. if (!gs_timerGateway)
  663. {
  664. rTRACE("FAIL: enable gateway reclient");
  665. return FALSE;
  666. }
  667. rTRACE("enable reclient: gateway");
  668. }
  669. }
  670. break;
  671. case oneclient_db:
  672. if (!gs_timerDB)
  673. {
  674. INT dbinterval = gGetPrivateProfileIntEx(sec_dbrole, key_retryinterval, file_relaycfg, 0);
  675. if (dbinterval > 0)
  676. {
  677. gs_timerDB = ::SetTimer(mainwnd, timer_dbclient, dbinterval, NULL);
  678. if (!gs_timerDB)
  679. {
  680. rTRACE("FAIL: enable db reclient");
  681. return FALSE;
  682. }
  683. rTRACE("enable reclient: db");
  684. }
  685. }
  686. break;
  687. default:
  688. return FALSE;
  689. }
  691. return TRUE;
  692. }
  694. BOOL gReOneClient(ONECLIENT ct)
  695. {
  696. if (!gs_reclient_enable)
  697. return FALSE;
  699. switch (ct)
  700. {
  701. case oneclient_root:
  702. {{
  703. if (g_RootClient.IsReady())
  704. return FALSE;
  706. const size_t freebufferRoot = gGetPrivateProfileIntEx(sec_root, key_freebuffer, file_relaycfg, 0);
  707. const size_t buffersizeRoot = gGetPrivateProfileIntEx(sec_root, key_buffersize, file_relaycfg, 0);
  708. std::_tstring addrRoot = gGetPrivateProfileStringEx(sec_root, key_address, file_relaycfg);
  709. const unsigned short portRoot = RELAY_ROUTE_PORT;
  711. rTRACE("try reclient: root - %s", addrRoot.c_str());
  713. if (!g_RootClient.Startup(freebufferRoot, buffersizeRoot, addrRoot.c_str(), portRoot))
  714. {
  715. rTRACE("FAIL: reclient root - %s", addrRoot.c_str());
  716. //return FALSE;
  717. }
  718. }}
  719. break;
  721. case oneclient_gateway:
  722. {{
  723. if (g_GatewayClient.IsReady())
  724. return FALSE;
  726. const size_t freebufferGateway = gGetPrivateProfileIntEx(sec_gateway, key_freebuffer, file_relaycfg, 0);
  727. const size_t buffersizeGateway = gGetPrivateProfileIntEx(sec_gateway, key_buffersize, file_relaycfg, 0);
  728. std::_tstring addrGateway = gGetPrivateProfileStringEx(sec_gateway, key_address, file_relaycfg);
  729. const unsigned short portGateway = GATEWAY_GAMESVR_SERVICE_PORT;
  731. rTRACE("try reclient: gateway - %s", addrGateway.c_str());
  733. if (!g_GatewayClient.Startup(freebufferGateway, buffersizeGateway, addrGateway.c_str(), portGateway))
  734. {
  735. rTRACE("FAIL: reclient gateway - %s", addrGateway.c_str());
  736. //return FALSE;
  737. }
  738. }}
  739. break;
  741. case oneclient_db:
  742. {{
  743. if (g_DBClient.IsReady())
  744. return FALSE;
  746. const size_t freebufferDB = gGetPrivateProfileIntEx(sec_dbrole, key_freebuffer, file_relaycfg, 0);
  747. const size_t buffersizeDB = gGetPrivateProfileIntEx(sec_dbrole, key_buffersize, file_relaycfg, 0);
  748. std::_tstring addrDB = gGetPrivateProfileStringEx(sec_dbrole, key_address, file_relaycfg);
  749. const unsigned short portDB = ROLEDBSVR_ROLEDB_PORT;
  751. rTRACE("try reclient: db - %s", addrDB.c_str());
  753. if (!g_DBClient.Startup(freebufferDB, buffersizeDB, addrDB.c_str(), portDB))
  754. {
  755. rTRACE("FAIL: reclient db - %s", addrDB.c_str());
  756. //return FALSE;
  757. }
  758. }}
  759. break;
  760. }
  762. return TRUE;
  763. }
  766. BOOL gConsignClientSD(IClient* pClient)
  767. {
  768. if (!pClient)
  769. return TRUE;
  771. HWND mainwnd = gGetMainWnd();
  772. if (!mainwnd)
  773. return FALSE;
  775. pClient->AddRef();
  776. ::PostMessage(mainwnd, UM_CONSIGNCLIENTSD, (WPARAM)pClient, 0);
  778. return TRUE;
  779. }
  782. BOOL gStartFriendTimingUpdateDB(UINT elapse)
  783. {
  784. if (gs_timerFriendUdtDB)
  785. return TRUE;
  787. HWND mainwnd = gGetMainWnd();
  788. if (!mainwnd)
  789. return FALSE;
  791. gs_timerFriendUdtDB = ::SetTimer(mainwnd, timer_friendudtdb, elapse, NULL);
  792. if (!gs_timerFriendUdtDB)
  793. {
  794. rTRACE("FAIL: start friend timing update db");
  795. return FALSE;
  796. }
  798. rTRACE("friend timing update db: start");
  800. return TRUE;
  801. }
  803. BOOL gStopFriendTimingUpdateDB()
  804. {
  805. if (!gs_timerFriendUdtDB)
  806. return TRUE;
  808. HWND mainwnd = gGetMainWnd();
  809. if (!mainwnd)
  810. return FALSE;
  812. ::KillTimer(mainwnd, gs_timerFriendUdtDB);
  813. gs_timerFriendUdtDB = 0;
  815. rTRACE("friend timing update db: stop");
  817. return TRUE;
  818. }
  820. BOOL gFriendTimingUpdateDB()
  821. {
  822. if (!g_FriendMgr.BkgrndUpdateDB())
  823. {
  824. rTRACE("warning: update friend DB fail");
  825. return FALSE;
  826. }
  828. rTRACE("update friend DB succeed");
  829. return TRUE;
  830. }