API tools faq
paste
Advertisement
SergiuAndreiM

messenger_manager

SergiuAndreiM
Jul 2nd, 2017
251
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.89 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include "constants.h"
  3. #include "gm.h"
  4. #include "messenger_manager.h"
  5. #include "buffer_manager.h"
  6. #include "desc_client.h"
  7. #include "log.h"
  8. #include "config.h"
  9. #include "p2p.h"
  10. #include "crc32.h"
  11. #include "char.h"
  12. #include "char_manager.h"
  13. #include "questmanager.h"
  14.  
  15. MessengerManager::MessengerManager()
  16. {
  17. }
  18.  
  19. MessengerManager::~MessengerManager()
  20. {
  21. }
  22.  
  23. void MessengerManager::Initialize()
  24. {
  25. }
  26.  
  27. void MessengerManager::Destroy()
  28. {
  29. }
  30.  
  31. void MessengerManager::P2PLogin(MessengerManager::keyA account)
  32. {
  33.     Login(account);
  34. }
  35.  
  36. void MessengerManager::P2PLogout(MessengerManager::keyA account)
  37. {
  38.     Logout(account);
  39. }
  40.  
  41. void MessengerManager::Login(MessengerManager::keyA account)
  42. {
  43.     if (m_set_loginAccount.find(account) != m_set_loginAccount.end())
  44.         return;
  45.  
  46.     DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&MessengerManager::LoadList), this),
  47.             "SELECT account, companion FROM messenger_list%s WHERE account='%s'", get_table_postfix(), account.c_str());
  48. #ifdef ENABLE_MESSENGER_BLOCK
  49.     DBManager::instance().FuncQuery(std::bind1st(std::mem_fun(&MessengerManager::LoadBlockList), this),
  50.             "SELECT account, companion FROM messenger_block_list%s WHERE account='%s'", get_table_postfix(), account.c_str());
  51. #endif
  52.  
  53.     m_set_loginAccount.insert(account);
  54. }
  55.  
  56. void MessengerManager::LoadList(SQLMsg * msg)
  57. {
  58.     if (NULL == msg)
  59.         return;
  60.  
  61.     if (NULL == msg->Get())
  62.         return;
  63.  
  64.     if (msg->Get()->uiNumRows == 0)
  65.         return;
  66.  
  67.     std::string account;
  68.  
  69.     sys_log(1, "Messenger::LoadList");
  70.  
  71.     for (uint i = 0; i < msg->Get()->uiNumRows; ++i)
  72.     {
  73.         MYSQL_ROW row = mysql_fetch_row(msg->Get()->pSQLResult);
  74.  
  75.         if (row[0] && row[1])
  76.         {
  77.             if (account.length() == 0)
  78.                 account = row[0];
  79.  
  80.             m_Relation[row[0]].insert(row[1]);
  81.             m_InverseRelation[row[1]].insert(row[0]);
  82.         }
  83.     }
  84.  
  85.     SendList(account);
  86.  
  87.     std::set<MessengerManager::keyT>::iterator it;
  88.  
  89.     for (it = m_InverseRelation[account].begin(); it != m_InverseRelation[account].end(); ++it)
  90.         SendLogin(*it, account);
  91. }
  92.  
  93. #ifdef ENABLE_MESSENGER_BLOCK
  94. bool MessengerManager::IsBlocked(MessengerManager::keyA account, MessengerManager::keyA companion)
  95. {  
  96.     if (m_BlockRelation[account].find(companion) != m_BlockRelation[account].end() || m_BlockRelation[companion].find(account) != m_BlockRelation[companion].end())
  97.         return true;
  98.     else
  99.         return false;
  100. }
  101. bool MessengerManager::IsBlocked_Target(MessengerManager::keyA account, MessengerManager::keyA companion)
  102. {  
  103.     return (m_BlockRelation[account].find(companion) != m_BlockRelation[account].end());
  104. }
  105. bool MessengerManager::IsBlocked_Me(MessengerManager::keyA account, MessengerManager::keyA companion)
  106. {  
  107.     return (m_BlockRelation[companion].find(account) != m_BlockRelation[companion].end());
  108. }
  109. bool MessengerManager::IsFriend(MessengerManager::keyA account, MessengerManager::keyA companion)
  110. {  
  111.     //gift function
  112.     if (m_Relation[account].find(companion) != m_Relation[account].end() || m_Relation[companion].find(account) != m_Relation[companion].end())
  113.         return true;
  114.     else
  115.         return false;
  116. }
  117. void MessengerManager::LoadBlockList(SQLMsg * msg)
  118. {
  119.     if (NULL == msg or NULL == msg->Get() or msg->Get()->uiNumRows == 0)
  120.         return;
  121.    
  122.     std::string account;
  123.  
  124.     // sys_log(1, "Messenger::LoadBlockList");
  125.  
  126.     for (uint i = 0; i < msg->Get()->uiNumRows; ++i)
  127.     {
  128.         MYSQL_ROW row = mysql_fetch_row(msg->Get()->pSQLResult);
  129.  
  130.         if (row[0] && row[1])
  131.         {
  132.             if (account.length() == 0)
  133.                 account = row[0];
  134.  
  135.             m_BlockRelation[row[0]].insert(row[1]);
  136.             m_InverseBlockRelation[row[1]].insert(row[0]);
  137.         }
  138.     }
  139.  
  140.     SendBlockList(account);
  141.  
  142.     std::set<MessengerManager::keyBL>::iterator it;
  143.  
  144.     for (it = m_InverseBlockRelation[account].begin(); it != m_InverseBlockRelation[account].end(); ++it)
  145.         SendBlockLogin(*it, account);
  146. }
  147. void MessengerManager::SendBlockList(MessengerManager::keyA account)
  148. {
  149.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  150.  
  151.     if (!ch)
  152.         return;
  153.  
  154.     LPDESC d = ch->GetDesc();
  155.  
  156.     // if (!d or m_BlockRelation.find(account) == m_BlockRelation.end() or m_BlockRelation[account].empty())
  157.     if (!d)
  158.         return;
  159.  
  160.     TPacketGCMessenger pack;
  161.  
  162.     pack.header     = HEADER_GC_MESSENGER;
  163.     pack.subheader  = MESSENGER_SUBHEADER_GC_BLOCK_LIST;
  164.     pack.size       = sizeof(TPacketGCMessenger);
  165.  
  166.     TPacketGCMessengerBlockListOffline pack_offline;
  167.     TPacketGCMessengerBlockListOnline pack_online;
  168.  
  169.     TEMP_BUFFER buf(128 * 1024); // 128k
  170.  
  171.     itertype(m_BlockRelation[account]) it = m_BlockRelation[account].begin(), eit = m_BlockRelation[account].end();
  172.  
  173.     while (it != eit)
  174.     {
  175.         if (m_set_loginAccount.find(*it) != m_set_loginAccount.end())
  176.         {
  177.             pack_online.connected = 1;
  178.  
  179.             // Online
  180.             pack_online.length = it->size();
  181.  
  182.             buf.write(&pack_online, sizeof(TPacketGCMessengerBlockListOnline));
  183.             buf.write(it->c_str(), it->size());
  184.         }
  185.         else
  186.         {
  187.             pack_offline.connected = 0;
  188.  
  189.             // Offline
  190.             pack_offline.length = it->size();
  191.  
  192.             buf.write(&pack_offline, sizeof(TPacketGCMessengerBlockListOffline));
  193.             buf.write(it->c_str(), it->size());
  194.         }
  195.  
  196.         ++it;
  197.     }
  198.  
  199.     pack.size += buf.size();
  200.  
  201.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  202.     d->Packet(buf.read_peek(), buf.size());
  203. }
  204. void MessengerManager::SendBlockLogin(MessengerManager::keyA account, MessengerManager::keyA companion)
  205. {
  206.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  207.     LPDESC d = ch ? ch->GetDesc() : NULL;
  208.  
  209.     if (!d)
  210.         return;
  211.  
  212.     if (!d->GetCharacter())
  213.         return;
  214.  
  215.     BYTE bLen = companion.size();
  216.  
  217.     TPacketGCMessenger pack;
  218.  
  219.     pack.header         = HEADER_GC_MESSENGER;
  220.     pack.subheader      = MESSENGER_SUBHEADER_GC_BLOCK_LOGIN;
  221.     pack.size           = sizeof(TPacketGCMessenger) + sizeof(BYTE) + bLen;
  222.  
  223.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  224.     d->BufferedPacket(&bLen, sizeof(BYTE));
  225.     d->Packet(companion.c_str(), companion.size());
  226. }
  227.  
  228. void MessengerManager::SendBlockLogout(MessengerManager::keyA account, MessengerManager::keyA companion)
  229. {
  230.     if (!companion.size())
  231.         return;
  232.  
  233.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  234.     LPDESC d = ch ? ch->GetDesc() : NULL;
  235.  
  236.     if (!d)
  237.         return;
  238.  
  239.     BYTE bLen = companion.size();
  240.  
  241.     TPacketGCMessenger pack;
  242.  
  243.     pack.header     = HEADER_GC_MESSENGER;
  244.     pack.subheader  = MESSENGER_SUBHEADER_GC_BLOCK_LOGOUT;
  245.     pack.size       = sizeof(TPacketGCMessenger) + sizeof(BYTE) + bLen;
  246.  
  247.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  248.     d->BufferedPacket(&bLen, sizeof(BYTE));
  249.     d->Packet(companion.c_str(), companion.size());
  250. }
  251.  
  252. void MessengerManager::AddToBlockList(MessengerManager::keyA account, MessengerManager::keyA companion)
  253. {
  254.     if (companion.size() == 0)
  255.         return;
  256.  
  257.     if (m_BlockRelation[account].find(companion) != m_BlockRelation[account].end())
  258.         return;
  259.  
  260.     // sys_log(0, "Messenger Add %s %s", account.c_str(), companion.c_str());
  261.     DBManager::instance().Query("INSERT INTO messenger_block_list%s VALUES ('%s', '%s', NOW())",
  262.             get_table_postfix(), account.c_str(), companion.c_str());
  263.  
  264.     __AddToBlockList(account, companion);
  265.  
  266.     TPacketGGMessenger p2ppck;
  267.  
  268.     p2ppck.bHeader = HEADER_GG_MESSENGER_BLOCK_ADD;
  269.     strlcpy(p2ppck.szAccount, account.c_str(), sizeof(p2ppck.szAccount));
  270.     strlcpy(p2ppck.szCompanion, companion.c_str(), sizeof(p2ppck.szCompanion));
  271.     P2P_MANAGER::instance().Send(&p2ppck, sizeof(TPacketGGMessenger));
  272. }
  273. void MessengerManager::__AddToBlockList(MessengerManager::keyA account, MessengerManager::keyA companion)
  274. {
  275.     //yeni eklerken
  276.     m_BlockRelation[account].insert(companion);
  277.     m_InverseBlockRelation[companion].insert(account);
  278.  
  279.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  280.     LPDESC d = ch ? ch->GetDesc() : NULL;
  281.  
  282.     if (d)
  283.     {
  284.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s bloklandi"), companion.c_str());
  285.     }
  286.  
  287.     LPCHARACTER tch = CHARACTER_MANAGER::instance().FindPC(companion.c_str());
  288.  
  289.     if (tch)
  290.         SendBlockLogin(account, companion);
  291.     else
  292.         SendBlockLogout(account, companion);
  293. }
  294. void MessengerManager::RemoveFromBlockList(MessengerManager::keyA account, MessengerManager::keyA companion)
  295. {
  296.     if (companion.size() == 0)
  297.         return;
  298.  
  299.     // sys_log(1, "Messenger Remove %s %s", account.c_str(), companion.c_str());
  300.     DBManager::instance().Query("DELETE FROM messenger_block_list%s WHERE account='%s' AND companion = '%s'",
  301.     get_table_postfix(), account.c_str(), companion.c_str());
  302.            
  303.     __RemoveFromBlockList(account, companion);
  304.  
  305.     TPacketGGMessenger p2ppck;
  306.  
  307.     p2ppck.bHeader = HEADER_GG_MESSENGER_BLOCK_REMOVE;
  308.     strlcpy(p2ppck.szAccount, account.c_str(), sizeof(p2ppck.szAccount));
  309.     strlcpy(p2ppck.szCompanion, companion.c_str(), sizeof(p2ppck.szCompanion));
  310.     P2P_MANAGER::instance().Send(&p2ppck, sizeof(TPacketGGMessenger));
  311. }
  312. void MessengerManager::__RemoveFromBlockList(MessengerManager::keyA account, MessengerManager::keyA companion)
  313. {
  314.     m_BlockRelation[account].erase(companion);
  315.     m_InverseBlockRelation[companion].erase(account);
  316.  
  317.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  318.     LPDESC d = ch ? ch->GetDesc() : NULL;
  319.  
  320.     if (d)
  321.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<메신져> %s 님을 메신저에서 삭제하였습니다."), companion.c_str());
  322. }
  323. void MessengerManager::RemoveAllBlockList(keyA account)
  324. {
  325.     std::set<keyBL> company(m_BlockRelation[account]);
  326.  
  327.     DBManager::instance().Query("DELETE FROM messenger_block_list%s WHERE account='%s' OR companion='%s'",
  328.             get_table_postfix(), account.c_str(), account.c_str());
  329.  
  330.     for (std::set<keyT>::iterator iter = company.begin(); iter != company.end(); iter++)
  331.     {
  332.         this->RemoveFromList(account, *iter);
  333.     }
  334.  
  335.     for (std::set<keyBL>::iterator iter = company.begin(); iter != company.end();)
  336.     {
  337.         company.erase(iter++);
  338.     }
  339.  
  340.     company.clear();
  341. }
  342. void MessengerManager::EkleLan(MessengerManager::keyA account, MessengerManager::keyA companion)
  343. {
  344.     DWORD dw1 = GetCRC32(companion.c_str(), companion.length());
  345.     DWORD dw2 = GetCRC32(account.c_str(), account.length());
  346.  
  347.     char buf[64];
  348.     snprintf(buf, sizeof(buf), "%u:%u", dw1, dw2);
  349.     DWORD dwComplex = GetCRC32(buf, strlen(buf));
  350.  
  351.     if (m_set_requestToAdd.find(dwComplex) == m_set_requestToAdd.end())
  352.     {
  353.         sys_log(0, "MessengerManager::EkleLan : request not exist %s -> %s", companion.c_str(), account.c_str());
  354.         return;
  355.     }
  356.     // if (gm_get_level(companion.c_str()) != GM_PLAYER)
  357.     // {
  358.        
  359.         // return; 
  360.     // }
  361.     m_set_requestToAdd.erase(dwComplex);
  362.     ///updated
  363.     AddToBlockList(companion, account);
  364.     //end
  365.     AddToBlockList(account, companion);
  366. }
  367. #endif
  368.  
  369. void MessengerManager::Logout(MessengerManager::keyA account)
  370. {
  371.     if (m_set_loginAccount.find(account) == m_set_loginAccount.end())
  372.         return;
  373.  
  374.     m_set_loginAccount.erase(account);
  375.  
  376.     std::set<MessengerManager::keyT>::iterator it;
  377.  
  378.     for (it = m_InverseRelation[account].begin(); it != m_InverseRelation[account].end(); ++it)
  379.     {
  380.         SendLogout(*it, account);
  381.     }
  382.  
  383.     std::map<keyT, std::set<keyT> >::iterator it2 = m_Relation.begin();
  384.  
  385.     while (it2 != m_Relation.end())
  386.     {
  387.         it2->second.erase(account);
  388.         ++it2;
  389.     }
  390.  
  391.     #ifdef ENABLE_MESSENGER_BLOCK
  392.     std::set<MessengerManager::keyBL>::iterator it61;
  393.    
  394.     for (it61 = m_InverseBlockRelation[account].begin(); it61 != m_InverseBlockRelation[account].end(); ++it61)
  395.     {
  396.         SendBlockLogout(*it61, account);
  397.     }
  398.  
  399.     std::map<keyBL, std::set<keyBL> >::iterator it3 = m_BlockRelation.begin();
  400.  
  401.     while (it3 != m_BlockRelation.end())
  402.     {
  403.         it3->second.erase(account);
  404.         ++it3;
  405.     }
  406.     m_BlockRelation.erase(account);
  407.     #endif
  408.  
  409.     m_Relation.erase(account);
  410.     //m_map_stMobile.erase(account);
  411. }
  412.  
  413. void MessengerManager::RequestToAdd(LPCHARACTER ch, LPCHARACTER target)
  414. {
  415.     if (!ch->IsPC() || !target->IsPC())
  416.         return;
  417.    
  418.     if (quest::CQuestManager::instance().GetPCForce(ch->GetPlayerID())->IsRunning() == true)
  419.     {
  420.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ó´ë¹æÀÌ Ä£±¸ Ãß°¡¸¦ ¹ÞÀ» ¼ö ¾ø´Â »óÅÂÀÔ´Ï´Ù."));
  421.         return;
  422.     }
  423.  
  424.     if (quest::CQuestManager::instance().GetPCForce(target->GetPlayerID())->IsRunning() == true)
  425.         return;
  426.  
  427.     DWORD dw1 = GetCRC32(ch->GetName(), strlen(ch->GetName()));
  428.     DWORD dw2 = GetCRC32(target->GetName(), strlen(target->GetName()));
  429.  
  430.     char buf[64];
  431.     snprintf(buf, sizeof(buf), "%u:%u", dw1, dw2);
  432.     DWORD dwComplex = GetCRC32(buf, strlen(buf));
  433.  
  434.     m_set_requestToAdd.insert(dwComplex);
  435.  
  436.     target->ChatPacket(CHAT_TYPE_COMMAND, "messenger_auth %s", ch->GetName());
  437. }
  438.  
  439. bool MessengerManager::AuthToAdd(MessengerManager::keyA account, MessengerManager::keyA companion, bool bDeny)
  440. {
  441.     DWORD dw1 = GetCRC32(companion.c_str(), companion.length());
  442.     DWORD dw2 = GetCRC32(account.c_str(), account.length());
  443.  
  444.     char buf[64];
  445.     snprintf(buf, sizeof(buf), "%u:%u", dw1, dw2);
  446.     DWORD dwComplex = GetCRC32(buf, strlen(buf));
  447.  
  448.     if (m_set_requestToAdd.find(dwComplex) == m_set_requestToAdd.end())
  449.     {
  450.         sys_log(0, "MessengerManager::AuthToAdd : request not exist %s -> %s", companion.c_str(), account.c_str());
  451.         return false;
  452.     }
  453.  
  454.     m_set_requestToAdd.erase(dwComplex);
  455.  
  456.     if (!bDeny)
  457.     {
  458.         AddToList(companion, account);
  459.         AddToList(account, companion);
  460.     }
  461.     return true;
  462. }
  463.  
  464. void MessengerManager::__AddToList(MessengerManager::keyA account, MessengerManager::keyA companion)
  465. {
  466.     m_Relation[account].insert(companion);
  467.     m_InverseRelation[companion].insert(account);
  468.  
  469.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  470.     LPDESC d = ch ? ch->GetDesc() : NULL;
  471.  
  472.     if (d)
  473.     {
  474.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<¸Þ½ÅÁ®> %s ´ÔÀ» Ä£±¸·Î Ãß°¡ÇÏ¿´½À´Ï´Ù."), companion.c_str());
  475.     }
  476.  
  477.     LPCHARACTER tch = CHARACTER_MANAGER::instance().FindPC(companion.c_str());
  478.  
  479.     if (tch)
  480.         SendLogin(account, companion);
  481.     else
  482.         SendLogout(account, companion);
  483. }
  484.  
  485. void MessengerManager::AddToList(MessengerManager::keyA account, MessengerManager::keyA companion)
  486. {
  487.     if (companion.size() == 0)
  488.         return;
  489.  
  490.     if (m_Relation[account].find(companion) != m_Relation[account].end())
  491.         return;
  492.  
  493.     sys_log(0, "Messenger Add %s %s", account.c_str(), companion.c_str());
  494.     DBManager::instance().Query("INSERT INTO messenger_list%s VALUES ('%s', '%s')",
  495.             get_table_postfix(), account.c_str(), companion.c_str());
  496.  
  497.     __AddToList(account, companion);
  498.  
  499.     TPacketGGMessenger p2ppck;
  500.  
  501.     p2ppck.bHeader = HEADER_GG_MESSENGER_ADD;
  502.     strlcpy(p2ppck.szAccount, account.c_str(), sizeof(p2ppck.szAccount));
  503.     strlcpy(p2ppck.szCompanion, companion.c_str(), sizeof(p2ppck.szCompanion));
  504.     P2P_MANAGER::instance().Send(&p2ppck, sizeof(TPacketGGMessenger));
  505. }
  506.  
  507. void MessengerManager::__RemoveFromList(MessengerManager::keyA account, MessengerManager::keyA companion)
  508. {
  509.     m_Relation[account].erase(companion);
  510.     m_InverseRelation[companion].erase(account);
  511.  
  512.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  513.     LPDESC d = ch ? ch->GetDesc() : NULL;
  514.  
  515.     if (d)
  516.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<¸Þ½ÅÁ®> %s ´ÔÀ» ¸Þ½ÅÀú¿¡¼­ »èÁ¦ÇÏ¿´½À´Ï´Ù."), companion.c_str());
  517. }
  518.  
  519. void MessengerManager::RemoveFromList(MessengerManager::keyA account, MessengerManager::keyA companion)
  520. {
  521.     if (companion.size() == 0)
  522.         return;
  523.  
  524.     sys_log(1, "Messenger Remove %s %s", account.c_str(), companion.c_str());
  525.     DBManager::instance().Query("DELETE FROM messenger_list%s WHERE account='%s' AND companion = '%s'",
  526.             get_table_postfix(), account.c_str(), companion.c_str());
  527.  
  528.     __RemoveFromList(account, companion);
  529.  
  530.     TPacketGGMessenger p2ppck;
  531.  
  532.     p2ppck.bHeader = HEADER_GG_MESSENGER_REMOVE;
  533.     strlcpy(p2ppck.szAccount, account.c_str(), sizeof(p2ppck.szAccount));
  534.     strlcpy(p2ppck.szCompanion, companion.c_str(), sizeof(p2ppck.szCompanion));
  535.     P2P_MANAGER::instance().Send(&p2ppck, sizeof(TPacketGGMessenger));
  536. }
  537.  
  538. void MessengerManager::RemoveAllList(keyA account)
  539. {
  540.     std::set<keyT>  company(m_Relation[account]);
  541.  
  542.     /* SQL Data »èÁ¦ */
  543.     DBManager::instance().Query("DELETE FROM messenger_list%s WHERE account='%s' OR companion='%s'",
  544.             get_table_postfix(), account.c_str(), account.c_str());
  545.  
  546.     /* ³»°¡ °¡Áö°íÀÖ´Â ¸®½ºÆ® »èÁ¦ */
  547.     for (std::set<keyT>::iterator iter = company.begin();
  548.             iter != company.end();
  549.             iter++ )
  550.     {
  551.         this->RemoveFromList(account, *iter);
  552.     }
  553.  
  554.     /* º¹»çÇÑ µ¥ÀÌŸ »èÁ¦ */
  555.     for (std::set<keyT>::iterator iter = company.begin();
  556.             iter != company.end();
  557.             )
  558.     {
  559.         company.erase(iter++);
  560.     }
  561.  
  562.     company.clear();
  563. }
  564.  
  565.  
  566. void MessengerManager::SendList(MessengerManager::keyA account)
  567. {
  568.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  569.  
  570.     if (!ch)
  571.         return;
  572.  
  573.     LPDESC d = ch->GetDesc();
  574.  
  575.     if (!d)
  576.         return;
  577.  
  578.     if (m_Relation.find(account) == m_Relation.end())
  579.         return;
  580.  
  581.     if (m_Relation[account].empty())
  582.         return;
  583.  
  584.     TPacketGCMessenger pack;
  585.  
  586.     pack.header     = HEADER_GC_MESSENGER;
  587.     pack.subheader  = MESSENGER_SUBHEADER_GC_LIST;
  588.     pack.size       = sizeof(TPacketGCMessenger);
  589.  
  590.     TPacketGCMessengerListOffline pack_offline;
  591.     TPacketGCMessengerListOnline pack_online;
  592.  
  593.     TEMP_BUFFER buf(128 * 1024); // 128k
  594.  
  595.     itertype(m_Relation[account]) it = m_Relation[account].begin(), eit = m_Relation[account].end();
  596.  
  597.     while (it != eit)
  598.     {
  599.         if (m_set_loginAccount.find(*it) != m_set_loginAccount.end())
  600.         {
  601.             pack_online.connected = 1;
  602.  
  603.             // Online
  604.             pack_online.length = it->size();
  605.  
  606.             buf.write(&pack_online, sizeof(TPacketGCMessengerListOnline));
  607.             buf.write(it->c_str(), it->size());
  608.         }
  609.         else
  610.         {
  611.             pack_offline.connected = 0;
  612.  
  613.             // Offline
  614.             pack_offline.length = it->size();
  615.  
  616.             buf.write(&pack_offline, sizeof(TPacketGCMessengerListOffline));
  617.             buf.write(it->c_str(), it->size());
  618.         }
  619.  
  620.         ++it;
  621.     }
  622.  
  623.     pack.size += buf.size();
  624.  
  625.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  626.     d->Packet(buf.read_peek(), buf.size());
  627. }
  628.  
  629. void MessengerManager::SendLogin(MessengerManager::keyA account, MessengerManager::keyA companion)
  630. {
  631.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  632.     LPDESC d = ch ? ch->GetDesc() : NULL;
  633.  
  634.     if (!d)
  635.         return;
  636.  
  637.     if (!d->GetCharacter())
  638.         return;
  639.  
  640.     if (ch->GetGMLevel() == GM_PLAYER && gm_get_level(companion.c_str()) != GM_PLAYER)
  641.         return;
  642.  
  643.     BYTE bLen = companion.size();
  644.  
  645.     TPacketGCMessenger pack;
  646.  
  647.     pack.header         = HEADER_GC_MESSENGER;
  648.     pack.subheader      = MESSENGER_SUBHEADER_GC_LOGIN;
  649.     pack.size           = sizeof(TPacketGCMessenger) + sizeof(BYTE) + bLen;
  650.  
  651.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  652.     d->BufferedPacket(&bLen, sizeof(BYTE));
  653.     d->Packet(companion.c_str(), companion.size());
  654. }
  655.  
  656. void MessengerManager::SendLogout(MessengerManager::keyA account, MessengerManager::keyA companion)
  657. {
  658.     if (!companion.size())
  659.         return;
  660.  
  661.     LPCHARACTER ch = CHARACTER_MANAGER::instance().FindPC(account.c_str());
  662.     LPDESC d = ch ? ch->GetDesc() : NULL;
  663.  
  664.     if (!d)
  665.         return;
  666.  
  667.     BYTE bLen = companion.size();
  668.  
  669.     TPacketGCMessenger pack;
  670.  
  671.     pack.header     = HEADER_GC_MESSENGER;
  672.     pack.subheader  = MESSENGER_SUBHEADER_GC_LOGOUT;
  673.     pack.size       = sizeof(TPacketGCMessenger) + sizeof(BYTE) + bLen;
  674.  
  675.     d->BufferedPacket(&pack, sizeof(TPacketGCMessenger));
  676.     d->BufferedPacket(&bLen, sizeof(BYTE));
  677.     d->Packet(companion.c_str(), companion.size());
  678. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!