haydukk11/server
1
0
Fork 0
forked from metin2/server
Code Pull Requests Activity

Merge branch 'nightly' into comment-encoding

Browse Source
This commit is contained in:
Tr0n
2024-04-06 01:09:03 +02:00
parent 8a1acefeeb 847ab2ef89
commit 341bef9aba
59 changed files with 46 additions and 2641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
src/db/src/BlockCountry.cpp
View File

@ -1,214 +0,0 @@
// vim:ts=4 sw=4
/*********************************************************************
* date : 2007.05.31
* file : BlockCountry.cpp
* author : mhh
* description :
*/
#include "stdafx.h"
#include "BlockCountry.h"
#include "DBManager.h"
#define DO_ALL_BLOCK_IP(iter) \
for ((iter) = m_block_ip.begin(); (iter) != m_block_ip.end(); ++(iter))
#define DO_ALL_BLOCK_EXCEPTION(iter) \
for ((iter) = m_block_exception.begin(); (iter) != m_block_exception.end(); ++(iter))
CBlockCountry::CBlockCountry()
{
}
CBlockCountry::~CBlockCountry()
{
BLOCK_IP *block_ip;
BLOCK_IP_VECTOR::iterator iter;
DO_ALL_BLOCK_IP(iter)
{
block_ip = *iter;
delete block_ip;
}
m_block_ip.clear();
}
bool CBlockCountry::Load()
{
// load blocked ip
{
char szQuery[256];
snprintf(szQuery, sizeof(szQuery), "SELECT IP_FROM, IP_TO, COUNTRY_NAME FROM iptocountry");
SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_ACCOUNT);
if (pMsg->Get()->uiNumRows == 0)
{
SPDLOG_ERROR(" DirectQuery failed({})", szQuery);
delete pMsg;
return false;
}
MYSQL_ROW row;
for (int n = 0; (row = mysql_fetch_row(pMsg->Get()->pSQLResult)) != NULL; ++n)
{
BLOCK_IP *block_ip = new BLOCK_IP;
block_ip->ip_from = strtoul(row[0], NULL, 10);
block_ip->ip_to = strtoul(row[1], NULL, 10);
strlcpy(block_ip->country, row[2], sizeof(block_ip->country));
m_block_ip.push_back(block_ip);
SPDLOG_DEBUG("BLOCKED_IP : {} - {}", block_ip->ip_from, block_ip->ip_to);
}
delete pMsg;
}
// load block exception account
{
char szQuery[256];
snprintf(szQuery, sizeof(szQuery), "SELECT login FROM block_exception");
SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_ACCOUNT);
if (pMsg->Get()->uiNumRows == 0)
{
SPDLOG_ERROR(" DirectQuery failed({})", szQuery);
delete pMsg;
return true;
}
MYSQL_ROW row;
for (int n = 0; (row = mysql_fetch_row(pMsg->Get()->pSQLResult)) != NULL; ++n)
{
const char *login = row[0];
m_block_exception.push_back(strdup(login));
SPDLOG_DEBUG("BLOCK_EXCEPTION = {}", login);
}
delete pMsg;
}
return true;
}
bool CBlockCountry::IsBlockedCountryIp(const char *user_ip)
{
BLOCK_IP* block_ip;
BLOCK_IP_VECTOR::iterator iter;
struct in_addr st_addr;
#ifndef __WIN32__
if (0 == inet_aton(user_ip, &st_addr))
#else
unsigned int in_address;
in_address = inet_addr(user_ip);
st_addr.s_addr = in_address;
if (INADDR_NONE == in_address)
#endif
return true; // 아이피가 괴상하니 일단 블럭처리
DO_ALL_BLOCK_IP(iter)
{
block_ip = *iter;
if (st_addr.s_addr >= block_ip->ip_from && st_addr.s_addr <= block_ip->ip_to)
return true;
}
return false;
}
void CBlockCountry::SendBlockedCountryIp(CPeer *peer)
{
SPDLOG_DEBUG("SendBlockedCountryIp start");
BLOCK_IP *block_ip;
BLOCK_IP_VECTOR::iterator iter;
TPacketBlockCountryIp packet;
DO_ALL_BLOCK_IP(iter)
{
block_ip = *iter;
packet.ip_from = block_ip->ip_from;
packet.ip_to = block_ip->ip_to;
peer->EncodeHeader(HEADER_DG_BLOCK_COUNTRY_IP, 0, sizeof(TPacketBlockCountryIp));
peer->Encode(&packet, sizeof(packet));
}
SPDLOG_DEBUG("[DONE] CBlockCountry::SendBlockedCountryIp() : count = {}",
m_block_ip.size());
SPDLOG_DEBUG("SendBlockedCountryIp end");
} /* end of CBlockCountry::SendBlockedCountryIp() */
void CBlockCountry::SendBlockException(CPeer *peer)
{
BLOCK_EXCEPTION_VECTOR::iterator iter;
DO_ALL_BLOCK_EXCEPTION(iter)
{
const char *login = *iter;
this->SendBlockExceptionOne(peer, login, BLOCK_EXCEPTION_CMD_ADD);
}
} /* end of CBlockCountry::SendBlockException() */
void CBlockCountry::SendBlockExceptionOne(CPeer *peer, const char *login, BYTE cmd)
{
if (NULL == peer || NULL == login)
return;
if (BLOCK_EXCEPTION_CMD_ADD != cmd && BLOCK_EXCEPTION_CMD_DEL != cmd)
return;
TPacketBlockException packet;
packet.cmd = cmd;
strlcpy(packet.login, login, sizeof(packet.login));
peer->EncodeHeader(HEADER_DG_BLOCK_EXCEPTION, 0, sizeof(TPacketBlockException));
peer->Encode(&packet, sizeof(packet));
}
void CBlockCountry::AddBlockException(const char *login)
{
BLOCK_EXCEPTION_VECTOR::iterator iter;
DO_ALL_BLOCK_EXCEPTION(iter)
{
const char *saved_login = *iter;
if (!strcmp(saved_login, login))
return;
}
m_block_exception.push_back(strdup(login));
return;
}
void CBlockCountry::DelBlockException(const char *login)
{
BLOCK_EXCEPTION_VECTOR::iterator iter;
DO_ALL_BLOCK_EXCEPTION(iter)
{
const char *saved_login = *iter;
if (!strcmp(saved_login, login))
{
::free((void*)saved_login);
m_block_exception.erase(iter);
return;
}
}
return;
}

