1. #include "stdafx.h"
  2. #include "constants.h"
  3. #include "config.h"
  4. #include "event.h"
  5. #include "minilzo.h"
  6. #include "packet.h"
  7. #include "desc_manager.h"
  8. #include "item_manager.h"
  9. #include "char.h"
  10. #include "char_manager.h"
  11. #include "mob_manager.h"
  12. #include "motion.h"
  13. #include "sectree_manager.h"
  14. #include "shop_manager.h"
  15. #include "regen.h"
  16. #include "text_file_loader.h"
  17. #include "skill.h"
  18. #include "pvp.h"
  19. #include "party.h"
  20. #include "questmanager.h"
  21. #include "profiler.h"
  22. #include "lzo_manager.h"
  23. #include "messenger_manager.h"
  24. #include "db.h"
  25. #include "log.h"
  26. #include "p2p.h"
  27. #include "guild_manager.h"
  28. #include "dungeon.h"
  29. #include "cmd.h"
  30. #include "refine.h"
  31. #include "banword.h"
  32. #include "priv_manager.h"
  33. #include "war_map.h"
  34. #include "building.h"
  35. #include "login_sim.h"
  36. #include "target.h"
  37. #include "marriage.h"
  38. #include "wedding.h"
  39. #include "fishing.h"
  40. #include "item_addon.h"
  41. #include "TrafficProfiler.h"
  42. #include "locale_service.h"
  43. #include "arena.h"
  44. #include "OXEvent.h"
  45. #include "monarch.h"
  46. #include "polymorph.h"
  47. #include "blend_item.h"
  48. #include "castle.h"
  49. #include "passpod.h"
  50. #include "ani.h"
  51. #include "BattleArena.h"
  52. #include "over9refine.h"
  53. #include "horsename_manager.h"
  54. #include "pcbang.h"
  55. #include "MarkManager.h"
  56. #include "spam.h"
  57. #include "panama.h"
  58. #include "threeway_war.h"
  59. #include "auth_brazil.h"
  60. #include "DragonLair.h"
  61. #include "HackShield.h"
  62. #include "skill_power.h"
  63. #ifdef TOURNAMENT_PVP_SYSTEM
  64. #include "tournament.h"
  65. #endif
  66. #include "SpeedServer.h"
  67. #include "XTrapManager.h"
  68. #include "DragonSoul.h"
  69. #ifdef ENABLE_TITLE_SYSTEM
  70. #include "title.h"
  71. #endif
  72. #ifdef ENABLE_MANAGER_BANK_SYSTEM
  73. #include "bank.h"
  74. #endif
  75. #ifdef ENABLE_LOCALIZATION_SYSTEM
  76. #include "localization.h"
  77. #endif
  78. #include <boost/bind.hpp>
  79. #ifdef USER_SECURITY_GUARD
  80. #include "user_security_guard.h"
  81. #endif
  83. #ifndef __WIN32__
  84. #include "limit_time.h"
  85. #endif
  87. //#define __FILEMONITOR__
  89. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
  90. #include "FileMonitor_FreeBSD.h"
  91. #endif
  93. #ifdef __AUCTION__
  94. #include "auction_manager.h"
  95. #endif
  97. #ifdef ENABLE_GOOGLE_TEST
  98. #ifndef __WIN32__
  99. #include <gtest/gtest.h>
  100. #endif
  101. #endif
  103. #ifdef USE_STACKTRACE
  104. #include <execinfo.h>
  105. #endif
  107. //// À©µµ¿ì¿¡¼­ Å×½ºÆ®ÇÒ ¶§´Â Ç×»ó ¼­¹öÅ° üũ
  108. #ifdef _WIN32
  109. #define _USE_SERVER_KEY_
  110. #endif
  111. #include "check_server.h"
  112. #ifdef __MELEY_LAIR_DUNGEON__
  113. #include "MeleyLair.h"
  114. #endif
  115. #ifdef __VERSION_162__
  116. #include "TempleOchao.h"
  117. #endif
  119. extern void WriteVersion();
  120. //extern const char * _malloc_options;
  121. #if defined(__FreeBSD__) && defined(DEBUG_ALLOC)
  122. extern void (*_malloc_message)(const char* p1, const char* p2, const char* p3, const char* p4);
  123. // FreeBSD _malloc_message replacement
  124. void WriteMallocMessage(const char* p1, const char* p2, const char* p3, const char* p4) {
  125. FILE* fp = ::fopen(DBGALLOC_LOG_FILENAME, "a");
  126. if (fp == NULL) {
  127. return;
  128. }
  129. ::fprintf(fp, "%s %s %s %s\n", p1, p2, p3, p4);
  130. ::fclose(fp);
  131. }
  132. #endif
  134. // TRAFFIC_PROFILER
  135. static const DWORD TRAFFIC_PROFILE_FLUSH_CYCLE = 3600; ///< TrafficProfiler ÀÇ Flush cycle. 1½Ã°£ °£°İ
  136. // END_OF_TRAFFIC_PROFILER
  138. // °ÔÀÓ°ú ¿¬°áµÇ´Â ¼ÒÄÏ
  139. volatile int num_events_called = 0;
  140. int max_bytes_written = 0;
  141. int current_bytes_written = 0;
  142. int total_bytes_written = 0;
  143. BYTE g_bLogLevel = 0;
  145. socket_t tcp_socket = 0;
  146. socket_t udp_socket = 0;
  147. socket_t p2p_socket = 0;
  149. LPFDWATCH main_fdw = NULL;
  151. int io_loop(LPFDWATCH fdw);
  153. int start(int argc, char **argv);
  154. int idle();
  155. void destroy();
  157. void test();
  159. enum EProfile
  160. {
  161. PROF_EVENT,
  162. PROF_CHR_UPDATE,
  163. PROF_IO,
  164. PROF_HEARTBEAT,
  165. PROF_MAX_NUM
  166. };
  168. static DWORD s_dwProfiler[PROF_MAX_NUM];
  170. int g_shutdown_disconnect_pulse;
  171. int g_shutdown_disconnect_force_pulse;
  172. int g_shutdown_core_pulse;
  173. bool g_bShutdown=false;
  175. extern void CancelReloadSpamEvent();
  177. void ContinueOnFatalError()
  178. {
  179. #ifdef USE_STACKTRACE
  180. void* array[200];
  181. std::size_t size;
  182. char** symbols;
  184. size = backtrace(array, 200);
  185. symbols = backtrace_symbols(array, size);
  187. std::ostringstream oss;
  188. oss << std::endl;
  189. for (std::size_t i = 0; i < size; ++i) {
  190. oss << " Stack> " << symbols[i] << std::endl;
  191. }
  193. free(symbols);
  195. sys_err("FatalError on %s", oss.str().c_str());
  196. #else
  197. sys_err("FatalError");
  198. #endif
  199. }
  201. void ShutdownOnFatalError()
  202. {
  203. if (!g_bShutdown)
  204. {
  205. sys_err("ShutdownOnFatalError!!!!!!!!!!");
  206. {
  207. char buf[256];
  209. strlcpy(buf, LC_TEXT("¼­¹ö¿¡ Ä¡¸íÀûÀÎ ¿À·ù°¡ ¹ß»ıÇÏ¿© ÀÚµ¿À¸·Î ÀçºÎÆõ˴ϴÙ."), sizeof(buf));
  210. SendNotice(buf);
  211. strlcpy(buf, LC_TEXT("10ÃÊÈÄ ÀÚµ¿À¸·Î Á¢¼ÓÀÌ Á¾·áµÇ¸ç,"), sizeof(buf));
  212. SendNotice(buf);
  213. strlcpy(buf, LC_TEXT("5ºĞ ÈÄ¿¡ Á¤»óÀûÀ¸·Î Á¢¼ÓÇϽǼö ÀÖ½À´Ï´Ù."), sizeof(buf));
  214. SendNotice(buf);
  215. }
  217. g_bShutdown = true;
  218. g_bNoMoreClient = true;
  220. g_shutdown_disconnect_pulse = thecore_pulse() + PASSES_PER_SEC(10);
  221. g_shutdown_disconnect_force_pulse = thecore_pulse() + PASSES_PER_SEC(20);
  222. g_shutdown_core_pulse = thecore_pulse() + PASSES_PER_SEC(30);
  223. }
  224. }
  226. namespace
  227. {
  228. struct SendDisconnectFunc
  229. {
  230. void operator () (LPDESC d)
  231. {
  232. if (d->GetCharacter())
  233. {
  234. if (d->GetCharacter()->GetGMLevel() == GM_PLAYER)
  235. d->GetCharacter()->ChatPacket(CHAT_TYPE_COMMAND, "quit Shutdown(SendDisconnectFunc)");
  236. }
  237. }
  238. };
  240. struct DisconnectFunc
  241. {
  242. void operator () (LPDESC d)
  243. {
  244. if (d->GetType() == DESC_TYPE_CONNECTOR)
  245. return;
  247. if (d->IsPhase(PHASE_P2P))
  248. return;
  250. d->SetPhase(PHASE_CLOSE);
  251. }
  252. };
  253. }
  255. extern std::map<DWORD, CLoginSim *> g_sim; // first: AID
  256. extern std::map<DWORD, CLoginSim *> g_simByPID;
  257. extern std::vector<TPlayerTable> g_vec_save;
  258. unsigned int save_idx = 0;
  260. void heartbeat(LPHEART ht, int pulse)
  261. {
  262. DWORD t;
  264. t = get_dword_time();
  265. num_events_called += event_process(pulse);
  266. s_dwProfiler[PROF_EVENT] += (get_dword_time() - t);
  268. t = get_dword_time();
  270. // 1Ãʸ¶´Ù
  271. if (!(pulse % ht->passes_per_sec))
  272. {
  273. #ifdef ENABLE_LIMIT_TIME
  274. if ((unsigned)get_global_time() >= GLOBAL_LIMIT_TIME)
  275. {
  276. sys_err("Server life time expired.");
  277. g_bShutdown = true;
  278. }
  279. #endif
  281. #ifdef ENABLE_BRAZIL_AUTH_FEATURE // @warme006
  282. if (g_bAuthServer && !test_server)
  283. auth_brazil_log();
  284. #endif
  286. if (!g_bAuthServer)
  287. {
  288. TPlayerCountPacket pack;
  289. pack.dwCount = DESC_MANAGER::instance().GetLocalUserCount();
  290. db_clientdesc->DBPacket(HEADER_GD_PLAYER_COUNT, 0, &pack, sizeof(TPlayerCountPacket));
  291. }
  292. #ifdef USER_SECURITY_GUARD
  293. if (g_bAuthServer)
  294. UserSecurityGuard_Log();
  295. #endif
  296. else
  297. {
  298. DESC_MANAGER::instance().ProcessExpiredLoginKey();
  299. DBManager::instance().FlushBilling();
  300. /*
  301. if (!(pulse % (ht->passes_per_sec * 600)))
  302. DBManager::instance().CheckBilling();
  303. */
  304. }
  306. {
  307. int count = 0;
  308. itertype(g_sim) it = g_sim.begin();
  310. while (it != g_sim.end())
  311. {
  312. if (!it->second->IsCheck())
  313. {
  314. it->second->SendLogin();
  316. if (++count > 50)
  317. {
  318. sys_log(0, "FLUSH_SENT");
  319. break;
  320. }
  321. }
  323. it++;
  324. }
  326. if (save_idx < g_vec_save.size())
  327. {
  328. count = MIN(100, g_vec_save.size() - save_idx);
  330. for (int i = 0; i < count; ++i, ++save_idx)
  331. db_clientdesc->DBPacket(HEADER_GD_PLAYER_SAVE, 0, &g_vec_save[save_idx], sizeof(TPlayerTable));
  333. sys_log(0, "SAVE_FLUSH %d", count);
  334. }
  335. }
  336. }
  338. //
  339. // 25 PPS(Pulse per second) ¶ó°í °¡Á¤ÇÒ ¶§
  340. //
  342. // ¾à 1.16Ãʸ¶´Ù
  343. if (!(pulse % (passes_per_sec + 4)))
  344. CHARACTER_MANAGER::instance().ProcessDelayedSave();
  346. //4ÃÊ ¸¶´Ù
  347. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
  348. if (!(pulse % (passes_per_sec * 5)))
  349. {
  350. FileMonitorFreeBSD::Instance().Update(pulse);
  351. }
  352. #endif
  354. // ¾à 5.08Ãʸ¶´Ù
  355. if (!(pulse % (passes_per_sec * 5 + 2)))
  356. {
  357. ITEM_MANAGER::instance().Update();
  358. DESC_MANAGER::instance().UpdateLocalUserCount();
  359. }
  361. s_dwProfiler[PROF_HEARTBEAT] += (get_dword_time() - t);
  363. DBManager::instance().Process();
  364. AccountDB::instance().Process();
  365. CPVPManager::instance().Process();
  367. if (g_bShutdown)
  368. {
  369. if (thecore_pulse() > g_shutdown_disconnect_pulse)
  370. {
  371. const DESC_MANAGER::DESC_SET & c_set_desc = DESC_MANAGER::instance().GetClientSet();
  372. std::for_each(c_set_desc.begin(), c_set_desc.end(), ::SendDisconnectFunc());
  373. g_shutdown_disconnect_pulse = INT_MAX;
  374. }
  375. else if (thecore_pulse() > g_shutdown_disconnect_force_pulse)
  376. {
  377. const DESC_MANAGER::DESC_SET & c_set_desc = DESC_MANAGER::instance().GetClientSet();
  378. std::for_each(c_set_desc.begin(), c_set_desc.end(), ::DisconnectFunc());
  379. }
  380. else if (thecore_pulse() > g_shutdown_disconnect_force_pulse + PASSES_PER_SEC(5))
  381. {
  382. thecore_shutdown();
  383. }
  384. }
  385. }
  387. static void CleanUpForEarlyExit() {
  388. CancelReloadSpamEvent();
  389. }
  391. int main(int argc, char **argv)
  392. {
  393. #ifdef DEBUG_ALLOC
  394. DebugAllocator::StaticSetUp();
  395. #endif
  397. #ifdef ENABLE_GOOGLE_TEST
  398. #ifndef __WIN32__
  399. // <Factor> start unit tests if option is set
  400. if ( argc > 1 )
  401. {
  402. if ( strcmp( argv[1], "unittest" ) == 0 )
  403. {
  404. ::testing::InitGoogleTest(&argc, argv);
  405. return RUN_ALL_TESTS();
  406. }
  407. }
  408. #endif
  409. #endif
  411. ilInit(); // DevIL Initialize
  413. WriteVersion();
  415. SECTREE_MANAGER sectree_manager;
  416. #ifdef ENABLE_TITLE_SYSTEM
  417. TitleManager title;
  418. #endif
  419. #ifdef ENABLE_MANAGER_BANK_SYSTEM
  420. BankManager bank;
  421. #endif
  422. #ifdef ENABLE_LOCALIZATION_SYSTEM
  423. LocalizationManager localization;
  424. #endif
  425. CHARACTER_MANAGER char_manager;
  426. ITEM_MANAGER item_manager;
  427. CShopManager shop_manager;
  428. CMobManager mob_manager;
  429. CMotionManager motion_manager;
  430. CPartyManager party_manager;
  431. CSkillManager skill_manager;
  432. CPVPManager pvp_manager;
  433. LZOManager lzo_manager;
  434. DBManager db_manager;
  435. AccountDB account_db;
  437. LogManager log_manager;
  438. MessengerManager messenger_manager;
  439. P2P_MANAGER p2p_manager;
  440. CGuildManager guild_manager;
  441. CGuildMarkManager mark_manager;
  442. CDungeonManager dungeon_manager;
  443. CRefineManager refine_manager;
  444. CBanwordManager banword_manager;
  445. CPrivManager priv_manager;
  446. CWarMapManager war_map_manager;
  447. building::CManager building_manager;
  448. CTargetManager target_manager;
  449. marriage::CManager marriage_manager;
  450. marriage::WeddingManager wedding_manager;
  451. CItemAddonManager item_addon_manager;
  452. CArenaManager arena_manager;
  453. COXEventManager OXEvent_manager;
  454. #ifdef TOURNAMENT_PVP_SYSTEM
  455. CTournamentPvP TournamentPvP;
  456. #endif
  457. CMonarch Monarch;
  458. CHorseNameManager horsename_manager;
  459. CPCBangManager pcbang_manager;
  461. DESC_MANAGER desc_manager;
  463. TrafficProfiler trafficProfiler;
  464. CTableBySkill SkillPowerByLevel;
  465. CPolymorphUtils polymorph_utils;
  466. CProfiler profiler;
  467. CPasspod passpod;
  468. CBattleArena ba;
  469. COver9RefineManager o9r;
  470. SpamManager spam_mgr;
  471. CThreeWayWar threeway_war;
  472. CDragonLairManager dl_manager;
  474. CHackShieldManager HSManager;
  475. CXTrapManager XTManager;
  477. CSpeedServerManager SSManager;
  478. DSManager dsManager;
  479. CCheckServer checkServer;
  480. #ifdef __VERSION_162__
  481. TempleOchao::CMgr TempleOchao_manager;
  482. #endif
  484. #ifdef __AUCTION__
  485. AuctionManager auctionManager;
  486. #endif
  488. if (!start(argc, argv)) {
  489. #ifdef __MELEY_LAIR_DUNGEON__
  490. MeleyLair::CMgr MeleyLair_manager;
  491. #endif
  492. CleanUpForEarlyExit();
  493. return 0;
  494. }
  496. quest::CQuestManager quest_manager;
  498. if (!quest_manager.Initialize()) {
  499. CleanUpForEarlyExit();
  500. return 0;
  501. }
  503. MessengerManager::instance().Initialize();
  504. CGuildManager::instance().Initialize();
  505. fishing::Initialize();
  506. OXEvent_manager.Initialize();
  507. #ifdef TOURNAMENT_PVP_SYSTEM
  508. TournamentPvP.Initialize();
  509. #endif
  510. if (speed_server)
  511. CSpeedServerManager::instance().Initialize();
  513. Cube_init();
  514. Blend_Item_init();
  515. ani_init();
  516. PanamaLoad();
  518. if ( g_bTrafficProfileOn )
  519. TrafficProfiler::instance().Initialize( TRAFFIC_PROFILE_FLUSH_CYCLE, "ProfileLog" );
  521. //if game server
  522. if (!g_bAuthServer)
  523. {
  524. if (!CCheckServer::Instance().CheckIP(g_szPublicIP)) {
  525. char pszRevision[128] = "I don't care";
  526. #ifdef _WIN32
  527. fprintf(stderr, "[main] Check IP failed\n");
  528. #else
  529. strncpy (pszRevision, "[main] Check IP failed\n", sizeof(pszRevision));
  530. #endif
  531. LogManager::Instance().InvalidServerLog(LC_GetLocalType(), g_szPublicIP, pszRevision);
  532. }
  534. //hackshield
  535. if (isHackShieldEnable)
  536. {
  537. if (!HSManager.Initialize())
  538. {
  539. fprintf(stderr, "Failed To Initialize HS");
  540. CleanUpForEarlyExit();
  541. return 0;
  542. }
  543. }
  545. //xtrap
  546. if(bXTrapEnabled)
  547. {
  548. if (!XTManager.LoadXTrapModule())
  549. {
  550. CleanUpForEarlyExit();
  551. return 0;
  552. }
  553. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
  554. //PFN_FileChangeListener pNotifyFunc = boost::bind( &CXTrapManager::NotifyMapFileChanged, CXTrapManager::instance(), _1 );
  555. PFN_FileChangeListener pNotifyFunc = &(CXTrapManager::NotifyMapFileChanged);
  557. const std::string strMap1Name = "map1.CS3";
  558. const std::string strMap2Name = "map2.CS3";
  560. FileMonitorFreeBSD::Instance().AddWatch( strMap1Name, pNotifyFunc );
  561. FileMonitorFreeBSD::Instance().AddWatch( strMap2Name, pNotifyFunc );
  562. #endif
  563. }
  564. }
  566. #ifdef __VERSION_162__
  567. TempleOchao_manager.Initialize();
  568. #endif
  570. #ifdef __MELEY_LAIR_DUNGEON__
  571. MeleyLair_manager.Initialize();
  572. #endif
  573. }
  575. // Client PackageCrypt
  577. //TODO : make it config
  578. const std::string strPackageCryptInfoDir = "package/";
  579. if( !desc_manager.LoadClientPackageCryptInfo( strPackageCryptInfoDir.c_str() ) )
  580. {
  581. sys_err("Failed to Load ClientPackageCryptInfo File(%s)", strPackageCryptInfoDir.c_str());
  582. }
  584. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
  585. PFN_FileChangeListener pPackageNotifyFunc = &(DESC_MANAGER::NotifyClientPackageFileChanged);
  586. //FileMonitorFreeBSD::Instance().AddWatch( strPackageCryptInfoName, pPackageNotifyFunc );
  587. #endif
  589. while (idle());
  591. sys_log(0, "<shutdown> Starting...");
  592. g_bShutdown = true;
  593. g_bNoMoreClient = true;
  595. if (g_bAuthServer)
  596. {
  597. DBManager::instance().FlushBilling(true);
  599. int iLimit = DBManager::instance().CountQuery() / 50;
  600. int i = 0;
  602. do
  603. {
  604. DWORD dwCount = DBManager::instance().CountQuery();
  605. sys_log(0, "Queries %u", dwCount);
  607. if (dwCount == 0)
  608. break;
  610. usleep(500000);
  612. if (++i >= iLimit)
  613. if (dwCount == DBManager::instance().CountQuery())
  614. break;
  615. } while (1);
  616. }
  618. sys_log(0, "<shutdown> Destroying CArenaManager...");
  619. arena_manager.Destroy();
  620. sys_log(0, "<shutdown> Destroying COXEventManager...");
  621. OXEvent_manager.Destroy();
  623. #ifdef TOURNAMENT_PVP_SYSTEM
  624. sys_log(0, "<shutdown> Destroying CTournamentPvP...");
  625. TournamentPvP.Destroy();
  626. #endif
  628. sys_log(0, "<shutdown> Disabling signal timer...");
  629. signal_timer_disable();
  631. sys_log(0, "<shutdown> Shutting down CHARACTER_MANAGER...");
  632. char_manager.GracefulShutdown();
  633. sys_log(0, "<shutdown> Shutting down ITEM_MANAGER...");
  634. item_manager.GracefulShutdown();
  636. sys_log(0, "<shutdown> Flushing db_clientdesc...");
  637. db_clientdesc->FlushOutput();
  638. sys_log(0, "<shutdown> Flushing p2p_manager...");
  639. p2p_manager.FlushOutput();
  641. sys_log(0, "<shutdown> Destroying CShopManager...");
  642. shop_manager.Destroy();
  643. sys_log(0, "<shutdown> Destroying CHARACTER_MANAGER...");
  644. char_manager.Destroy();
  645. sys_log(0, "<shutdown> Destroying ITEM_MANAGER...");
  646. item_manager.Destroy();
  647. sys_log(0, "<shutdown> Destroying DESC_MANAGER...");
  648. desc_manager.Destroy();
  649. sys_log(0, "<shutdown> Destroying quest::CQuestManager...");
  650. quest_manager.Destroy();
  651. sys_log(0, "<shutdown> Destroying building::CManager...");
  652. building_manager.Destroy();
  654. if (!g_bAuthServer)
  655. {
  656. if (isHackShieldEnable)
  657. {
  658. sys_log(0, "<shutdown> Releasing HackShield manager...");
  659. HSManager.Release();
  660. }
  661. #ifdef __MELEY_LAIR_DUNGEON__
  662. sys_log(0, "<shutdown> Destroying MeleyLair_manager.");
  663. MeleyLair_manager.Destroy();
  664. #endif
  666. #ifdef __VERSION_162__
  667. sys_log(0, "<shutdown> Destroying TempleOchao_manager.");
  668. TempleOchao_manager.Destroy();
  669. #endif
  670. }
  672. sys_log(0, "<shutdown> Flushing TrafficProfiler...");
  673. trafficProfiler.Flush();
  675. destroy();
  677. #ifdef DEBUG_ALLOC
  678. DebugAllocator::StaticTearDown();
  679. #endif
  681. return 1;
  682. }
  684. void usage()
  685. {
  686. printf("Option list\n"
  687. "-p <port> : bind port number (port must be over 1024)\n"
  688. "-l <level> : sets log level\n"
  689. "-n <locale> : sets locale name\n"
  690. #ifdef ENABLE_NEWSTUFF
  691. "-C <on-off> : checkpointing check on/off\n"
  692. #endif
  693. "-v : log to stdout\n"
  694. "-r : do not load regen tables\n"
  695. "-t : traffic profile on\n");
  696. }
  698. int start(int argc, char **argv)
  699. {
  700. std::string st_localeServiceName;
  702. bool bVerbose = false;
  703. char ch;
  705. //_malloc_options = "A";
  706. #if defined(__FreeBSD__) && defined(DEBUG_ALLOC)
  707. _malloc_message = WriteMallocMessage;
  708. #endif
  709. #ifdef ENABLE_LIMIT_TIME
  710. if ((unsigned)get_global_time() >= GLOBAL_LIMIT_TIME)
  711. {
  712. sys_err("Server life time expired.");
  713. return 0;
  714. }
  715. #endif
  717. #ifdef ENABLE_NEWSTUFF
  718. while ((ch = getopt(argc, argv, "npverltIC")) != -1)
  719. #else
  720. while ((ch = getopt(argc, argv, "npverltI")) != -1)
  721. #endif
  722. {
  723. char* ep = NULL;
  725. switch (ch)
  726. {
  727. case 'I': // IP
  728. strlcpy(g_szPublicIP, argv[optind], sizeof(g_szPublicIP));
  730. printf("IP %s\n", g_szPublicIP);
  732. optind++;
  733. optreset = 1;
  734. break;
  736. case 'p': // port
  737. mother_port = strtol(argv[optind], &ep, 10);
  739. if (mother_port <= 1024)
  740. {
  741. usage();
  742. return 0;
  743. }
  745. printf("port %d\n", mother_port);
  747. optind++;
  748. optreset = 1;
  749. break;
  751. case 'l':
  752. {
  753. long l = strtol(argv[optind], &ep, 10);
  755. log_set_level(l);
  757. optind++;
  758. optreset = 1;
  759. }
  760. break;
  762. // LOCALE_SERVICE
  763. case 'n':
  764. {
  765. if (optind < argc)
  766. {
  767. st_localeServiceName = argv[optind++];
  768. optreset = 1;
  769. }
  770. }
  771. break;
  772. // END_OF_LOCALE_SERVICE
  774. #ifdef ENABLE_NEWSTUFF
  775. case 'C': // checkpoint check
  776. bCheckpointCheck = strtol(argv[optind], &ep, 10);;
  777. printf("CHECKPOINT_CHECK %d\n", bCheckpointCheck);
  779. optind++;
  780. optreset = 1;
  781. break;
  782. #endif
  784. case 'v': // verbose
  785. bVerbose = true;
  786. break;
  788. case 'r':
  789. g_bNoRegen = true;
  790. break;
  792. // TRAFFIC_PROFILER
  793. case 't':
  794. g_bTrafficProfileOn = true;
  795. break;
  796. // END_OF_TRAFFIC_PROFILER
  797. }
  798. }
  800. // LOCALE_SERVICE
  801. config_init(st_localeServiceName);
  802. // END_OF_LOCALE_SERVICE
  804. #ifdef __WIN32__
  805. // In Windows dev mode, "verbose" option is [on] by default.
  806. bVerbose = true;
  807. #endif
  808. if (!bVerbose)
  809. freopen("stdout", "a", stdout);
  811. bool is_thecore_initialized = thecore_init(25, heartbeat);
  813. if (!is_thecore_initialized)
  814. {
  815. fprintf(stderr, "Could not initialize thecore, check owner of pid, syslog\n");
  816. exit(0);
  817. }
  819. if (false == CThreeWayWar::instance().LoadSetting("forkedmapindex.txt"))
  820. {
  821. if (false == g_bAuthServer)
  822. {
  823. fprintf(stderr, "Could not Load ThreeWayWar Setting file");
  824. exit(0);
  825. }
  826. }
  828. signal_timer_disable();
  830. main_fdw = fdwatch_new(4096);
  832. if ((tcp_socket = socket_tcp_bind(g_szPublicIP, mother_port)) == INVALID_SOCKET)
  833. {
  834. perror("socket_tcp_bind: tcp_socket");
  835. return 0;
  836. }
  839. #ifndef __UDP_BLOCK__
  840. if ((udp_socket = socket_udp_bind(g_szPublicIP, mother_port)) == INVALID_SOCKET)
  841. {
  842. perror("socket_udp_bind: udp_socket");
  843. return 0;
  844. }
  845. #endif
  847. // if internal ip exists, p2p socket uses internal ip, if not use public ip
  848. //if ((p2p_socket = socket_tcp_bind(*g_szInternalIP ? g_szInternalIP : g_szPublicIP, p2p_port)) == INVALID_SOCKET)
  849. if ((p2p_socket = socket_tcp_bind(g_szPublicIP, p2p_port)) == INVALID_SOCKET)
  850. {
  851. perror("socket_tcp_bind: p2p_socket");
  852. return 0;
  853. }
  855. fdwatch_add_fd(main_fdw, tcp_socket, NULL, FDW_READ, false);
  856. #ifndef __UDP_BLOCK__
  857. fdwatch_add_fd(main_fdw, udp_socket, NULL, FDW_READ, false);
  858. #endif
  859. fdwatch_add_fd(main_fdw, p2p_socket, NULL, FDW_READ, false);
  861. db_clientdesc = DESC_MANAGER::instance().CreateConnectionDesc(main_fdw, db_addr, db_port, PHASE_DBCLIENT, true);
  862. if (!g_bAuthServer) {
  863. db_clientdesc->UpdateChannelStatus(0, true);
  864. }
  866. if (g_bAuthServer)
  867. {
  868. if (g_stAuthMasterIP.length() != 0)
  869. {
  870. fprintf(stderr, "SlaveAuth");
  871. g_pkAuthMasterDesc = DESC_MANAGER::instance().CreateConnectionDesc(main_fdw, g_stAuthMasterIP.c_str(), g_wAuthMasterPort, PHASE_P2P, true);
  872. P2P_MANAGER::instance().RegisterConnector(g_pkAuthMasterDesc);
  873. g_pkAuthMasterDesc->SetP2P(g_stAuthMasterIP.c_str(), g_wAuthMasterPort, g_bChannel);
  875. }
  876. else
  877. {
  878. fprintf(stderr, "MasterAuth %d\n", LC_GetLocalType());
  879. }
  880. }
  881. /* game server to teen server */
  882. else
  883. {
  884. if (teen_addr[0] && teen_port)
  885. g_TeenDesc = DESC_MANAGER::instance().CreateConnectionDesc(main_fdw, teen_addr, teen_port, PHASE_TEEN, true);
  887. sys_log(0, "SPAM_CONFIG: duration %u score %u reload cycle %u\n",
  888. g_uiSpamBlockDuration, g_uiSpamBlockScore, g_uiSpamReloadCycle);
  890. extern void LoadSpamDB();
  891. LoadSpamDB();
  892. }
  894. signal_timer_enable(30);
  895. return 1;
  896. }
  898. void destroy()
  899. {
  900. sys_log(0, "<shutdown> Canceling ReloadSpamEvent...");
  901. CancelReloadSpamEvent();
  903. sys_log(0, "<shutdown> regen_free()...");
  904. regen_free();
  906. sys_log(0, "<shutdown> Closing sockets...");
  907. socket_close(tcp_socket);
  908. #ifndef __UDP_BLOCK__
  909. socket_close(udp_socket);
  910. #endif
  911. socket_close(p2p_socket);
  913. sys_log(0, "<shutdown> fdwatch_delete()...");
  914. fdwatch_delete(main_fdw);
  916. sys_log(0, "<shutdown> event_destroy()...");
  917. event_destroy();
  919. sys_log(0, "<shutdown> CTextFileLoader::DestroySystem()...");
  920. CTextFileLoader::DestroySystem();
  922. sys_log(0, "<shutdown> thecore_destroy()...");
  923. thecore_destroy();
  924. }
  926. int idle()
  927. {
  928. static struct timeval pta = { 0, 0 };
  929. static int process_time_count = 0;
  930. struct timeval now;
  932. if (pta.tv_sec == 0)
  933. gettimeofday(&pta, (struct timezone *) 0);
  935. int passed_pulses;
  937. if (!(passed_pulses = thecore_idle()))
  938. return 0;
  940. assert(passed_pulses > 0);
  942. DWORD t;
  944. while (passed_pulses--) {
  945. heartbeat(thecore_heart, ++thecore_heart->pulse);
  947. // To reduce the possibility of abort() in checkpointing
  948. thecore_tick();
  949. }
  951. t = get_dword_time();
  952. CHARACTER_MANAGER::instance().Update(thecore_heart->pulse);
  953. db_clientdesc->Update(t);
  954. s_dwProfiler[PROF_CHR_UPDATE] += (get_dword_time() - t);
  956. t = get_dword_time();
  957. if (!io_loop(main_fdw)) return 0;
  958. s_dwProfiler[PROF_IO] += (get_dword_time() - t);
  960. log_rotate();
  962. gettimeofday(&now, (struct timezone *) 0);
  963. ++process_time_count;
  965. if (now.tv_sec - pta.tv_sec > 0)
  966. {
  967. pt_log("[%3d] event %5d/%-5d idle %-4ld event %-4ld heartbeat %-4ld I/O %-4ld chrUpate %-4ld | WRITE: %-7d | PULSE: %d",
  968. process_time_count,
  969. num_events_called,
  970. event_count(),
  971. thecore_profiler[PF_IDLE],
  972. s_dwProfiler[PROF_EVENT],
  973. s_dwProfiler[PROF_HEARTBEAT],
  974. s_dwProfiler[PROF_IO],
  975. s_dwProfiler[PROF_CHR_UPDATE],
  976. current_bytes_written,
  977. thecore_pulse());
  979. num_events_called = 0;
  980. current_bytes_written = 0;
  982. process_time_count = 0;
  983. gettimeofday(&pta, (struct timezone *) 0);
  985. memset(&thecore_profiler[0], 0, sizeof(thecore_profiler));
  986. memset(&s_dwProfiler[0], 0, sizeof(s_dwProfiler));
  987. }
  989. #ifdef __WIN32__
  990. if (_kbhit()) {
  991. int c = _getch();
  992. switch (c) {
  993. case 0x1b: // Esc
  994. return 0; // shutdown
  995. break;
  996. default:
  997. break;
  998. }
  999. }
  1000. #endif
  1002. return 1;
  1003. }
  1005. int io_loop(LPFDWATCH fdw)
  1006. {
  1007. LPDESC d;
  1008. int num_events, event_idx;
  1010. DESC_MANAGER::instance().DestroyClosed(); // PHASE_CLOSEÀÎ Á¢¼ÓµéÀ» ²÷¾îÁØ´Ù.
  1011. DESC_MANAGER::instance().TryConnect();
  1013. if ((num_events = fdwatch(fdw, 0)) < 0)
  1014. return 0;
  1016. for (event_idx = 0; event_idx < num_events; ++event_idx)
  1017. {
  1018. d = (LPDESC) fdwatch_get_client_data(fdw, event_idx);
  1020. if (!d)
  1021. {
  1022. if (FDW_READ == fdwatch_check_event(fdw, tcp_socket, event_idx))
  1023. {
  1024. DESC_MANAGER::instance().AcceptDesc(fdw, tcp_socket);
  1025. fdwatch_clear_event(fdw, tcp_socket, event_idx);
  1026. }
  1027. else if (FDW_READ == fdwatch_check_event(fdw, p2p_socket, event_idx))
  1028. {
  1029. DESC_MANAGER::instance().AcceptP2PDesc(fdw, p2p_socket);
  1030. fdwatch_clear_event(fdw, p2p_socket, event_idx);
  1031. }
  1032. /*
  1033. else if (FDW_READ == fdwatch_check_event(fdw, udp_socket, event_idx))
  1034. {
  1035. char buf[256];
  1036. struct sockaddr_in cliaddr;
  1037. socklen_t socklen = sizeof(cliaddr);
  1039. int iBytesRead;
  1041. if ((iBytesRead = socket_udp_read(udp_socket, buf, 256, (struct sockaddr *) &cliaddr, &socklen)) > 0)
  1042. {
  1043. static CInputUDP s_inputUDP;
  1045. s_inputUDP.SetSockAddr(cliaddr);
  1047. int iBytesProceed;
  1048. s_inputUDP.Process(NULL, buf, iBytesRead, iBytesProceed);
  1049. }
  1051. fdwatch_clear_event(fdw, udp_socket, event_idx);
  1052. }
  1053. */
  1054. continue;
  1055. }
  1057. int iRet = fdwatch_check_event(fdw, d->GetSocket(), event_idx);
  1059. switch (iRet)
  1060. {
  1061. case FDW_READ:
  1062. if (db_clientdesc == d)
  1063. {
  1064. int size = d->ProcessInput();
  1066. if (size)
  1067. sys_log(1, "DB_BYTES_READ: %d", size);
  1069. if (size < 0)
  1070. {
  1071. d->SetPhase(PHASE_CLOSE);
  1072. }
  1073. }
  1074. else if (d->ProcessInput() < 0)
  1075. {
  1076. d->SetPhase(PHASE_CLOSE);
  1077. }
  1078. break;
  1080. case FDW_WRITE:
  1081. if (db_clientdesc == d)
  1082. {
  1083. int buf_size = buffer_size(d->GetOutputBuffer());
  1084. int sock_buf_size = fdwatch_get_buffer_size(fdw, d->GetSocket());
  1086. int ret = d->ProcessOutput();
  1088. if (ret < 0)
  1089. {
  1090. d->SetPhase(PHASE_CLOSE);
  1091. }
  1093. if (buf_size)
  1094. sys_log(1, "DB_BYTES_WRITE: size %d sock_buf %d ret %d", buf_size, sock_buf_size, ret);
  1095. }
  1096. else if (d->ProcessOutput() < 0)
  1097. {
  1098. d->SetPhase(PHASE_CLOSE);
  1099. }
  1100. else if (g_TeenDesc==d)
  1101. {
  1102. int buf_size = buffer_size(d->GetOutputBuffer());
  1103. int sock_buf_size = fdwatch_get_buffer_size(fdw, d->GetSocket());
  1105. int ret = d->ProcessOutput();
  1107. if (ret < 0)
  1108. {
  1109. d->SetPhase(PHASE_CLOSE);
  1110. }
  1112. if (buf_size)
  1113. sys_log(0, "TEEN::Send(size %d sock_buf %d ret %d)", buf_size, sock_buf_size, ret);
  1114. }
  1115. break;
  1117. case FDW_EOF:
  1118. {
  1119. d->SetPhase(PHASE_CLOSE);
  1120. }
  1121. break;
  1123. default:
  1124. sys_err("fdwatch_check_event returned unknown %d", iRet);
  1125. d->SetPhase(PHASE_CLOSE);
  1126. break;
  1127. }
  1128. }
  1130. return 1;
  1131. }