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 "ani.h"
50. #include "BattleArena.h"
51. #include "over9refine.h"
52. #include "horsename_manager.h"
53. #include "pcbang.h"
54. #include "MarkManager.h"
55. #include "spam.h"
56. #include "panama.h"
57. #include "threeway_war.h"
58. #include "DragonLair.h"
59. #include "skill_power.h"
60. #include "SpeedServer.h"
61. #include "DragonSoul.h"
62. #include <boost/bind.hpp>
64. //#define __FILEMONITOR__
66. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
67. #include "FileMonitor_FreeBSD.h"
68. #endif
70. #ifndef __WIN32__
71. #include <gtest/gtest.h>
72. #endif
74. #ifdef USE_STACKTRACE
75. #include <execinfo.h>
76. #endif
78. extern void WriteVersion();
79. //extern const char * _malloc_options;
80. #if defined(__FreeBSD__) && defined(DEBUG_ALLOC)
81. extern void (*_malloc_message)(const char* p1, const char* p2, const char* p3, const char* p4);
82. // FreeBSD _malloc_message replacement
83. void WriteMallocMessage(const char* p1, const char* p2, const char* p3, const char* p4) {
84. FILE* fp = ::fopen(DBGALLOC_LOG_FILENAME, "a");
85. if (fp == NULL) {
86. return;
87. }
88. ::fprintf(fp, "%s %s %s %s\n", p1, p2, p3, p4);
89. ::fclose(fp);
90. }
91. #endif
93. // TRAFFIC_PROFILER
94. static const DWORD TRAFFIC_PROFILE_FLUSH_CYCLE = 3600; ///< TrafficProfiler ÀÇ Flush cycle. 1½Ã°£ °£°İ
95. // END_OF_TRAFFIC_PROFILER
97. // °ÔÀÓ°ú ¿¬°áµÇ´Â ¼ÒÄÏ
98. volatile int num_events_called = 0;
99. int max_bytes_written = 0;
100. int current_bytes_written = 0;
101. int total_bytes_written = 0;
102. BYTE g_bLogLevel = 0;
104. socket_t tcp_socket = 0;
105. socket_t udp_socket = 0;
106. socket_t p2p_socket = 0;
108. LPFDWATCH main_fdw = NULL;
110. int io_loop(LPFDWATCH fdw);
112. int start(int argc, char **argv);
113. int idle();
114. void destroy();
116. void test();
118. enum EProfile
119. {
120. PROF_EVENT,
121. PROF_CHR_UPDATE,
122. PROF_IO,
123. PROF_HEARTBEAT,
124. PROF_MAX_NUM
125. };
127. static DWORD s_dwProfiler[PROF_MAX_NUM];
129. int g_shutdown_disconnect_pulse;
130. int g_shutdown_disconnect_force_pulse;
131. int g_shutdown_core_pulse;
132. bool g_bShutdown=false;
134. extern int speed_server;
135. extern void CancelReloadSpamEvent();
137. void ContinueOnFatalError()
138. {
139. #ifdef USE_STACKTRACE
140. void* array[200];
141. std::size_t size;
142. char** symbols;
144. size = backtrace(array, 200);
145. symbols = backtrace_symbols(array, size);
147. std::ostringstream oss;
148. oss << std::endl;
149. for (std::size_t i = 0; i < size; ++i) {
150. oss << " Stack> " << symbols[i] << std::endl;
151. }
153. free(symbols);
155. sys_err("FatalError on %s", oss.str().c_str());
156. #else
157. sys_err("FatalError");
158. #endif
159. }
161. void ShutdownOnFatalError()
162. {
163. if (!g_bShutdown)
164. {
165. sys_err("ShutdownOnFatalError!!!!!!!!!!");
166. {
167. char buf[256];
169. strlcpy(buf, LC_TEXT("¼­¹ö¿¡ Ä¡¸íÀûÀÎ ¿À·ù°¡ ¹ß»ıÇÏ¿© ÀÚµ¿À¸·Î ÀçºÎÆõ˴ϴÙ."), sizeof(buf));
170. SendNotice(buf);
171. strlcpy(buf, LC_TEXT("10ÃÊÈÄ ÀÚµ¿À¸·Î Á¢¼ÓÀÌ Á¾·áµÇ¸ç,"), sizeof(buf));
172. SendNotice(buf);
173. strlcpy(buf, LC_TEXT("5ºĞ ÈÄ¿¡ Á¤»óÀûÀ¸·Î Á¢¼ÓÇϽǼö ÀÖ½À´Ï´Ù."), sizeof(buf));
174. SendNotice(buf);
175. }
177. g_bShutdown = true;
178. g_bNoMoreClient = true;
180. g_shutdown_disconnect_pulse = thecore_pulse() + PASSES_PER_SEC(10);
181. g_shutdown_disconnect_force_pulse = thecore_pulse() + PASSES_PER_SEC(20);
182. g_shutdown_core_pulse = thecore_pulse() + PASSES_PER_SEC(30);
183. }
184. }
186. namespace
187. {
188. struct SendDisconnectFunc
189. {
190. void operator () (LPDESC d)
191. {
192. if (d->GetCharacter())
193. {
194. if (d->GetCharacter()->GetGMLevel() == GM_PLAYER)
195. d->GetCharacter()->ChatPacket(CHAT_TYPE_COMMAND, "quit Shutdown(SendDisconnectFunc)");
196. }
197. }
198. };
200. struct DisconnectFunc
201. {
202. void operator () (LPDESC d)
203. {
204. if (d->GetType() == DESC_TYPE_CONNECTOR)
205. return;
207. if (d->IsPhase(PHASE_P2P))
208. return;
210. d->SetPhase(PHASE_CLOSE);
211. }
212. };
213. }
215. extern std::map<DWORD, CLoginSim *> g_sim; // first: AID
216. extern std::map<DWORD, CLoginSim *> g_simByPID;
217. extern std::vector<TPlayerTable> g_vec_save;
218. unsigned int save_idx = 0;
220. void heartbeat(LPHEART ht, int pulse)
221. {
222. DWORD t;
224. t = get_dword_time();
225. num_events_called += event_process(pulse);
226. s_dwProfiler[PROF_EVENT] += (get_dword_time() - t);
228. t = get_dword_time();
230. // 1Ãʸ¶´Ù
231. if (!(pulse % ht->passes_per_sec))
232. {
233. if (!g_bAuthServer)
234. {
235. TPlayerCountPacket pack;
236. pack.dwCount = DESC_MANAGER::instance().GetLocalUserCount();
237. db_clientdesc->DBPacket(HEADER_GD_PLAYER_COUNT, 0, &pack, sizeof(TPlayerCountPacket));
238. }
239. else
240. {
241. DESC_MANAGER::instance().ProcessExpiredLoginKey();
242. }
244. {
245. int count = 0;
246. itertype(g_sim) it = g_sim.begin();
248. while (it != g_sim.end())
249. {
250. if (!it->second->IsCheck())
251. {
252. it->second->SendLogin();
254. if (++count > 50)
255. {
256. sys_log(0, "FLUSH_SENT");
257. break;
258. }
259. }
261. it++;
262. }
264. if (save_idx < g_vec_save.size())
265. {
266. count = MIN(100, g_vec_save.size() - save_idx);
268. for (int i = 0; i < count; ++i, ++save_idx)
269. db_clientdesc->DBPacket(HEADER_GD_PLAYER_SAVE, 0, &g_vec_save[save_idx], sizeof(TPlayerTable));
271. sys_log(0, "SAVE_FLUSH %d", count);
272. }
273. }
274. }
276. //
277. // 25 PPS(Pulse per second) ¶ó°í °¡Á¤ÇÒ ¶§
278. //
280. // ¾à 1.16Ãʸ¶´Ù
281. if (!(pulse % (passes_per_sec + 4)))
282. CHARACTER_MANAGER::instance().ProcessDelayedSave();
284. //4ÃÊ ¸¶´Ù
285. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
286. if (!(pulse % (passes_per_sec * 5)))
287. {
288. FileMonitorFreeBSD::Instance().Update(pulse);
289. }
290. #endif
292. // ¾à 5.08Ãʸ¶´Ù
293. if (!(pulse % (passes_per_sec * 5 + 2)))
294. {
295. ITEM_MANAGER::instance().Update();
296. DESC_MANAGER::instance().UpdateLocalUserCount();
297. }
299. s_dwProfiler[PROF_HEARTBEAT] += (get_dword_time() - t);
301. DBManager::instance().Process();
302. AccountDB::instance().Process();
303. CPVPManager::instance().Process();
305. if (g_bShutdown)
306. {
307. if (thecore_pulse() > g_shutdown_disconnect_pulse)
308. {
309. const DESC_MANAGER::DESC_SET & c_set_desc = DESC_MANAGER::instance().GetClientSet();
310. std::for_each(c_set_desc.begin(), c_set_desc.end(), ::SendDisconnectFunc());
311. g_shutdown_disconnect_pulse = INT_MAX;
312. }
313. else if (thecore_pulse() > g_shutdown_disconnect_force_pulse)
314. {
315. const DESC_MANAGER::DESC_SET & c_set_desc = DESC_MANAGER::instance().GetClientSet();
316. std::for_each(c_set_desc.begin(), c_set_desc.end(), ::DisconnectFunc());
317. }
318. else if (thecore_pulse() > g_shutdown_disconnect_force_pulse + PASSES_PER_SEC(5))
319. {
320. thecore_shutdown();
321. }
322. }
323. }
325. static void CleanUpForEarlyExit() {
326. CancelReloadSpamEvent();
327. }
329. int main(int argc, char **argv)
330. {
331. #ifdef DEBUG_ALLOC
332. DebugAllocator::StaticSetUp();
333. #endif
335. #ifndef __WIN32__
336. // <Factor> start unit tests if option is set
337. if ( argc > 1 )
338. {
339. if ( strcmp( argv[1], "unittest" ) == 0 )
340. {
341. ::testing::InitGoogleTest(&argc, argv);
342. return RUN_ALL_TESTS();
343. }
344. }
345. #endif
347. ilInit(); // DevIL Initialize
349. WriteVersion();
351. SECTREE_MANAGER sectree_manager;
352. CHARACTER_MANAGER char_manager;
353. ITEM_MANAGER item_manager;
354. CShopManager shop_manager;
355. CMobManager mob_manager;
356. CMotionManager motion_manager;
357. CPartyManager party_manager;
358. CSkillManager skill_manager;
359. CPVPManager pvp_manager;
360. LZOManager lzo_manager;
361. DBManager db_manager;
362. AccountDB account_db;
364. LogManager log_manager;
365. MessengerManager messenger_manager;
366. P2P_MANAGER p2p_manager;
367. CGuildManager guild_manager;
368. CGuildMarkManager mark_manager;
369. CDungeonManager dungeon_manager;
370. CRefineManager refine_manager;
371. CBanwordManager banword_manager;
372. CPrivManager priv_manager;
373. CWarMapManager war_map_manager;
374. building::CManager building_manager;
375. CTargetManager target_manager;
376. marriage::CManager marriage_manager;
377. marriage::WeddingManager wedding_manager;
378. CItemAddonManager item_addon_manager;
379. CArenaManager arena_manager;
380. COXEventManager OXEvent_manager;
381. CMonarch Monarch;
382. CHorseNameManager horsename_manager;
383. CPCBangManager pcbang_manager;
385. DESC_MANAGER desc_manager;
387. TrafficProfiler trafficProfiler;
388. CTableBySkill SkillPowerByLevel;
389. CPolymorphUtils polymorph_utils;
390. CProfiler profiler;
391. CBattleArena ba;
392. COver9RefineManager o9r;
393. SpamManager spam_mgr;
394. CThreeWayWar threeway_war;
395. CDragonLairManager dl_manager;
397. CSpeedServerManager SSManager;
398. DSManager dsManager;
400. if (!start(argc, argv)) {
401. CleanUpForEarlyExit();
402. return 0;
403. }
405. quest::CQuestManager quest_manager;
407. if (!quest_manager.Initialize()) {
408. CleanUpForEarlyExit();
409. return 0;
410. }
412. MessengerManager::instance().Initialize();
413. CGuildManager::instance().Initialize();
414. fishing::Initialize();
415. OXEvent_manager.Initialize();
416. if (speed_server)
417. CSpeedServerManager::instance().Initialize();
419. Cube_init();
420. Blend_Item_init();
421. ani_init();
422. PanamaLoad();
424. if ( g_bTrafficProfileOn )
425. TrafficProfiler::instance().Initialize( TRAFFIC_PROFILE_FLUSH_CYCLE, "ProfileLog" );
427. // Client PackageCrypt
429. //TODO : make it config
430. const std::string strPackageCryptInfoDir = "package/";
431. if( !desc_manager.LoadClientPackageCryptInfo( strPackageCryptInfoDir.c_str() ) )
432. {
433. sys_err("Failed to Load ClientPackageCryptInfo File(%s)", strPackageCryptInfoDir.c_str());
434. }
436. #if defined (__FreeBSD__) && defined(__FILEMONITOR__)
437. PFN_FileChangeListener pPackageNotifyFunc = &(DESC_MANAGER::NotifyClientPackageFileChanged);
438. //FileMonitorFreeBSD::Instance().AddWatch( strPackageCryptInfoName, pPackageNotifyFunc );
439. #endif
441. while (idle());
443. sys_log(0, "<shutdown> Starting...");
444. g_bShutdown = true;
445. g_bNoMoreClient = true;
447. if (g_bAuthServer)
448. {
449. int iLimit = DBManager::instance().CountQuery() / 50;
450. int i = 0;
452. do
453. {
454. DWORD dwCount = DBManager::instance().CountQuery();
455. sys_log(0, "Queries %u", dwCount);
457. if (dwCount == 0)
458. break;
460. usleep(500000);
462. if (++i >= iLimit)
463. if (dwCount == DBManager::instance().CountQuery())
464. break;
465. } while (1);
466. }
468. sys_log(0, "<shutdown> Destroying CArenaManager...");
469. arena_manager.Destroy();
470. sys_log(0, "<shutdown> Destroying COXEventManager...");
471. OXEvent_manager.Destroy();
473. sys_log(0, "<shutdown> Disabling signal timer...");
474. signal_timer_disable();
476. sys_log(0, "<shutdown> Shutting down CHARACTER_MANAGER...");
477. char_manager.GracefulShutdown();
478. sys_log(0, "<shutdown> Shutting down ITEM_MANAGER...");
479. item_manager.GracefulShutdown();
481. sys_log(0, "<shutdown> Flushing db_clientdesc...");
482. db_clientdesc->FlushOutput();
483. sys_log(0, "<shutdown> Flushing p2p_manager...");
484. p2p_manager.FlushOutput();
486. sys_log(0, "<shutdown> Destroying CShopManager...");
487. shop_manager.Destroy();
488. sys_log(0, "<shutdown> Destroying CHARACTER_MANAGER...");
489. char_manager.Destroy();
490. sys_log(0, "<shutdown> Destroying ITEM_MANAGER...");
491. item_manager.Destroy();
492. sys_log(0, "<shutdown> Destroying DESC_MANAGER...");
493. desc_manager.Destroy();
494. sys_log(0, "<shutdown> Destroying quest::CQuestManager...");
495. quest_manager.Destroy();
496. sys_log(0, "<shutdown> Destroying building::CManager...");
497. building_manager.Destroy();
499. sys_log(0, "<shutdown> Flushing TrafficProfiler...");
500. trafficProfiler.Flush();
502. destroy();
504. #ifdef DEBUG_ALLOC
505. DebugAllocator::StaticTearDown();
506. #endif
508. return 1;
509. }
511. void usage()
512. {
513. printf("Option list\n"
514. "-p <port> : bind port number (port must be over 1024)\n"
515. "-l <level> : sets log level\n"
516. "-v : log to stdout\n"
517. "-r : do not load regen tables\n"
518. "-t : traffic proflie on\n");
519. }
521. int start(int argc, char **argv)
522. {
523. std::string st_localeServiceName;
525. bool bVerbose = false;
526. char ch;
528. //_malloc_options = "A";
529. #if defined(__FreeBSD__) && defined(DEBUG_ALLOC)
530. _malloc_message = WriteMallocMessage;
531. #endif
533. while ((ch = getopt(argc, argv, "npverltI")) != -1)
534. {
535. char* ep = NULL;
537. switch (ch)
538. {
539. case 'I': // IP
540. strlcpy(g_szPublicIP, argv[optind], sizeof(g_szPublicIP));
542. printf("IP %s\n", g_szPublicIP);
544. optind++;
545. optreset = 1;
546. break;
548. case 'p': // port
549. mother_port = strtol(argv[optind], &ep, 10);
551. if (mother_port <= 1024)
552. {
553. usage();
554. return 0;
555. }
557. printf("port %d\n", mother_port);
559. optind++;
560. optreset = 1;
561. break;
563. case 'l':
564. {
565. long l = strtol(argv[optind], &ep, 10);
567. log_set_level(l);
569. optind++;
570. optreset = 1;
571. }
572. break;
574. // LOCALE_SERVICE
575. case 'n':
576. {
577. if (optind < argc)
578. {
579. st_localeServiceName = argv[optind++];
580. optreset = 1;
581. }
582. }
583. break;
584. // END_OF_LOCALE_SERVICE
586. case 'v': // verbose
587. bVerbose = true;
588. break;
590. case 'r':
591. g_bNoRegen = true;
592. break;
594. // TRAFFIC_PROFILER
595. case 't':
596. g_bTrafficProfileOn = true;
597. break;
598. // END_OF_TRAFFIC_PROFILER
599. }
600. }
602. // LOCALE_SERVICE
603. config_init(st_localeServiceName);
604. // END_OF_LOCALE_SERVICE
606. #ifdef __WIN32__
607. // In Windows dev mode, "verbose" option is [on] by default.
608. bVerbose = true;
609. #endif
610. if (!bVerbose)
611. freopen("stdout", "a", stdout);
613. bool is_thecore_initialized = thecore_init(25, heartbeat);
615. if (!is_thecore_initialized)
616. {
617. fprintf(stderr, "Could not initialize thecore, check owner of pid, syslog\n");
618. exit(0);
619. }
621. if (false == CThreeWayWar::instance().LoadSetting("forkedmapindex.txt"))
622. {
623. if (false == g_bAuthServer)
624. {
625. fprintf(stderr, "Could not Load ThreeWayWar Setting file");
626. exit(0);
627. }
628. }
630. signal_timer_disable();
632. main_fdw = fdwatch_new(4096);
634. if ((tcp_socket = socket_tcp_bind(g_szPublicIP, mother_port)) == INVALID_SOCKET)
635. {
636. perror("socket_tcp_bind: tcp_socket");
637. return 0;
638. }
641. #ifndef __UDP_BLOCK__
642. if ((udp_socket = socket_udp_bind(g_szPublicIP, mother_port)) == INVALID_SOCKET)
643. {
644. perror("socket_udp_bind: udp_socket");
645. return 0;
646. }
647. #endif
649. // if internal ip exists, p2p socket uses internal ip, if not use public ip
650. //if ((p2p_socket = socket_tcp_bind(*g_szInternalIP ? g_szInternalIP : g_szPublicIP, p2p_port)) == INVALID_SOCKET)
651. if ((p2p_socket = socket_tcp_bind(g_szPublicIP, p2p_port)) == INVALID_SOCKET)
652. {
653. perror("socket_tcp_bind: p2p_socket");
654. return 0;
655. }
657. fdwatch_add_fd(main_fdw, tcp_socket, NULL, FDW_READ, false);
658. #ifndef __UDP_BLOCK__
659. fdwatch_add_fd(main_fdw, udp_socket, NULL, FDW_READ, false);
660. #endif
661. fdwatch_add_fd(main_fdw, p2p_socket, NULL, FDW_READ, false);
663. db_clientdesc = DESC_MANAGER::instance().CreateConnectionDesc(main_fdw, db_addr, db_port, PHASE_DBCLIENT, true);
664. if (!g_bAuthServer) {
665. db_clientdesc->UpdateChannelStatus(0, true);
666. }
668. if (g_bAuthServer)
669. {
670. if (g_stAuthMasterIP.length() != 0)
671. {
672. fprintf(stderr, "SlaveAuth");
673. g_pkAuthMasterDesc = DESC_MANAGER::instance().CreateConnectionDesc(main_fdw, g_stAuthMasterIP.c_str(), g_wAuthMasterPort, PHASE_P2P, true);
674. P2P_MANAGER::instance().RegisterConnector(g_pkAuthMasterDesc);
675. g_pkAuthMasterDesc->SetP2P(g_stAuthMasterIP.c_str(), g_wAuthMasterPort, g_bChannel);
677. }
678. else
679. {
680. fprintf(stderr, "MasterAuth %d", LC_GetLocalType());
681. }
682. }
683. else
684. {
685. extern unsigned int g_uiSpamBlockDuration;
686. extern unsigned int g_uiSpamBlockScore;
687. extern unsigned int g_uiSpamReloadCycle;
689. sys_log(0, "SPAM_CONFIG: duration %u score %u reload cycle %u\n",
690. g_uiSpamBlockDuration, g_uiSpamBlockScore, g_uiSpamReloadCycle);
692. extern void LoadSpamDB();
693. LoadSpamDB();
694. }
696. signal_timer_enable(30);
697. return 1;
698. }
700. void destroy()
701. {
702. sys_log(0, "<shutdown> Canceling ReloadSpamEvent...");
703. CancelReloadSpamEvent();
705. sys_log(0, "<shutdown> regen_free()...");
706. regen_free();
708. sys_log(0, "<shutdown> Closing sockets...");
709. socket_close(tcp_socket);
710. #ifndef __UDP_BLOCK__
711. socket_close(udp_socket);
712. #endif
713. socket_close(p2p_socket);
715. sys_log(0, "<shutdown> fdwatch_delete()...");
716. fdwatch_delete(main_fdw);
718. sys_log(0, "<shutdown> event_destroy()...");
719. event_destroy();
721. sys_log(0, "<shutdown> CTextFileLoader::DestroySystem()...");
722. CTextFileLoader::DestroySystem();
724. sys_log(0, "<shutdown> thecore_destroy()...");
725. thecore_destroy();
726. }
728. int idle()
729. {
730. static struct timeval pta = { 0, 0 };
731. static int process_time_count = 0;
732. struct timeval now;
734. if (pta.tv_sec == 0)
735. gettimeofday(&pta, (struct timezone *) 0);
737. int passed_pulses;
739. if (!(passed_pulses = thecore_idle()))
740. return 0;
742. assert(passed_pulses > 0);
744. DWORD t;
746. while (passed_pulses--) {
747. heartbeat(thecore_heart, ++thecore_heart->pulse);
749. // To reduce the possibility of abort() in checkpointing
750. thecore_tick();
751. }
753. t = get_dword_time();
754. CHARACTER_MANAGER::instance().Update(thecore_heart->pulse);
755. db_clientdesc->Update(t);
756. s_dwProfiler[PROF_CHR_UPDATE] += (get_dword_time() - t);
758. t = get_dword_time();
759. if (!io_loop(main_fdw)) return 0;
760. s_dwProfiler[PROF_IO] += (get_dword_time() - t);
762. log_rotate();
764. gettimeofday(&now, (struct timezone *) 0);
765. ++process_time_count;
767. if (now.tv_sec - pta.tv_sec > 0)
768. {
769. pt_log("[%3d] event %5d/%-5d idle %-4ld event %-4ld heartbeat %-4ld I/O %-4ld chrUpate %-4ld | WRITE: %-7d | PULSE: %d",
770. process_time_count,
771. num_events_called,
772. event_count(),
773. thecore_profiler[PF_IDLE],
774. s_dwProfiler[PROF_EVENT],
775. s_dwProfiler[PROF_HEARTBEAT],
776. s_dwProfiler[PROF_IO],
777. s_dwProfiler[PROF_CHR_UPDATE],
778. current_bytes_written,
779. thecore_pulse());
781. num_events_called = 0;
782. current_bytes_written = 0;
784. process_time_count = 0;
785. gettimeofday(&pta, (struct timezone *) 0);
787. memset(&thecore_profiler[0], 0, sizeof(thecore_profiler));
788. memset(&s_dwProfiler[0], 0, sizeof(s_dwProfiler));
789. }
791. #ifdef __WIN32__
792. if (_kbhit()) {
793. int c = _getch();
794. switch (c) {
795. case 0x1b: // Esc
796. return 0; // shutdown
797. break;
798. default:
799. break;
800. }
801. }
802. #endif
804. return 1;
805. }
807. int io_loop(LPFDWATCH fdw)
808. {
809. LPDESC d;
810. int num_events, event_idx;
812. DESC_MANAGER::instance().DestroyClosed(); // PHASE_CLOSEÀÎ Á¢¼ÓµéÀ» ²÷¾îÁØ´Ù.
813. DESC_MANAGER::instance().TryConnect();
815. if ((num_events = fdwatch(fdw, 0)) < 0)
816. return 0;
818. for (event_idx = 0; event_idx < num_events; ++event_idx)
819. {
820. d = (LPDESC) fdwatch_get_client_data(fdw, event_idx);
822. if (!d)
823. {
824. if (FDW_READ == fdwatch_check_event(fdw, tcp_socket, event_idx))
825. {
826. DESC_MANAGER::instance().AcceptDesc(fdw, tcp_socket);
827. fdwatch_clear_event(fdw, tcp_socket, event_idx);
828. }
829. else if (FDW_READ == fdwatch_check_event(fdw, p2p_socket, event_idx))
830. {
831. DESC_MANAGER::instance().AcceptP2PDesc(fdw, p2p_socket);
832. fdwatch_clear_event(fdw, p2p_socket, event_idx);
833. }
834. /*
835. else if (FDW_READ == fdwatch_check_event(fdw, udp_socket, event_idx))
836. {
837. char buf[256];
838. struct sockaddr_in cliaddr;
839. socklen_t socklen = sizeof(cliaddr);
841. int iBytesRead;
843. if ((iBytesRead = socket_udp_read(udp_socket, buf, 256, (struct sockaddr *) &cliaddr, &socklen)) > 0)
844. {
845. static CInputUDP s_inputUDP;
847. s_inputUDP.SetSockAddr(cliaddr);
849. int iBytesProceed;
850. s_inputUDP.Process(NULL, buf, iBytesRead, iBytesProceed);
851. }
853. fdwatch_clear_event(fdw, udp_socket, event_idx);
854. }
855. */
856. continue;
857. }
859. int iRet = fdwatch_check_event(fdw, d->GetSocket(), event_idx);
861. switch (iRet)
862. {
863. case FDW_READ:
864. if (db_clientdesc == d)
865. {
866. int size = d->ProcessInput();
868. if (size)
869. sys_log(1, "DB_BYTES_READ: %d", size);
871. if (size < 0)
872. {
873. d->SetPhase(PHASE_CLOSE);
874. }
875. }
876. else if (d->ProcessInput() < 0)
877. {
878. d->SetPhase(PHASE_CLOSE);
879. }
880. break;
882. case FDW_WRITE:
883. if (db_clientdesc == d)
884. {
885. int buf_size = buffer_size(d->GetOutputBuffer());
886. int sock_buf_size = fdwatch_get_buffer_size(fdw, d->GetSocket());
888. int ret = d->ProcessOutput();
890. if (ret < 0)
891. {
892. d->SetPhase(PHASE_CLOSE);
893. }
895. if (buf_size)
896. sys_log(1, "DB_BYTES_WRITE: size %d sock_buf %d ret %d", buf_size, sock_buf_size, ret);
897. }
898. else if (d->ProcessOutput() < 0)
899. {
900. d->SetPhase(PHASE_CLOSE);
901. }
902. break;
904. case FDW_EOF:
905. {
906. d->SetPhase(PHASE_CLOSE);
907. }
908. break;
910. default:
911. sys_err("fdwatch_check_event returned unknown %d", iRet);
912. d->SetPhase(PHASE_CLOSE);
913. break;
914. }
915. }
917. return 1;
918. }

MAIN.CPP