44
src/db/src/BlockCountry.h
View File

@ -1,44 +0,0 @@
// vim: ts=4 sw=4
// Date : 2007.05.31
// File : BlockCountry.h
// Author : mhh
// Description :
#ifndef __INC_METIN_II_BLOCKCOUNTRY_H__
#define __INC_METIN_II_BLOCKCOUNTRY_H__
#include "Peer.h"
#define MAX_COUNTRY_NAME_LENGTH 50
class CBlockCountry : public singleton<CBlockCountry>
{
private:
struct BLOCK_IP
{
DWORD ip_from;
DWORD ip_to;
char country[MAX_COUNTRY_NAME_LENGTH + 1];
};
typedef std::vector<BLOCK_IP*> BLOCK_IP_VECTOR;
BLOCK_IP_VECTOR m_block_ip;
typedef std::vector<const char*> BLOCK_EXCEPTION_VECTOR;
BLOCK_EXCEPTION_VECTOR m_block_exception;
public:
CBlockCountry();
~CBlockCountry();
public:
bool Load();
bool IsBlockedCountryIp(const char *user_ip);
void SendBlockedCountryIp(CPeer *peer);
void SendBlockException(CPeer *peer);
void SendBlockExceptionOne(CPeer *peer, const char *login, BYTE cmd);
void AddBlockException(const char *login);
void DelBlockException(const char *login);
};
#endif

289
src/db/src/ClientManager.cpp
View File

