1. #include "stdafx.h"
  2. #include "../../common/billing.h"
  3. #include "config.h"
  4. #include "desc_client.h"
  5. #include "desc_manager.h"
  6. #include "char.h"
  7. #include "char_manager.h"
  8. #include "p2p.h"
  9. #include "guild.h"
  10. #include "guild_manager.h"
  11. #include "party.h"
  12. #include "messenger_manager.h"
  13. #include "empire_text_convert.h"
  14. #include "unique_item.h"
  15. #include "xmas_event.h"
  16. #include "affect.h"
  17. #include "castle.h"
  18. #include "dev_log.h"
  19. #include "locale_service.h"
  20. #include "questmanager.h"
  21. #include "pcbang.h"
  22. #include "skill.h"
  23. #include "threeway_war.h"
  26. ////////////////////////////////////////////////////////////////////////////////
  27. // Input Processor
  28. CInputP2P::CInputP2P()
  29. {
  30. BindPacketInfo(&m_packetInfoGG);
  31. }
  33. void CInputP2P::Login(LPDESC d, const char * c_pData)
  34. {
  35. P2P_MANAGER::instance().Login(d, (TPacketGGLogin *) c_pData);
  36. }
  38. void CInputP2P::Logout(LPDESC d, const char * c_pData)
  39. {
  40. TPacketGGLogout * p = (TPacketGGLogout *) c_pData;
  41. P2P_MANAGER::instance().Logout(p->szName);
  42. }
  44. int CInputP2P::Relay(LPDESC d, const char * c_pData, size_t uiBytes)
  45. {
  46. TPacketGGRelay * p = (TPacketGGRelay *) c_pData;
  48. if (uiBytes < sizeof(TPacketGGRelay) + p->lSize)
  49. return -1;
  51. if (p->lSize < 0)
  52. {
  53. sys_err("invalid packet length %d", p->lSize);
  54. d->SetPhase(PHASE_CLOSE);
  55. return -1;
  56. }
  58. sys_log(0, "InputP2P::Relay : %s size %d", p->szName, p->lSize);
  60. LPCHARACTER pkChr = CHARACTER_MANAGER::instance().FindPC(p->szName);
  62. const BYTE* c_pbData = (const BYTE *) (c_pData + sizeof(TPacketGGRelay));
  64. if (!pkChr)
  65. return p->lSize;
  67. if (*c_pbData == HEADER_GC_WHISPER)
  68. {
  69. if (pkChr->IsBlockMode(BLOCK_WHISPER))
  70. {
  71. // 귓속말 거부 상태에서 귓속말 거부.
  72. return p->lSize;
  73. }
  75. char buf[1024];
  76. memcpy(buf, c_pbData, MIN(p->lSize, sizeof(buf)));
  78. TPacketGCWhisper* p2 = (TPacketGCWhisper*) buf;
  79. // bType 상위 4비트: Empire 번호
  80. // bType 하위 4비트: EWhisperType
  81. BYTE bToEmpire = (p2->bType >> 4);
  82. p2->bType = p2->bType & 0x0F;
  83. if(p2->bType == 0x0F) {
  84. // 시스템 메세지 귓속말은 bType의 상위비트까지 모두 사용함.
  85. p2->bType = WHISPER_TYPE_SYSTEM;
  86. } else {
  87. if (!pkChr->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
  88. if (bToEmpire >= 1 && bToEmpire <= 3 && pkChr->GetEmpire() != bToEmpire)
  89. {
  90. ConvertEmpireText(bToEmpire,
  91. buf + sizeof(TPacketGCWhisper),
  92. p2->wSize - sizeof(TPacketGCWhisper),
  93. 10+2*pkChr->GetSkillPower(SKILL_LANGUAGE1 + bToEmpire - 1));
  94. }
  95. }
  97. pkChr->GetDesc()->Packet(buf, p->lSize);
  98. }
  99. else
  100. pkChr->GetDesc()->Packet(c_pbData, p->lSize);
  102. return (p->lSize);
  103. }
  105. int CInputP2P::Notice(LPDESC d, const char * c_pData, size_t uiBytes)
  106. {
  107. TPacketGGNotice * p = (TPacketGGNotice *) c_pData;
  109. if (uiBytes < sizeof(TPacketGGNotice) + p->lSize)
  110. return -1;
  112. if (p->lSize < 0)
  113. {
  114. sys_err("invalid packet length %d", p->lSize);
  115. d->SetPhase(PHASE_CLOSE);
  116. return -1;
  117. }
  119. char szBuf[256+1];
  120. strlcpy(szBuf, c_pData + sizeof(TPacketGGNotice), MIN(p->lSize + 1, sizeof(szBuf)));
  121. SendNotice(szBuf);
  122. return (p->lSize);
  123. }
  125. int CInputP2P::MonarchNotice(LPDESC d, const char * c_pData, size_t uiBytes)
  126. {
  127. TPacketGGMonarchNotice * p = (TPacketGGMonarchNotice *) c_pData;
  129. if (uiBytes < p->lSize + sizeof(TPacketGGMonarchNotice))
  130. return -1;
  132. if (p->lSize < 0)
  133. {
  134. sys_err("invalid packet length %d", p->lSize);
  135. d->SetPhase(PHASE_CLOSE);
  136. return -1;
  137. }
  139. char szBuf[256+1];
  140. strlcpy(szBuf, c_pData + sizeof(TPacketGGMonarchNotice), MIN(p->lSize + 1, sizeof(szBuf)));
  141. SendMonarchNotice(p->bEmpire, szBuf);
  142. return (p->lSize);
  143. }
  145. int CInputP2P::MonarchTransfer(LPDESC d, const char* c_pData)
  146. {
  147. TPacketMonarchGGTransfer* p = (TPacketMonarchGGTransfer*) c_pData;
  148. LPCHARACTER pTargetChar = CHARACTER_MANAGER::instance().FindByPID(p->dwTargetPID);
  150. if (pTargetChar != NULL)
  151. {
  152. unsigned int qIndex = quest::CQuestManager::instance().GetQuestIndexByName("monarch_transfer");
  154. if (qIndex != 0)
  155. {
  156. pTargetChar->SetQuestFlag("monarch_transfer.x", p->x);
  157. pTargetChar->SetQuestFlag("monarch_transfer.y", p->y);
  158. quest::CQuestManager::instance().Letter(pTargetChar->GetPlayerID(), qIndex, 0);
  159. }
  160. }
  162. return 0;
  163. }
  165. int CInputP2P::Guild(LPDESC d, const char* c_pData, size_t uiBytes)
  166. {
  167. TPacketGGGuild * p = (TPacketGGGuild *) c_pData;
  168. uiBytes -= sizeof(TPacketGGGuild);
  169. c_pData += sizeof(TPacketGGGuild);
  171. CGuild * g = CGuildManager::instance().FindGuild(p->dwGuild);
  173. switch (p->bSubHeader)
  174. {
  175. case GUILD_SUBHEADER_GG_CHAT:
  176. {
  177. if (uiBytes < sizeof(TPacketGGGuildChat))
  178. return -1;
  180. TPacketGGGuildChat * p = (TPacketGGGuildChat *) c_pData;
  182. if (g)
  183. g->P2PChat(p->szText);
  185. return sizeof(TPacketGGGuildChat);
  186. }
  188. case GUILD_SUBHEADER_GG_SET_MEMBER_COUNT_BONUS:
  189. {
  190. if (uiBytes < sizeof(int))
  191. return -1;
  193. int iBonus = *((int *) c_pData);
  194. CGuild* pGuild = CGuildManager::instance().FindGuild(p->dwGuild);
  195. if (pGuild)
  196. {
  197. pGuild->SetMemberCountBonus(iBonus);
  198. }
  199. return sizeof(int);
  200. }
  201. default:
  202. sys_err ("UNKNOWN GUILD SUB PACKET");
  203. break;
  204. }
  205. return 0;
  206. }
  209. struct FuncShout
  210. {
  211. const char * m_str;
  212. BYTE m_bEmpire;
  214. FuncShout(const char * str, BYTE bEmpire) : m_str(str), m_bEmpire(bEmpire)
  215. {
  216. }
  218. void operator () (LPDESC d)
  219. {
  220. #ifdef ENABLE_NEWSTUFF
  221. if (!d->GetCharacter() || (!g_bGlobalShoutEnable && d->GetCharacter()->GetGMLevel() == GM_PLAYER && d->GetEmpire() != m_bEmpire))
  222. return;
  223. #else
  224. if (!d->GetCharacter() || (d->GetCharacter()->GetGMLevel() == GM_PLAYER && d->GetEmpire() != m_bEmpire))
  225. return;
  226. #endif
  227. d->GetCharacter()->ChatPacket(CHAT_TYPE_SHOUT, "%s", m_str);
  228. }
  229. };
  231. void SendShout(const char * szText, BYTE bEmpire)
  232. {
  233. const DESC_MANAGER::DESC_SET & c_ref_set = DESC_MANAGER::instance().GetClientSet();
  234. std::for_each(c_ref_set.begin(), c_ref_set.end(), FuncShout(szText, bEmpire));
  235. }
  237. void CInputP2P::Shout(const char * c_pData)
  238. {
  239. TPacketGGShout * p = (TPacketGGShout *) c_pData;
  240. SendShout(p->szText, p->bEmpire);
  241. }
  243. void CInputP2P::Disconnect(const char * c_pData)
  244. {
  245. TPacketGGDisconnect * p = (TPacketGGDisconnect *) c_pData;
  247. LPDESC d = DESC_MANAGER::instance().FindByLoginName(p->szLogin);
  249. if (!d)
  250. return;
  252. if (!d->GetCharacter())
  253. {
  254. d->SetPhase(PHASE_CLOSE);
  255. }
  256. else
  257. d->DisconnectOfSameLogin();
  258. }
  260. void CInputP2P::Setup(LPDESC d, const char * c_pData)
  261. {
  262. TPacketGGSetup * p = (TPacketGGSetup *) c_pData;
  263. sys_log(0, "P2P: Setup %s:%d", d->GetHostName(), p->wPort);
  264. d->SetP2P(d->GetHostName(), p->wPort, p->bChannel);
  265. }
  267. void CInputP2P::MessengerAdd(const char * c_pData)
  268. {
  269. TPacketGGMessenger * p = (TPacketGGMessenger *) c_pData;
  270. sys_log(0, "P2P: Messenger Add %s %s", p->szAccount, p->szCompanion);
  271. MessengerManager::instance().__AddToList(p->szAccount, p->szCompanion);
  272. }
  274. void CInputP2P::MessengerRemove(const char * c_pData)
  275. {
  276. TPacketGGMessenger * p = (TPacketGGMessenger *) c_pData;
  277. sys_log(0, "P2P: Messenger Remove %s %s", p->szAccount, p->szCompanion);
  278. MessengerManager::instance().__RemoveFromList(p->szAccount, p->szCompanion);
  279. }
  281. void CInputP2P::FindPosition(LPDESC d, const char* c_pData)
  282. {
  283. TPacketGGFindPosition* p = (TPacketGGFindPosition*) c_pData;
  284. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(p->dwTargetPID);
  285. #ifdef ENABLE_CMD_WARP_IN_DUNGEON
  286. if (ch)
  287. #else
  288. if (ch && ch->GetMapIndex() < 10000)
  289. #endif
  290. {
  291. TPacketGGWarpCharacter pw;
  292. pw.header = HEADER_GG_WARP_CHARACTER;
  293. pw.pid = p->dwFromPID;
  294. pw.x = ch->GetX();
  295. pw.y = ch->GetY();
  296. #ifdef ENABLE_CMD_WARP_IN_DUNGEON
  297. pw.mapIndex = (ch->GetMapIndex() < 10000) ? 0 : ch->GetMapIndex();
  298. #endif
  299. d->Packet(&pw, sizeof(pw));
  300. }
  301. }
  303. void CInputP2P::WarpCharacter(const char* c_pData)
  304. {
  305. TPacketGGWarpCharacter* p = (TPacketGGWarpCharacter*) c_pData;
  306. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindByPID(p->pid);
  307. #ifdef ENABLE_CMD_WARP_IN_DUNGEON
  308. if (ch)
  309. ch->WarpSet(p->x, p->y, p->mapIndex);
  310. #else
  311. if (ch)
  312. ch->WarpSet(p->x, p->y);
  313. #endif
  314. }
  316. void CInputP2P::GuildWarZoneMapIndex(const char* c_pData)
  317. {
  318. TPacketGGGuildWarMapIndex * p = (TPacketGGGuildWarMapIndex*) c_pData;
  319. CGuildManager & gm = CGuildManager::instance();
  321. sys_log(0, "P2P: GuildWarZoneMapIndex g1(%u) vs g2(%u), mapIndex(%d)", p->dwGuildID1, p->dwGuildID2, p->lMapIndex);
  323. CGuild * g1 = gm.FindGuild(p->dwGuildID1);
  324. CGuild * g2 = gm.FindGuild(p->dwGuildID2);
  326. if (g1 && g2)
  327. {
  328. g1->SetGuildWarMapIndex(p->dwGuildID2, p->lMapIndex);
  329. g2->SetGuildWarMapIndex(p->dwGuildID1, p->lMapIndex);
  330. }
  331. }
  333. void CInputP2P::Transfer(const char * c_pData)
  334. {
  335. TPacketGGTransfer * p = (TPacketGGTransfer *) c_pData;
  337. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(p->szName);
  339. if (ch)
  340. ch->WarpSet(p->lX, p->lY);
  341. }
  343. void CInputP2P::XmasWarpSanta(const char * c_pData)
  344. {
  345. TPacketGGXmasWarpSanta * p =(TPacketGGXmasWarpSanta *) c_pData;
  347. if (p->bChannel == g_bChannel && map_allow_find(p->lMapIndex))
  348. {
  349. int iNextSpawnDelay = 50 * 60;
  351. xmas::SpawnSanta(p->lMapIndex, iNextSpawnDelay); // 50분있다가 새로운 산타가 나타남 (한국은 20분)
  353. TPacketGGXmasWarpSantaReply pack_reply;
  354. pack_reply.bHeader = HEADER_GG_XMAS_WARP_SANTA_REPLY;
  355. pack_reply.bChannel = g_bChannel;
  356. P2P_MANAGER::instance().Send(&pack_reply, sizeof(pack_reply));
  357. }
  358. }
  360. void CInputP2P::XmasWarpSantaReply(const char* c_pData)
  361. {
  362. TPacketGGXmasWarpSantaReply* p = (TPacketGGXmasWarpSantaReply*) c_pData;
  364. if (p->bChannel == g_bChannel)
  365. {
  366. CharacterVectorInteractor i;
  368. if (CHARACTER_MANAGER::instance().GetCharactersByRaceNum(xmas::MOB_SANTA_VNUM, i))
  369. {
  370. CharacterVectorInteractor::iterator it = i.begin();
  372. while (it != i.end()) {
  373. M2_DESTROY_CHARACTER(*it++);
  374. }
  375. }
  376. }
  377. }
  379. void CInputP2P::LoginPing(LPDESC d, const char * c_pData)
  380. {
  381. TPacketGGLoginPing * p = (TPacketGGLoginPing *) c_pData;
  383. SendBillingExpire(p->szLogin, BILLING_DAY, 0, NULL);
  385. if (!g_pkAuthMasterDesc) // If I am master, I have to broadcast
  386. P2P_MANAGER::instance().Send(p, sizeof(TPacketGGLoginPing), d);
  387. }
  389. // BLOCK_CHAT
  390. void CInputP2P::BlockChat(const char * c_pData)
  391. {
  392. TPacketGGBlockChat * p = (TPacketGGBlockChat *) c_pData;
  394. LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(p->szName);
  396. if (ch)
  397. {
  398. sys_log(0, "BLOCK CHAT apply name %s dur %d", p->szName, p->lBlockDuration);
  399. ch->AddAffect(AFFECT_BLOCK_CHAT, POINT_NONE, 0, AFF_NONE, p->lBlockDuration, 0, true);
  400. }
  401. else
  402. {
  403. sys_log(0, "BLOCK CHAT fail name %s dur %d", p->szName, p->lBlockDuration);
  404. }
  405. }
  406. // END_OF_BLOCK_CHAT
  407. //
  409. void CInputP2P::PCBangUpdate(const char* c_pData)
  410. {
  411. TPacketPCBangUpdate* p = (TPacketPCBangUpdate*)c_pData;
  413. CPCBangManager::instance().RequestUpdateIPList(p->ulPCBangID);
  414. }
  416. void CInputP2P::IamAwake(LPDESC d, const char * c_pData)
  417. {
  418. std::string hostNames;
  419. P2P_MANAGER::instance().GetP2PHostNames(hostNames);
  420. sys_log(0, "P2P Awakeness check from %s. My P2P connection number is %d. and details...\n%s", d->GetHostName(), P2P_MANAGER::instance().GetDescCount(), hostNames.c_str());
  421. }
  423. int CInputP2P::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
  424. {
  425. if (test_server)
  426. sys_log(0, "CInputP2P::Anlayze[Header %d]", bHeader);
  428. int iExtraLen = 0;
  430. switch (bHeader)
  431. {
  432. case HEADER_GG_SETUP:
  433. Setup(d, c_pData);
  434. break;
  436. case HEADER_GG_LOGIN:
  437. Login(d, c_pData);
  438. break;
  440. case HEADER_GG_LOGOUT:
  441. Logout(d, c_pData);
  442. break;
  444. case HEADER_GG_RELAY:
  445. if ((iExtraLen = Relay(d, c_pData, m_iBufferLeft)) < 0)
  446. return -1;
  447. break;
  449. case HEADER_GG_NOTICE:
  450. if ((iExtraLen = Notice(d, c_pData, m_iBufferLeft)) < 0)
  451. return -1;
  452. break;
  454. case HEADER_GG_SHUTDOWN:
  455. sys_err("Accept shutdown p2p command from %s.", d->GetHostName());
  456. Shutdown(10);
  457. break;
  459. case HEADER_GG_GUILD:
  460. if ((iExtraLen = Guild(d, c_pData, m_iBufferLeft)) < 0)
  461. return -1;
  462. break;
  464. case HEADER_GG_SHOUT:
  465. Shout(c_pData);
  466. break;
  468. case HEADER_GG_DISCONNECT:
  469. Disconnect(c_pData);
  470. break;
  472. case HEADER_GG_MESSENGER_ADD:
  473. MessengerAdd(c_pData);
  474. break;
  476. case HEADER_GG_MESSENGER_REMOVE:
  477. MessengerRemove(c_pData);
  478. break;
  480. case HEADER_GG_FIND_POSITION:
  481. FindPosition(d, c_pData);
  482. break;
  484. case HEADER_GG_WARP_CHARACTER:
  485. WarpCharacter(c_pData);
  486. break;
  488. case HEADER_GG_GUILD_WAR_ZONE_MAP_INDEX:
  489. GuildWarZoneMapIndex(c_pData);
  490. break;
  492. case HEADER_GG_TRANSFER:
  493. Transfer(c_pData);
  494. break;
  496. case HEADER_GG_XMAS_WARP_SANTA:
  497. XmasWarpSanta(c_pData);
  498. break;
  500. case HEADER_GG_XMAS_WARP_SANTA_REPLY:
  501. XmasWarpSantaReply(c_pData);
  502. break;
  504. case HEADER_GG_RELOAD_CRC_LIST:
  505. LoadValidCRCList();
  506. break;
  508. case HEADER_GG_CHECK_CLIENT_VERSION:
  509. CheckClientVersion();
  510. break;
  512. case HEADER_GG_LOGIN_PING:
  513. LoginPing(d, c_pData);
  514. break;
  516. case HEADER_GG_BLOCK_CHAT:
  517. BlockChat(c_pData);
  518. break;
  520. case HEADER_GG_SIEGE:
  521. {
  522. TPacketGGSiege* pSiege = (TPacketGGSiege*)c_pData;
  523. castle_siege(pSiege->bEmpire, pSiege->bTowerCount);
  524. }
  525. break;
  527. case HEADER_GG_MONARCH_NOTICE:
  528. if ((iExtraLen = MonarchNotice(d, c_pData, m_iBufferLeft)) < 0)
  529. return -1;
  530. break;
  532. case HEADER_GG_MONARCH_TRANSFER :
  533. MonarchTransfer(d, c_pData);
  534. break;
  536. case HEADER_GG_PCBANG_UPDATE :
  537. PCBangUpdate(c_pData);
  538. break;
  540. case HEADER_GG_CHECK_AWAKENESS:
  541. IamAwake(d, c_pData);
  542. break;
  543. }
  545. return (iExtraLen);
  546. }