@ -1,6 +1,5 @@
#include "stdafx.h"
#include <common/billing.h>
#include <common/building.h>
#include <common/VnumHelper.h>
#include "../../libgame/include/grid.h"
@ -17,7 +16,6 @@
#include "ItemAwardManager.h"
#include "Marriage.h"
#include "Monarch.h"
#include "BlockCountry.h"
#include "ItemIDRangeManager.h"
#include "Cache.h"
#ifdef __AUCTION__
@ -1144,7 +1142,6 @@ void CClientManager::QUERY_SETUP(CPeer * peer, DWORD dwHandle, const char * c_pD
SPDLOG_DEBUG("AUTH_PEER ptr {}", (void*) peer);
m_pkAuthPeer = peer;
SendAllLoginToBilling();
return;
}
@ -1287,10 +1284,9 @@ void CClientManager::QUERY_SETUP(CPeer * peer, DWORD dwHandle, const char * c_pD
}
//
// 로그인 및 빌링정보 보내기
// Log in the player
//
TPacketLoginOnSetup * pck = (TPacketLoginOnSetup *) c_pData;;
std::vector<TPacketBillingRepair> vec_repair;
TPacketLoginOnSetup * pck = (TPacketLoginOnSetup *) c_pData;
for (DWORD c = 0; c < p->dwLoginCount; ++c, ++pck)
{
@ -1313,29 +1309,11 @@ void CClientManager::QUERY_SETUP(CPeer * peer, DWORD dwHandle, const char * c_pD
{
SPDLOG_DEBUG("SETUP: login {} {} login_key {} host {}", pck->dwID, pck->szLogin, pck->dwLoginKey, pck->szHost);
pkLD->SetPlay(true);
if (m_pkAuthPeer)
{
TPacketBillingRepair pck_repair;
pck_repair.dwLoginKey = pkLD->GetKey();
strlcpy(pck_repair.szLogin, pck->szLogin, sizeof(pck_repair.szLogin));
strlcpy(pck_repair.szHost, pck->szHost, sizeof(pck_repair.szHost));
vec_repair.push_back(pck_repair);
}
}
else
SPDLOG_DEBUG("SETUP: login_fail {} {} login_key {}", pck->dwID, pck->szLogin, pck->dwLoginKey);
}
if (m_pkAuthPeer && !vec_repair.empty())
{
SPDLOG_DEBUG("REPAIR size {}", vec_repair.size());
m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_REPAIR, 0, sizeof(DWORD) + sizeof(TPacketBillingRepair) * vec_repair.size());
m_pkAuthPeer->EncodeDWORD(vec_repair.size());
m_pkAuthPeer->Encode(&vec_repair[0], sizeof(TPacketBillingRepair) * vec_repair.size());
}
SendPartyOnSetup(peer);
CGuildManager::instance().OnSetup(peer);
CPrivManager::instance().SendPrivOnSetup(peer);
@ -1687,22 +1665,6 @@ void CClientManager::QUERY_FLUSH_CACHE(CPeer * pkPeer, const char * c_pData)
delete pkCache;
}
void CClientManager::QUERY_SMS(CPeer * pkPeer, TPacketGDSMS * pack)
{
char szQuery[QUERY_MAX_LEN];
char szMsg[256+1];
//unsigned int len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg), SQL_ACCOUNT);
unsigned int len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg));
szMsg[len] = '\0';
snprintf(szQuery, sizeof(szQuery),
"INSERT INTO sms_pool (server, sender, receiver, mobile, msg) VALUES(%d, '%s', '%s', '%s', '%s')",
(m_iPlayerIDStart + 2) / 3, pack->szFrom, pack->szTo, pack->szMobile, szMsg);
CDBManager::instance().AsyncQuery(szQuery);
}
void CClientManager::QUERY_RELOAD_PROTO()
{
if (!InitializeTables())
@ -1844,8 +1806,6 @@ void CClientManager::QUERY_AUTH_LOGIN(CPeer * pkPeer, DWORD dwHandle, TPacketGDA
pkLD->SetKey(p->dwLoginKey);
pkLD->SetClientKey(p->adwClientKey);
pkLD->SetBillType(p->bBillType);
pkLD->SetBillID(p->dwBillID);
pkLD->SetPremium(p->iPremiumTimes);
TAccountTable & r = pkLD->GetAccountRef();
@ -1868,109 +1828,6 @@ void CClientManager::QUERY_AUTH_LOGIN(CPeer * pkPeer, DWORD dwHandle, TPacketGDA
}
}
void CClientManager::BillingExpire(TPacketBillingExpire * p)
{
char key[LOGIN_MAX_LEN + 1];
trim_and_lower(p->szLogin, key, sizeof(key));
switch (p->bBillType)
{
case BILLING_IP_TIME:
case BILLING_IP_DAY:
{
DWORD dwIPID = 0;
str_to_number(dwIPID, p->szLogin);
TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
while (it != m_map_kLogonAccount.end())
{
CLoginData * pkLD = (it++)->second;
if (pkLD->GetBillID() == dwIPID)
{
CPeer * pkPeer = GetPeer(pkLD->GetConnectedPeerHandle());
if (pkPeer)
{
strlcpy(p->szLogin, pkLD->GetAccountRef().login, sizeof(p->szLogin));
pkPeer->EncodeHeader(HEADER_DG_BILLING_EXPIRE, 0, sizeof(TPacketBillingExpire));
pkPeer->Encode(p, sizeof(TPacketBillingExpire));
}
}
}
}
break;
case BILLING_TIME:
case BILLING_DAY:
{
TLogonAccountMap::iterator it = m_map_kLogonAccount.find(key);
if (it != m_map_kLogonAccount.end())
{
CLoginData * pkLD = it->second;
CPeer * pkPeer = GetPeer(pkLD->GetConnectedPeerHandle());
if (pkPeer)
{
pkPeer->EncodeHeader(HEADER_DG_BILLING_EXPIRE, 0, sizeof(TPacketBillingExpire));
pkPeer->Encode(p, sizeof(TPacketBillingExpire));
}
}
}
break;
}
}
void CClientManager::BillingCheck(const char * data)
{
if (!m_pkAuthPeer)
return;
time_t curTime = GetCurrentTime();
DWORD dwCount = *(DWORD *) data;
data += sizeof(DWORD);
std::vector<DWORD> vec;
SPDLOG_DEBUG("BillingCheck: size {}", dwCount);
for (DWORD i = 0; i < dwCount; ++i)
{
DWORD dwKey = *(DWORD *) data;
data += sizeof(DWORD);
SPDLOG_DEBUG("BillingCheck: {}", dwKey);
TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(dwKey);
if (it == m_map_pkLoginData.end())
{
SPDLOG_DEBUG("BillingCheck: key not exist: {}", dwKey);
vec.push_back(dwKey);
}
else
{
CLoginData * pkLD = it->second;
if (!pkLD->IsPlay() && curTime - pkLD->GetLastPlayTime() > 180)
{
SPDLOG_DEBUG("BillingCheck: not login: {}", dwKey);
vec.push_back(dwKey);
}
}
}
m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_CHECK, 0, sizeof(DWORD) + sizeof(DWORD) * vec.size());
m_pkAuthPeer->EncodeDWORD(vec.size());
if (!vec.empty())
m_pkAuthPeer->Encode(&vec[0], sizeof(DWORD) * vec.size());
}
void CClientManager::GuildDepositMoney(TPacketGDGuildMoney* p)
{
CGuildManager::instance().DepositMoney(p->dwGuild, p->iGold);
@ -1991,51 +1848,6 @@ void CClientManager::GuildWarBet(TPacketGDGuildWarBet * p)
CGuildManager::instance().Bet(p->dwWarID, p->szLogin, p->dwGold, p->dwGuild);
}
void CClientManager::SendAllLoginToBilling()
{
if (!m_pkAuthPeer)
return;
std::vector<TPacketBillingRepair> vec;
TPacketBillingRepair p;
TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
while (it != m_map_kLogonAccount.end())
{
CLoginData * pkLD = (it++)->second;
p.dwLoginKey = pkLD->GetKey();
strlcpy(p.szLogin, pkLD->GetAccountRef().login, sizeof(p.szLogin));
strlcpy(p.szHost, pkLD->GetIP(), sizeof(p.szHost));
SPDLOG_DEBUG("SendAllLoginToBilling {} {}", pkLD->GetAccountRef().login, pkLD->GetIP());
vec.push_back(p);
}
if (!vec.empty())
{
m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_REPAIR, 0, sizeof(DWORD) + sizeof(TPacketBillingRepair) * vec.size());
m_pkAuthPeer->EncodeDWORD(vec.size());
m_pkAuthPeer->Encode(&vec[0], sizeof(TPacketBillingRepair) * vec.size());
}
}
void CClientManager::SendLoginToBilling(CLoginData * pkLD, bool bLogin)
{
if (!m_pkAuthPeer)
return;
TPacketBillingLogin p;
p.dwLoginKey = pkLD->GetKey();
p.bLogin = bLogin ? 1 : 0;
DWORD dwCount = 1;
m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_LOGIN, 0, sizeof(DWORD) + sizeof(TPacketBillingLogin));
m_pkAuthPeer->EncodeDWORD(dwCount);
m_pkAuthPeer->Encode(&p, sizeof(TPacketBillingLogin));
}
void CClientManager::CreateObject(TPacketGDCreateObject * p)
{
using namespace building;
@ -2125,28 +1937,6 @@ void CClientManager::UpdateLand(DWORD * pdw)
ForwardPacket(HEADER_DG_UPDATE_LAND, p, sizeof(building::TLand));
}
void CClientManager::VCard(TPacketGDVCard * p)
{
SPDLOG_DEBUG("VCARD: {} {} {} {} {}",
p->dwID, p->szSellCharacter, p->szSellAccount, p->szBuyCharacter, p->szBuyAccount);
m_queue_vcard.push(*p);
}
void CClientManager::VCardProcess()
{
if (!m_pkAuthPeer)
return;
while (!m_queue_vcard.empty())
{
m_pkAuthPeer->EncodeHeader(HEADER_DG_VCARD, 0, sizeof(TPacketGDVCard));
m_pkAuthPeer->Encode(&m_queue_vcard.front(), sizeof(TPacketGDVCard));
m_queue_vcard.pop();
}
}
// BLOCK_CHAT
void CClientManager::BlockChat(TPacketBlockChat* p)
{
@ -2476,10 +2266,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
QUERY_REMOVE_AFFECT(peer, (TPacketGDRemoveAffect *) data);
break;
case HEADER_GD_HIGHSCORE_REGISTER:
QUERY_HIGHSCORE_REGISTER(peer, (TPacketGDHighscore *) data);
break;
case HEADER_GD_PARTY_CREATE:
QUERY_PARTY_CREATE(peer, (TPacketPartyCreate*) data);
break;
@ -2512,10 +2298,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
QUERY_CHANGE_NAME(peer, dwHandle, (TPacketGDChangeName *) data);
break;
case HEADER_GD_SMS:
QUERY_SMS(peer, (TPacketGDSMS *) data);
break;
case HEADER_GD_AUTH_LOGIN:
QUERY_AUTH_LOGIN(peer, dwHandle, (TPacketGDAuthLogin *) data);
break;
@ -2556,14 +2338,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
SetEventFlag((TPacketSetEventFlag*) data);
break;
case HEADER_GD_BILLING_EXPIRE:
BillingExpire((TPacketBillingExpire *) data);
break;
case HEADER_GD_BILLING_CHECK:
BillingCheck(data);
break;
case HEADER_GD_CREATE_OBJECT:
CreateObject((TPacketGDCreateObject *) data);
break;
@ -2576,10 +2350,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
UpdateLand((DWORD *) data);
break;
case HEADER_GD_VCARD:
VCard((TPacketGDVCard *) data);
break;
case HEADER_GD_MARRIAGE_ADD:
MarriageAdd((TPacketMarriageAdd *) data);
break;
@ -2672,17 +2442,6 @@ void CClientManager::ProcessPackets(CPeer * peer)
ChangeMonarchLord(peer, dwHandle, (TPacketChangeMonarchLord*)data);
break;
case HEADER_GD_BLOCK_COUNTRY_IP:
SPDLOG_DEBUG("HEADER_GD_BLOCK_COUNTRY_IP received");
CBlockCountry::instance().SendBlockedCountryIp(peer);
CBlockCountry::instance().SendBlockException(peer);
break;
case HEADER_GD_BLOCK_EXCEPTION:
SPDLOG_DEBUG("HEADER_GD_BLOCK_EXCEPTION received");
BlockException((TPacketBlockException*) data);
break;
case HEADER_GD_REQ_SPARE_ITEM_ID_RANGE :
SendSpareItemIDRange(peer);
break;
@ -2818,7 +2577,6 @@ void CClientManager::RemovePeer(CPeer * pPeer)
if (pkLD->IsPlay())
{
pkLD->SetPlay(false);
SendLoginToBilling(pkLD, false);
}
if (pkLD->IsDeleted())
@ -2934,11 +2692,6 @@ int CClientManager::AnalyzeQueryResult(SQLMsg * msg)
RESULT_SAFEBOX_CHANGE_PASSWORD_SECOND(peer, msg);
break;
case QID_HIGHSCORE_REGISTER:
SPDLOG_DEBUG("QUERY_RESULT: HEADER_GD_HIGHSCORE_REGISTER {}", (void*) msg);
RESULT_HIGHSCORE_REGISTER(peer, msg);
break;
case QID_SAFEBOX_SAVE:
case QID_ITEM_SAVE:
case QID_ITEM_DESTROY:
@ -3184,7 +2937,6 @@ int CClientManager::Process()
// Process network events
event_base_loop(m_base, EVLOOP_NONBLOCK);
VCardProcess();
return 1;
}
@ -4190,43 +3942,6 @@ void CClientManager::ChangeMonarchLord(CPeer * peer, DWORD dwHandle, TPacketChan
delete pMsg;
}
void CClientManager::BlockException(TPacketBlockException *data)
{
SPDLOG_DEBUG("[BLOCK_EXCEPTION] CMD({}) login({})", data->cmd, data->login);
// save sql
{
char buf[1024];
switch (data->cmd)
{
case BLOCK_EXCEPTION_CMD_ADD:
snprintf(buf, sizeof(buf), "INSERT INTO block_exception VALUES('%s')", data->login);
CDBManager::instance().AsyncQuery(buf, SQL_ACCOUNT);
CBlockCountry::instance().AddBlockException(data->login);
break;
case BLOCK_EXCEPTION_CMD_DEL:
snprintf(buf, sizeof(buf), "DELETE FROM block_exception VALUES('%s')", data->login);
CDBManager::instance().AsyncQuery(buf, SQL_ACCOUNT);
CBlockCountry::instance().DelBlockException(data->login);
break;
default:
return;
}
}
for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
{
CPeer *peer = *it;
if (!peer->GetChannel())
continue;
CBlockCountry::instance().SendBlockExceptionOne(peer, data->login, data->cmd);
}
}
void CClientManager::SendSpareItemIDRange(CPeer* peer)
{
peer->SendSpareItemIDRange();

17
src/db/src/ClientManager.h
View File

@ -310,9 +310,6 @@ class CClientManager : public singleton<CClientManager>
void SendPartyOnSetup(CPeer * peer);
void QUERY_HIGHSCORE_REGISTER(CPeer * peer, TPacketGDHighscore* data);
void RESULT_HIGHSCORE_REGISTER(CPeer * pkPeer, SQLMsg * msg);
void QUERY_FLUSH_CACHE(CPeer * pkPeer, const char * c_pData);
void QUERY_PARTY_CREATE(CPeer * peer, TPacketPartyCreate* p);
@ -327,7 +324,6 @@ class CClientManager : public singleton<CClientManager>
void QUERY_CHANGE_NAME(CPeer * peer, DWORD dwHandle, TPacketGDChangeName * p);
void GetPlayerFromRes(TPlayerTable * player_table, MYSQL_RES* res);
void QUERY_SMS(CPeer * pkPeer, TPacketGDSMS * p);
void QUERY_LOGIN_KEY(CPeer * pkPeer, TPacketGDLoginKey * p);
void AddGuildPriv(TPacketGiveGuildPriv* p);
@ -347,12 +343,6 @@ class CClientManager : public singleton<CClientManager>
void SetEventFlag(TPacketSetEventFlag* p);
void SendEventFlagsOnSetup(CPeer* peer);
void BillingExpire(TPacketBillingExpire * p);
void BillingCheck(const char * data);
void SendAllLoginToBilling();
void SendLoginToBilling(CLoginData * pkLD, bool bLogin);
// 결혼
void MarriageAdd(TPacketMarriageAdd * p);
void MarriageUpdate(TPacketMarriageUpdate * p);
@ -385,10 +375,6 @@ class CClientManager : public singleton<CClientManager>
void DeleteObject(DWORD dwID);
void UpdateLand(DWORD * pdw);
// VCard
void VCard(TPacketGDVCard * p);
void VCardProcess();
// BLOCK_CHAT
void BlockChat(TPacketBlockChat * p);
// END_OF_BLOCK_CHAT
@ -441,8 +427,6 @@ class CClientManager : public singleton<CClientManager>
std::vector<building::TObjectProto> m_vec_kObjectProto;
std::map<DWORD, building::TObject *> m_map_pkObjectTable;
std::queue<TPacketGDVCard> m_queue_vcard;
bool m_bShutdowned;
TPlayerTableCacheMap m_map_playerCache; // 플레이어 id가 key
@ -545,7 +529,6 @@ class CClientManager : public singleton<CClientManager>
//END_MONARCH
void ChangeMonarchLord(CPeer* peer, DWORD dwHandle, TPacketChangeMonarchLord* info);
void BlockException(TPacketBlockException *data);
void SendSpareItemIDRange(CPeer* peer);

1
src/db/src/ClientManagerLogin.cpp
View File

@ -55,7 +55,6 @@ bool CClientManager::DeleteLogonAccount(const char * c_pszLogin, DWORD dwHandle)
if (pkLD->IsPlay())
{
pkLD->SetPlay(false);
SendLoginToBilling(pkLD, false);
}
if (pkLD->IsDeleted())

89
src/db/src/ClientManagerPlayer.cpp
View File

@ -6,11 +6,8 @@
#include "Main.h"
#include "QID.h"
#include "ItemAwardManager.h"
#include "HB.h"
#include "Cache.h"
extern bool g_bHotBackup;
extern std::string g_stLocale;
extern int g_test_server;
@ -195,9 +192,6 @@ void CClientManager::PutPlayerCache(TPlayerTable * pNew)
m_map_playerCache.insert(TPlayerTableCacheMap::value_type(pNew->id, c));
}
if (g_bHotBackup)
PlayerHB::instance().Put(pNew->id);
c->Put(pNew);
}
@ -243,7 +237,6 @@ void CClientManager::QUERY_PLAYER_LOAD(CPeer * peer, DWORD dwHandle, TPlayerLoad
pTab = c->Get();
pkLD->SetPlay(true);
SendLoginToBilling(pkLD, true);
memcpy(pTab->aiPremiumTimes, pkLD->GetPremiumPtr(), sizeof(pTab->aiPremiumTimes));
peer->EncodeHeader(HEADER_DG_PLAYER_LOAD_SUCCESS, dwHandle, sizeof(TPlayerTable));
@ -364,7 +357,7 @@ void CClientManager::QUERY_PLAYER_LOAD(CPeer * peer, DWORD dwHandle, TPlayerLoad
"id,name,job,voice,dir,x,y,z,map_index,exit_x,exit_y,exit_map_index,hp,mp,stamina,random_hp,random_sp,playtime,"
"gold,level,level_step,st,ht,dx,iq,exp,"
"stat_point,skill_point,sub_skill_point,stat_reset_count,part_base,part_hair,"
"skill_level,quickslot,skill_group,alignment,mobile,horse_level,horse_riding,horse_hp,horse_hp_droptime,horse_stamina,"
"skill_level,quickslot,skill_group,alignment,horse_level,horse_riding,horse_hp,horse_hp_droptime,horse_stamina,"
"UNIX_TIMESTAMP(NOW())-UNIX_TIMESTAMP(last_play),horse_skill_point FROM player%s WHERE id=%d",
GetTablePostfix(), packet->player_id);
@ -454,7 +447,7 @@ bool CreatePlayerTableFromRes(MYSQL_RES * res, TPlayerTable * pkTab)
// "id,name,job,voice,dir,x,y,z,map_index,exit_x,exit_y,exit_map_index,hp,mp,stamina,random_hp,random_sp,playtime,"
// "gold,level,level_step,st,ht,dx,iq,exp,"
// "stat_point,skill_point,sub_skill_point,stat_reset_count,part_base,part_hair,"
// "skill_level,quickslot,skill_group,alignment,mobile,horse_level,horse_riding,horse_hp,horse_stamina FROM player%s WHERE id=%d",
// "skill_level,quickslot,skill_group,alignment,horse_level,horse_riding,horse_hp,horse_stamina FROM player%s WHERE id=%d",
str_to_number(pkTab->id, row[col++]);
strlcpy(pkTab->name, row[col++], sizeof(pkTab->name));
str_to_number(pkTab->job, row[col++]);
@ -505,13 +498,6 @@ bool CreatePlayerTableFromRes(MYSQL_RES * res, TPlayerTable * pkTab)
str_to_number(pkTab->skill_group, row[col++]);
str_to_number(pkTab->lAlignment, row[col++]);
if (row[col])
{
strlcpy(pkTab->szMobile, row[col], sizeof(pkTab->szMobile));
}
col++;
str_to_number(pkTab->horse.bLevel, row[col++]);
str_to_number(pkTab->horse.bRiding, row[col++]);
str_to_number(pkTab->horse.sHealth, row[col++]);
@ -649,7 +635,6 @@ void CClientManager::RESULT_PLAYER_LOAD(CPeer * peer, MYSQL_RES * pRes, ClientHa
}
pkLD->SetPlay(true);
SendLoginToBilling(pkLD, true);
memcpy(tab.aiPremiumTimes, pkLD->GetPremiumPtr(), sizeof(tab.aiPremiumTimes));
peer->EncodeHeader(HEADER_DG_PLAYER_LOAD_SUCCESS, pkInfo->dwHandle, sizeof(TPlayerTable));
@ -1206,76 +1191,6 @@ void CClientManager::QUERY_REMOVE_AFFECT(CPeer * peer, TPacketGDRemoveAffect * p
CDBManager::instance().AsyncQuery(queryStr);
}
void CClientManager::QUERY_HIGHSCORE_REGISTER(CPeer* peer, TPacketGDHighscore * data)
{
char szQuery[128];
snprintf(szQuery, sizeof(szQuery), "SELECT value FROM highscore%s WHERE board='%s' AND pid = %u", GetTablePostfix(), data->szBoard, data->dwPID);
SPDLOG_DEBUG("HEADER_GD_HIGHSCORE_REGISTER: PID {}", data->dwPID);
ClientHandleInfo * pi = new ClientHandleInfo(0);
strlcpy(pi->login, data->szBoard, sizeof(pi->login));
pi->account_id = (DWORD)data->lValue;
pi->player_id = data->dwPID;
pi->account_index = (data->cDir > 0);
CDBManager::instance().ReturnQuery(szQuery, QID_HIGHSCORE_REGISTER, peer->GetHandle(), pi);
}
void CClientManager::RESULT_HIGHSCORE_REGISTER(CPeer * pkPeer, SQLMsg * msg)
{
CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
ClientHandleInfo * pi = (ClientHandleInfo *) qi->pvData;
//DWORD dwHandle = pi->dwHandle;
char szBoard[21];
strlcpy(szBoard, pi->login, sizeof(szBoard));
int value = (int)pi->account_id;
SQLResult * res = msg->Get();
if (res->uiNumRows == 0)
{
// 새로운 하이스코어를 삽입
char buf[256];
snprintf(buf, sizeof(buf), "INSERT INTO highscore%s VALUES('%s', %u, %d)", GetTablePostfix(), szBoard, pi->player_id, value);
CDBManager::instance().AsyncQuery(buf);
}
else
{
if (!res->pSQLResult)
{
delete pi;
return;
}
MYSQL_ROW row = mysql_fetch_row(res->pSQLResult);
if (row && row[0])
{
int current_value = 0; str_to_number(current_value, row[0]);
if (pi->account_index && current_value >= value || !pi->account_index && current_value <= value)
{
value = current_value;
}
else
{
char buf[256];
snprintf(buf, sizeof(buf), "REPLACE INTO highscore%s VALUES('%s', %u, %d)", GetTablePostfix(), szBoard, pi->player_id, value);
CDBManager::instance().AsyncQuery(buf);
}
}
else
{
char buf[256];
snprintf(buf, sizeof(buf), "INSERT INTO highscore%s VALUES('%s', %u, %d)", GetTablePostfix(), szBoard, pi->player_id, value);
CDBManager::instance().AsyncQuery(buf);
}
}
// TODO: 이곳에서 하이스코어가 업데이트 되었는지 체크하여 공지를 뿌려야한다.
delete pi;
}
void CClientManager::InsertLogoutPlayer(DWORD pid)
{
TLogoutPlayerMap::iterator it = m_map_logout.find(pid);

1
src/db/src/DBManager.h
View File

@ -23,7 +23,6 @@ enum eSQL_SLOT
SQL_PLAYER,
SQL_ACCOUNT,
SQL_COMMON,
SQL_HOTBACKUP,
SQL_MAX_NUM,
};

86
src/db/src/HB.cpp
View File

@ -1,86 +0,0 @@
#include "stdafx.h"
#include "HB.h"
#include "Main.h"
#include "DBManager.h"
#include <memory>
PlayerHB::PlayerHB()
{
m_iExpireTime = 3600; // 1 hour hotbackup default.
}
PlayerHB::~PlayerHB()
{
}
bool PlayerHB::Initialize()
{
char szQuery[128];
snprintf(szQuery, sizeof(szQuery), "SHOW CREATE TABLE player%s", GetTablePostfix());
std::unique_ptr<SQLMsg> pMsg(CDBManager::instance().DirectQuery(szQuery));
if (pMsg->Get()->uiNumRows == 0)
return false;
MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
m_stCreateTableQuery = row[1];
return true;
}
//
// @version 05/07/05 Bang2ni - id 에 해당하는 data 가 없을 때 쿼리하고 data 를 insert 하는코드 추가.
//
void PlayerHB::Put(DWORD id)
{
itertype(m_map_data) it = m_map_data.find(id);
if (it == m_map_data.end())
{
Query(id);
m_map_data.insert(std::pair< DWORD, time_t >(id, get_dword_time()));
return;
}
if (time(0) - it->second > m_iExpireTime)
Query(id);
}
//
// @version 05/07/05 Bang2ni - Query string 버퍼가 작아서 늘려줌.
//
bool PlayerHB::Query(DWORD id)
{
time_t ct = time(0);
struct tm curr_tm = *localtime(&ct);
char szTableName[64];
snprintf(szTableName, sizeof(szTableName), "hb_%02d%02d%02d%02d_player%s",
curr_tm.tm_year - 100, curr_tm.tm_mon + 1, curr_tm.tm_mday, curr_tm.tm_hour, GetTablePostfix());
char szQuery[4096];
if (m_stTableName.compare(szTableName))
{
char szFind[32];
snprintf(szFind, sizeof(szFind), "CREATE TABLE `player%s`", GetTablePostfix());
int pos = m_stCreateTableQuery.find(szFind);
if (pos < 0)
{
SPDLOG_ERROR("cannot find {} ", szFind);
// SPDLOG_ERROR("cannot find {} in {}", szFind, m_stCreateTableQuery.c_str());
return false;
}
snprintf(szQuery, sizeof(szQuery), "CREATE TABLE IF NOT EXISTS %s%s", szTableName, m_stCreateTableQuery.c_str() + strlen(szFind));
// SPDLOG_DEBUG("{}", szQuery);
std::unique_ptr<SQLMsg> pMsg(CDBManager::instance().DirectQuery(szQuery, SQL_HOTBACKUP));
m_stTableName = szTableName;
}
snprintf(szQuery, sizeof(szQuery), "REPLACE INTO %s SELECT * FROM %splayer%s WHERE id=%u", m_stTableName.c_str(), GetPlayerDBName(), GetTablePostfix(), id);
CDBManager::instance().AsyncQuery(szQuery, SQL_HOTBACKUP);
return true;
}

24
src/db/src/HB.h
View File

@ -1,24 +0,0 @@
// vim:ts=8 sw=4
#ifndef __INC_METIN_II_PLAYERHB_H__
#define __INC_METIN_II_PLAYERHB_H__
class PlayerHB : public singleton<PlayerHB>
{
public:
PlayerHB();
virtual ~PlayerHB();
bool Initialize();
void Put(DWORD id);
private:
bool Query(DWORD id);
std::map<DWORD, time_t> m_map_data;
std::string m_stCreateTableQuery;
std::string m_stTableName;
int m_iExpireTime;
};
#endif

2
src/db/src/LoginData.cpp
View File

@ -11,8 +11,6 @@ CLoginData::CLoginData()
memset(m_szIP, 0, sizeof(m_szIP));
m_bPlay = false;
m_bDeleted = false;
m_bBillType = 0;
m_dwBillID = 0;
m_lastPlayTime = 0;
m_dwLastPlayerID = 0;

8
src/db/src/LoginData.h
View File

@ -29,12 +29,6 @@ class CLoginData
void SetDeleted(bool bSet);
bool IsDeleted();
void SetBillID(DWORD id) { m_dwBillID = id; }
DWORD GetBillID() { return m_dwBillID; }
void SetBillType(BYTE type) { m_bBillType = type; }
BYTE GetBillType() { return m_bBillType; }
time_t GetLastPlayTime() { return m_lastPlayTime; }
void SetPremium(DWORD * paiPremiumTimes);
@ -53,8 +47,6 @@ class CLoginData
bool m_bPlay;
bool m_bDeleted;
BYTE m_bBillType;
DWORD m_dwBillID;
time_t m_lastPlayTime;
DWORD m_aiPremiumTimes[PREMIUM_MAX_NUM];

60
src/db/src/Main.cpp
View File

@ -5,12 +5,10 @@
#include "ClientManager.h"
#include "GuildManager.h"
#include "ItemAwardManager.h"
#include "HB.h"
#include "PrivManager.h"
#include "MoneyLog.h"
#include "Marriage.h"
#include "Monarch.h"
#include "BlockCountry.h"
#include "ItemIDRangeManager.h"
#include <version.h>
#ifdef __AUCTION__
@ -28,7 +26,6 @@ std::string g_stLocale = "euckr";
std::string g_stPlayerDBName = "";
bool g_bHotBackup = false;
BOOL g_test_server = false;
//단위 초
@ -70,14 +67,12 @@ int main()
CConfig Config;
CDBManager DBManager;
CClientManager ClientManager;
PlayerHB player_hb;
CGuildManager GuildManager;
CPrivManager PrivManager;
CMoneyLog MoneyLog;
ItemAwardManager ItemAwardManager;
marriage::CManager MarriageManager;
CMonarch Monarch;
CBlockCountry BlockCountry;
CItemIDRangeManager ItemIDRangeManager;
#ifdef __AUCTION__
AuctionManager auctionManager;
@ -87,7 +82,6 @@ int main()
GuildManager.Initialize();
MarriageManager.Initialize();
BlockCountry.Load();
ItemIDRangeManager.Build();
#ifdef __AUCTION__
AuctionManager::instance().Initialize();
@ -170,27 +164,8 @@ int Start()
{
g_stLocale = szBuf;
SPDLOG_INFO("LOCALE set to {}", g_stLocale.c_str());
// CHINA_DISABLE_HOTBACKUP
if ("gb2312" == g_stLocale)
{
SPDLOG_INFO("CIBN_LOCALE: DISABLE_HOTBACKUP");
g_bHotBackup = false;
}
// END_OF_CHINA_DISABLE_HOTBACKUP
}
int iDisableHotBackup;
if (CConfig::instance().GetValue("DISABLE_HOTBACKUP", &iDisableHotBackup))
{
if (iDisableHotBackup)
{
SPDLOG_INFO("CONFIG: DISABLE_HOTBACKUP");
g_bHotBackup = false;
}
}
if (!CConfig::instance().GetValue("TABLE_POSTFIX", szBuf, 256))
{
SPDLOG_WARN("TABLE_POSTFIX not configured use default");
@ -324,35 +299,6 @@ int Start()
return false;
}
if (CConfig::instance().GetValue("SQL_HOTBACKUP", line, 256))
{
sscanf(line, " %s %s %s %s %d ", szAddr, szDB, szUser, szPassword, &iPort);
SPDLOG_DEBUG("connecting to MySQL server (hotbackup)");
int iRetry = 5;
do
{
if (CDBManager::instance().Connect(SQL_HOTBACKUP, szAddr, iPort, szDB, szUser, szPassword))
{
SPDLOG_DEBUG(" OK");
break;
}
SPDLOG_DEBUG(" failed, retrying in 5 seconds");
SPDLOG_ERROR(" failed, retrying in 5 seconds");
sleep(5);
}
while (iRetry--);
SPDLOG_INFO("Success HOTBACKUP");
}
else
{
SPDLOG_ERROR("SQL_HOTBACKUP not configured");
return false;
}
if (!CClientManager::instance().Initialize())
{
SPDLOG_ERROR("ClientManager initialization failed");
@ -361,12 +307,6 @@ int Start()
SPDLOG_INFO("ClientManager initialization OK");
if (!PlayerHB::instance().Initialize())
{
SPDLOG_ERROR("cannot initialize player hotbackup");
return false;
}
#ifndef __WIN32__
signal(SIGUSR1, emergency_sig);
#endif

21
src/db/src/QID.h
View File

@ -20,19 +20,18 @@ enum QID
QID_ITEM_DESTROY, // 11
QID_QUEST_SAVE, // 12
QID_PLAYER_SAVE, // 13
QID_HIGHSCORE_REGISTER, // 14
QID_PLAYER_DELETE, // 15
QID_LOGIN_BY_KEY, // 16
QID_PLAYER_INDEX_CREATE, // 17
QID_ITEM_AWARD_LOAD, // 18
QID_ITEM_AWARD_TAKEN, // 19
QID_GUILD_RANKING, // 20
QID_PLAYER_DELETE, // 14
QID_LOGIN_BY_KEY, // 15
QID_PLAYER_INDEX_CREATE, // 16
QID_ITEM_AWARD_LOAD, // 17
QID_ITEM_AWARD_TAKEN, // 18
QID_GUILD_RANKING, // 19
// MYSHOP_PRICE_LIST
QID_ITEMPRICE_SAVE, ///< 21, 아이템 가격정보 저장 쿼리
QID_ITEMPRICE_DESTROY, ///< 22, 아이템 가격정보 삭제 쿼리
QID_ITEMPRICE_LOAD_FOR_UPDATE, ///< 23, 가격정보 업데이트를 위한 아이템 가격정보 로드 쿼리
QID_ITEMPRICE_LOAD, ///< 24, 아이템 가격정보 로드 쿼리
QID_ITEMPRICE_SAVE, ///< 20, 아이템 가격정보 저장 쿼리
QID_ITEMPRICE_DESTROY, ///< 21, 아이템 가격정보 저장 쿼리
QID_ITEMPRICE_LOAD_FOR_UPDATE, ///< 22, 가격정보 업데이트를 위한 아이템 가격정보 로드 쿼리
QID_ITEMPRICE_LOAD, ///< 22, 아이템 가격정보 로드 쿼리
// END_OF_MYSHOP_PRICE_LIST
};