RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6745638bb324fc933f9c1f4d8fafd959e1d6389
Client/Server/AdminTool/AdminToolServer/RYL_AdminMgrDispatch.cpp
LGram16 dd97ddec92 Restructure repository to include all source folders 
Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2025-11-29 20:17:20 +09:00

6619 lines
199 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "RYL_AdminMgrDispatch.h"
#include "RYL_AgentServerDispatch.h"
#include "RYL_AgentServerTable.h"
#include "RYL_AdminManagerServer.h"
#include <DB/GameDBComponent.h>
#include <DBComponent/RYL_GameDB.h>
#include <DBComponent/BillingDB.h>
#include <DBComponent/RYL_AdminMgrDB.h>
#include <DBComponent/AuthDB.h>
#include <Network/Protocol/RYL_AdminMgrProtocol.h>
#include <Network/Session/Session.h>
#include <Network/Buffer/RYL_CumulateBuffer.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/PacketCommand.h>
#include <Network/Packet/PacketStruct/ServerInfo.h>
#include <Network/Packet/PacketStruct/ServerPacket.h>
#include <Network/Packet/PacketStruct/GuildPacket.h>
#include <Network/Packet/PacketStruct/CastlePacket.h>
#include <Network/Packet/PacketStruct/ClientToLoginServer.h>
#include <Item/ItemMgr.h>
#include <Item/ItemFactory.h>
#include <Utility/Debug/DebugMacros.h>
#include <Parser/ServerInfo.h>
#include <Log/ServerLog.h>
#include "ClientDispatchTable.h"
CRylAdminMgrDispatch::CRylAdminMgrDispatch(CSession& Session)
: m_bLogin(false)
, m_MyAuthority(0)
, m_MyUID(0)
, CRylServerDispatch(Session, 10)
{
}
void CRylAdminMgrDispatch::Destroy()
{
}
void CRylAdminMgrDispatch::Connected()
{
CClientDispatchTable::GetInstance().insert(this);
m_nAgentType = atoi(CServerInfo::GetInstance().GetValue("AGENT_TYPE"));
m_nIPCheck = atoi(CServerInfo::GetInstance().GetValue("IP_CHECK"));
_snprintf(m_szToolNation, 256, "%s", CServerInfo::GetInstance().GetValue("NATION"));
}
void CRylAdminMgrDispatch::Disconnected()
{
CClientDispatchTable::GetInstance().erase(this);
CDBAdminTool::GetInstance().EndLog(m_MyUID); // DB에 Logout시간을 남긴다.
CAgentServerTable::GetInstance().RemoveAllModifyCharacter(this); // 수정 중이였던 캐릭터를 목록에서 모두 삭제
CAgentServerTable::GetInstance().RemoveAllDepositLock(this); // 수정 중이였던 창고의 독점권을 모두 해제
}
// 패킷 디스패치
bool CRylAdminMgrDispatch::DispatchPacket(PktBase* lpPktBase)
{
using namespace PktAdminMgr;
unsigned char cCmd = lpPktBase->GetCmd();
if(PktAdminMgr::AuthorityMask::AdminAuthority[cCmd] & m_MyAuthority) // 패킷 사용권한 체크
{
if(cCmd && cCmd < PktCMD::PktEnd)
{
// 어떤일을하는 패킷인지 확인후 Log쿼리를 미리 만들어놓자.
// (Before 데이터 수집을 위해 디스패치전에 데이터를 끌어오자)
m_DetailLog.PktLog[cCmd](lpPktBase, m_MyLogID);
}
bool bResult = false;
// 나중에 함수 포인터로 전환해보자..;
switch(cCmd)
{
case PktCMD::PktNewAdmin: bResult = PktNewAdmin (lpPktBase); break;
case PktCMD::PktAdminList: bResult = PktAdminList (lpPktBase); break;
case PktCMD::PktDelAdmin: bResult = PktDelAdmin (lpPktBase); break;
case PktCMD::PktUpdateLevel: bResult = PktUpdateLev (lpPktBase); break;
case PktCMD::PktUpdateIP: bResult = PktUpdateIP (lpPktBase); break;
case PktCMD::PktUpdatePasswd: bResult = PktUpdatePasswd (lpPktBase); break;
case PktCMD::PktLogList: bResult = PktLogList (lpPktBase); break;
case PktCMD::PktLogUseMessage: bResult = PktLogUseMessage (lpPktBase); break;
case PktCMD::PktDetailLog: bResult = PktDetailLog (lpPktBase); break;
case PktCMD::PktBeforeAfter: bResult = PktBeforAfter (lpPktBase); break;
case PktCMD::PktSearchID: bResult = PktSearchID (lpPktBase); break;
case PktCMD::PktSearchName: bResult = PktSearchName (lpPktBase); break;
case PktCMD::PktGetCharacter: bResult = PktGetCharacter (lpPktBase); break;
case PktCMD::PktSetCharacter: bResult = PktSetCharacter (lpPktBase); break;
case PktCMD::PktCloseCharacter: bResult = PktCloseCharacter (lpPktBase); break;
case PktCMD::PktUpdateStatus: bResult = PktUpdateStatus (lpPktBase); break;
case PktCMD::PktCreateItem: bResult = PktCreateItem (lpPktBase); break;
case PktCMD::PktUpdateItem: bResult = PktUpdateItem (lpPktBase); break;
case PktCMD::PktRemoveItem: bResult = PktRemoveItem (lpPktBase); break;
case PktCMD::PktItemReset: bResult = PktItemReset (lpPktBase); break;
case PktCMD::PktSkillEdit: bResult = PktSkillEdit (lpPktBase); break;
case PktCMD::PktAddBlockUser: bResult = PktAddBlockUser (lpPktBase); break;
case PktCMD::PktSearchBlock: bResult = PktSearchBlock (lpPktBase); break;
case PktCMD::PktDelBlockUser: bResult = PktDelBlockUser (lpPktBase); break;
case PktCMD::PktChangePos: bResult = PktChangePos (lpPktBase); break;
case PktCMD::PktSetZoneList: bResult = PktSetZoneList (lpPktBase); break;
case PktCMD::PktDepositPasswd: bResult = PktDepositPasswd (lpPktBase); break;
case PktCMD::PktCheckName: bResult = PktCheckName (lpPktBase); break;
case PktCMD::PktChangeName: bResult = PktChangeName (lpPktBase); break;
case PktCMD::PktDelCharList: bResult = PktDelCharList (lpPktBase); break;
case PktCMD::PktCharRestore: bResult = PktCharRestore (lpPktBase); break;
case PktCMD::PktAdminStoreInsert: bResult = PktAdminStoreInsert (lpPktBase); break;
case PktCMD::PktAdminStoreDelete: bResult = PktAdminStoreDelete (lpPktBase); break;
case PktCMD::PktGetAdminStoreItem: bResult = PktGetAdminStoreItem (lpPktBase); break;
case PktCMD::PktUpdateAdminStore: bResult = PktUpdateAdminStore (lpPktBase); break;
case PktCMD::PktDelCharacter: bResult = PktDelCharacter (lpPktBase); break;
case PktCMD::PktInvenGold: bResult = PktInvenGold (lpPktBase); break;
case PktCMD::PktForcedDis: bResult = PktForcedDis (lpPktBase); break;
case PktCMD::PktGuildSearch: bResult = PktGuildSearch (lpPktBase); break;
case PktCMD::PktRequestGuildMemberList: bResult = PktRequestGuildMemberList (lpPktBase); break;
case PktCMD::PktGuildRestoreDataList: bResult = PktGuildRestoreDataList (lpPktBase); break;
case PktCMD::PktFortSearch: bResult = PktFortSearch (lpPktBase); break;
case PktCMD::PktMiningCamp: bResult = PktMiningCamp (lpPktBase); break;
case PktCMD::PktShopCamp: bResult = PktShopCamp (lpPktBase); break;
case PktCMD::PktShopCampGold: bResult = PktShopCampGold (lpPktBase); break;
case PktCMD::PktShopCampTax: bResult = PktShopCampTax (lpPktBase); break;
case PktCMD::PktCastleSearch: bResult = PktCastleSearch (lpPktBase); break;
case PktCMD::PktCastleCreature: bResult = PktCastleCreature (lpPktBase); break;
case PktCMD::PktItemQtyControl: bResult = PktItemQtyControlData (lpPktBase); break;
case PktCMD::PktStoreGoldUpdate: bResult = PktStoreGoldUpdate (lpPktBase); break;
case PktCMD::PktUserBillingLog: bResult = PktUserBillingLogRequest (lpPktBase); break;
case PktCMD::PktGameAdmin: bResult = PktGameAdmin (lpPktBase); break;
case PktCMD::PktConnectAllServerz: bResult = PktConnectAllServerz (lpPktBase); break;
case PktCMD::PktRefreshConnectedList: bResult = SendConnectedServerIndex (); break;
case PktCMD::PktInterestedUser: bResult = PktInterestedUser (lpPktBase); break;
case PktCMD::PktConnectionChk: bResult = PktConnectionChk (lpPktBase); break;
case PktCMD::PktConnectedUserList: bResult = PktConnectedUserList (); break;
case PktCMD::PktDuplicatedItem: bResult = PktDuplicatedItem (lpPktBase); break;
case PktCMD::PktItemDistribute: bResult = PktItemDistribute (lpPktBase); break;
case PktCMD::PktGuildRight: bResult = PktGuildRight (lpPktBase); break;
case PktCMD::PktUnifiedCharInfo: bResult = PktUnifiedCharInfo (lpPktBase); break;
case PktCMD::PktUnifiedGuildInfo: bResult = PktUnifiedGuildInfo (lpPktBase); break;
case PktCMD::PktDetailCharInfo: bResult = PktDetailCharInfo (lpPktBase); break;
case PktCMD::PktCancelExecuteQuest: bResult = PktCancelExecuteQuest (lpPktBase); break;
case PktCMD::PktDeleteHistoryQuest: bResult = PktDeleteHistoryQuest (lpPktBase); break;
case PktCMD::PktUserNation: bResult = PktUserNation (lpPktBase); break;
case PktCMD::PktShiftToUID: bResult = PktShiftToUID (lpPktBase); break;
case PktCMD::PktStoreTabEdit: bResult = PktStoreTabEdit (lpPktBase); break;
case PktCMD::PktAmountOfGold: bResult = PktAmountOfGold (lpPktBase); break;
case PktCMD::PktGMLogMsg: bResult = PktGMLogMsg (lpPktBase); break;
case PktCMD::PktNameChangeCount: bResult = PktNameChangeCount (lpPktBase); break;
case PktCMD::PktGuildMemberEdit: bResult = PktGuildMemberEdit (lpPktBase); break;
case PktCMD::PktGetCharInfoTime: bResult = PktSearchCharInfoTime (lpPktBase); break;
default: bResult = PktUnkonwnPacket(); break;
}
if(bResult) m_DetailLog.UpdateDetailLog();
return bResult;
}
else // 클라이언트가 권한정보가 없거나 권한이 없을경우
{
switch(cCmd)
{
case PktCMD::PktLogin: return PktLogin(lpPktBase);
default: return PktAuthority();
}
}
return false;
}
// 캐릭터 스테이터스 정보 수정
bool CRylAdminMgrDispatch::PktUpdateStatus(PktBase* lpPktBase)
{
PktAdminMgr::PktUpdateStatus* lpPktStatus = static_cast<PktAdminMgr::PktUpdateStatus*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktStatus->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktStatus->m_dwCID);
if(NULL == lpModifyCharacter)
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
PktAdminMgr::CHAR_STATUS_ST stBeforeStatus;
lpModifyCharacter->GetModifyCharStatus(stBeforeStatus);
if(!lpModifyCharacter->UpdataStatus(lpPktStatus->m_stStatus))
{
SendResult(PktAdminMgr::PktResult::Err_ChangeStatus);
}
else
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::MASK::ON_BASIC);
m_DetailLog.SetBefore("UID: %u\r\nCID: %u\r\nServerGroup: %u\r\n\r\nRace: %d\r\n"
"Level: %d\r\nExp: %I64d\r\nFame: %u\r\nMileage: %u\r\nClass: %u\r\nCON: %d\r\n"
"DEX: %d\r\nINT: %d\r\nSTR: %d\r\nWIS: %d\r\nIP: %d\r\nSex: %d\r\nFace: %d\r\nHair: %d\r\nChance: %d",
lpPktStatus->m_dwUID, lpPktStatus->m_dwCID, lpPktStatus->m_dwServerGroup, stBeforeStatus.m_cRace,
stBeforeStatus.m_cLevel, stBeforeStatus.m_dwExp, stBeforeStatus.m_dwFame, stBeforeStatus.m_dwMileage,
stBeforeStatus.m_nClass, stBeforeStatus.m_nCON, stBeforeStatus.m_nDEX, stBeforeStatus.m_nINT,
stBeforeStatus.m_nSTR, stBeforeStatus.m_nWIS, stBeforeStatus.m_nIP, stBeforeStatus.m_cSex,
stBeforeStatus.m_cFace, stBeforeStatus.m_cHair, stBeforeStatus.m_cChance);
m_DetailLog.SetAfter("Race: %d\r\nLevel: %d\r\nExp: %I64d\r\nFame: %u\r\nMileage: %u\r\n"
"Class: %d\r\nCON: %d\r\nDEX: %d\r\nINT: %d\r\nSTR: %d\r\nWIS: %d\r\nIP: %d\r\n"
"Sex: %d\r\nFace: %d\r\nHair: %d\r\nChance: %d",
lpPktStatus->m_stStatus.m_cRace, lpPktStatus->m_stStatus.m_cLevel, lpPktStatus->m_stStatus.m_dwExp,
lpPktStatus->m_stStatus.m_dwFame, lpPktStatus->m_stStatus.m_dwMileage, lpPktStatus->m_stStatus.m_nClass,
lpPktStatus->m_stStatus.m_nCON, lpPktStatus->m_stStatus.m_nDEX, lpPktStatus->m_stStatus.m_nINT,
lpPktStatus->m_stStatus.m_nSTR, lpPktStatus->m_stStatus.m_nWIS, lpPktStatus->m_stStatus.m_nIP,
lpPktStatus->m_stStatus.m_cSex, lpPktStatus->m_stStatus.m_cFace, lpPktStatus->m_stStatus.m_cHair,
lpPktStatus->m_stStatus.m_cChance);
m_DetailLog.InsertLog(m_MyLogID);
SendResult(PktAdminMgr::PktResult::Success_ChangeStatus);
}
return true;
}
// 캐릭터 정보 요청
bool CRylAdminMgrDispatch::PktGetCharacter(PktBase* lpPktBase)
{
PktAdminMgr::PktGetCharacter* lpPktGetChar = static_cast<PktAdminMgr::PktGetCharacter*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktGetChar->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계 서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
ItemData::CDepositLock::DepositInfo Info;
if(lpAgentDispatch->GetDepositLock().GetLockInfo(lpPktGetChar->m_dwUID, Info))
{
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(Info.m_dwCID);
if(NULL != lpModifyCharacter)
{
if(lpModifyCharacter->GetSaveState())
{
// 요청한 UID내의 캐릭터가 정보 저장중인 상태
SendResultnRequestKey(
PktAdminMgr::PktResult::Err_StateisSave, lpPktGetChar->m_dwRequestKey);
return true;
}
}
}
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktGetChar->m_dwCID);
bool bRefresh = false;
if(NULL != lpModifyCharacter)
{
// 동일한 사용자가 캐릭터 정보 재 갱신 가능하도록
bRefresh = (lpModifyCharacter->GetDispatch() == this)
&& (lpModifyCharacter->GetClientKey() == lpPktGetChar->m_dwRequestKey);
}
if ((NULL == lpModifyCharacter) || bRefresh)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAgentServer::PktAdminToolGetData));
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAgentServer::PktAdminToolGetData* lpPktSGetChar =
reinterpret_cast<PktAgentServer::PktAdminToolGetData*>(lpBuffer->begin());
lpPktSGetChar->m_cType = PktAgentServer::PktAdminToolGetData::GET_CHAR_DATA;
lpPktSGetChar->m_dwUID = lpPktGetChar->m_dwUID;
lpPktSGetChar->m_dwCID = lpPktGetChar->m_dwCID;
lpPktSGetChar->m_cOldServerGroupID = lpPktGetChar->m_cOldServerGroupID;
lpPktSGetChar->m_dwRequestKey =
lpAgentDispatch->GetRequestKeeper().Push(this, lpPktGetChar->m_dwRequestKey);
strncpy(lpPktSGetChar->m_szName, lpPktGetChar->m_szCharName, 16);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAgentServer::PktAdminToolGetData), PktAgentServer::PktCMD::CmdAdminToolGetData, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (true == lpAgentDispatch->Send(lpBuffer))
{
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().InsertChar(lpPktGetChar->m_dwCID);
lpModifyCharacter->SetUID(lpPktGetChar->m_dwUID);
lpModifyCharacter->SetCID(lpPktGetChar->m_dwCID);
lpModifyCharacter->SetModifyAdmin(m_szAccount, sizeof(m_szAccount));
lpModifyCharacter->SetServerGroup(lpPktGetChar->m_dwServerGroup);
lpModifyCharacter->SetOldServerGroup(lpPktGetChar->m_cOldServerGroupID);
lpModifyCharacter->SetDispatch(this);
lpModifyCharacter->SetClientKey(lpPktGetChar->m_dwRequestKey);
SendResult(PktAdminMgr::PktResult::Success_ModifyCharacter);
return true;
}
else
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
SendResultnRequestKey(PktAdminMgr::PktResult::Err_ModifyCharacter, lpPktGetChar->m_dwRequestKey);
}
return true;
}
// 캐릭터 편집을 마치거나 캐릭터 세션을 닫고 저장
bool CRylAdminMgrDispatch::PktCloseCharacter(PktBase* lpPktBase)
{
PktAdminMgr::PktCloseCharacter* lpPktCloseChar = static_cast<PktAdminMgr::PktCloseCharacter*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktCloseChar->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계 서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktCloseChar->m_dwCID);
if(NULL == lpModifyCharacter)
{
ERRLOG0(g_Log, "캐릭터 세션 얻기 실패");
return true;
}
// 캐릭터 정보가 변경되었으나 저장이 안된상태라면 저장할것인지 클라이언트에게 물어보자
//if(0 == lpModifyCharacter->m_byChangedInfo)
CPacketDispatch* lpPacketDispatch =
lpAgentDispatch->GetDepositLock().GetDispatch(lpModifyCharacter->GetUID());
if(this == lpPacketDispatch)
{
// 내가 창고 독점권을 소유하고 있으니 독점권 해지
lpAgentDispatch->GetDepositLock().DepositUnLock(lpModifyCharacter->GetUID());
}
// 내가 편집 중이던 캐릭터를 모두 지우기
if(!lpAgentDispatch->GetModifyCharacterMgr().EraseChar(lpPktCloseChar->m_dwCID))
{
SendResult(PktAdminMgr::PktResult::Err_CloseCharacter);
}
return true;
}
// 캐릭터의 정보가 변경된부분이 있으면 변경된 부분만 저장한다.
bool CRylAdminMgrDispatch::PktSetCharacter(PktBase* lpPktBase)
{
PktAdminMgr::PktSetCharacter* lpPktSetChar = static_cast<PktAdminMgr::PktSetCharacter*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktSetChar->m_dwServerGroup);
if (NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계 서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpChar =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktSetChar->m_dwCID);
if (NULL == lpChar)
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
// 캐릭터에 변경된 정보가 있으면
if ((0 != lpChar->m_byChangedInfo) && (0 == lpChar->GetSaveState()))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAgentServer::PktAdminToolSetData));
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAgentServer::PktAdminToolSetData* lpPktSSetData =
reinterpret_cast<PktAgentServer::PktAdminToolSetData*>(lpBuffer->begin());
// Character Parser에게 ServerDispatch Session을 매치
lpAgentDispatch->SetPaseSession();
// 저장중인 캐릭터 재 로딩 방지
lpChar->SetSaveState(true);
lpPktSSetData->m_dwSerial = Item::CItemFactory::GetInstance().GetItemUID();
lpPktSSetData->m_cType = PktAgentServer::PktAdminToolSetData::OPEN_UPDATE_DATA;
lpPktSSetData->m_dwUID = lpPktSetChar->m_dwUID;
lpPktSSetData->m_dwCID = lpPktSetChar->m_dwCID;
lpPktSSetData->m_dwRequestKey =
lpAgentDispatch->GetRequestKeeper().Push(this, lpPktSetChar->m_dwRequestKey);
lpPktSSetData->m_cOldServerGroupID = lpPktSetChar->m_cOldServerGroupID;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAgentServer::PktAdminToolSetData), PktAgentServer::PktCMD::CmdAdminToolSetData, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (true == lpAgentDispatch->Send(lpBuffer))
{
if (true == lpAgentDispatch->UpdateCharacter(lpChar, lpPktSSetData->m_dwSerial,
lpPktSSetData->m_dwUID, lpPktSSetData->m_dwCID, lpPktSSetData->m_dwRequestKey))
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Apply Edited Data]\r\nUID: %u\r\nCID: %u\r\nServerGroup: %u",
lpPktSetChar->m_dwUID, lpPktSetChar->m_dwCID, lpPktSetChar->m_dwServerGroup);
m_DetailLog.InsertLog(m_MyLogID);
SendResult(PktAdminMgr::PktResult::Success_SaveCharacter);
return true;
}
else
{
ERRLOG0(g_Log, "캐릭터 세션 열기 실패");
}
}
else
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_SkipCharacterSave);
}
return true;
}
// ID로 캐릭터 검색 CID, UID
bool CRylAdminMgrDispatch::PktSearchID(PktBase* lpPktBase)
{
PktAdminMgr::PktSearchID* lpPktSearch = static_cast<PktAdminMgr::PktSearchID*>(lpPktBase);
bool bResult = false;
if(lpPktSearch->m_SearchType == PktAdminMgr::PktSearchID::SearchUID)
{
PktSearchUIDAck(lpPktSearch->m_dwID, lpPktSearch->m_nOldServerID, lpPktSearch->m_dwRequestKey, bResult);
}
else if(lpPktSearch->m_SearchType == PktAdminMgr::PktSearchID::SearchCID)
{
PktSearchCIDAck(lpPktSearch->m_dwID, lpPktSearch->m_dwServerGroup, lpPktSearch->m_dwRequestKey, bResult);
}
PktSearchResultAck(bResult ? PktAdminMgr::PktSearchResultAck::Success : PktAdminMgr::PktSearchResultAck::NoData,
lpPktSearch->m_dwRequestKey);
return true;
}
// UID 검색은 모든 서버군의 DB에 전송하여 결과값을 얻어온다.
bool CRylAdminMgrDispatch::PktSearchUIDAck(unsigned long UID, unsigned int nOldServerID,
unsigned long dwKey, bool& bResult)
{
CAgentServerTable& ServerTable = CAgentServerTable::GetInstance();
CCumulateBuffer cBuffer(8129, &GetSession());
unsigned short SearchCount = 0;
// 모든 DB에서 검색하여 결과를 보내준다.
for(int Cnt = 0; Cnt < CAgentServerTable::MAX_AGENT_SERVER; Cnt++)
{
CGameDB* lpGameDB = ServerTable.GetGameDB(Cnt);
CRylAgentServerDispatch* lpAgentDispatch = ServerTable.GetDispatch(Cnt);
if((NULL != lpGameDB) && (NULL != lpAgentDispatch))
{
char In_Char[1024]; // 일단 넉넉하게 잡아주자
if(lpGameDB->UIDByCharacterList(UID, m_nAgentType, nOldServerID, In_Char))
{
unsigned char CharCount = In_Char[0];
if (0 == CharCount)
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
}
else
{
int nSize = sizeof(PktAdminMgr::PktSearchAck) + (sizeof(CGameDB::Out_CharList) * CharCount);
char* lpBuffer = cBuffer.GetBuffer(nSize);
PktAdminMgr::PktSearchAck* lpPktSearch = reinterpret_cast<PktAdminMgr::PktSearchAck*>(lpBuffer);
char* lpCharBody = reinterpret_cast<char*>(lpPktSearch + 1);
lpPktSearch->m_dwServerGroup = Cnt; // 서버군 인덱스
lpPktSearch->m_CharCount = CharCount; // 등록되어있는 캐릭터 수
lpPktSearch->m_dwRequestKey = dwKey;
lpPktSearch->m_cOldServerGroup = nOldServerID;
// 캐릭터 이름및 UID CID 정보
CopyMemory(lpCharBody, In_Char + 1, sizeof(CGameDB::Out_CharList) * CharCount);
PacketWrap::WrapHeader(lpBuffer, nSize, PktAdminMgr::PktCMD::PktSearchAck, 0, 0);
++SearchCount;
}
}
}
}
if(0 == SearchCount)
{
// 검색된 정보가 없으면.
bResult = false;
cBuffer.ResizeLength(0);
}
else
{
bResult = true;
}
return true;
}
// CID 검색결과 Ack
bool CRylAdminMgrDispatch::PktSearchCIDAck(unsigned long CID, unsigned long dwGroup, unsigned long dwKey,
bool& bResult)
{
CAgentServerTable& ServerTable = CAgentServerTable::GetInstance();
CCumulateBuffer cBuffer(8192, &GetSession());
bResult = false;
CGameDB* lpGameDB = ServerTable.GetGameDB(dwGroup);
CRylAgentServerDispatch* lpAgentDispatch = ServerTable.GetDispatch(dwGroup);
if((NULL != lpGameDB) && (NULL != lpAgentDispatch))
{
char In_Char[1024];
if (true == lpGameDB->CIDByCharacterList(CID, In_Char))
{
unsigned char Count = In_Char[0];
int nSize = sizeof(PktAdminMgr::PktSearchAck) + sizeof(CGameDB::Out_CharList);
char* lpBuffer = cBuffer.GetBuffer(nSize);
PktAdminMgr::PktSearchAck* lpPktSearch = reinterpret_cast<PktAdminMgr::PktSearchAck*>(lpBuffer);
char* lpCharBody = reinterpret_cast<char*>(lpPktSearch + 1);
bResult = true;
lpPktSearch->m_dwServerGroup = dwGroup;
lpPktSearch->m_CharCount = Count;
lpPktSearch->m_dwRequestKey = dwKey;
lpPktSearch->m_cOldServerGroup = lpGameDB->GetOldServerGroupID(CID);
CopyMemory(lpCharBody, In_Char + 1, sizeof(CGameDB::Out_CharList));
PacketWrap::WrapHeader(lpBuffer, nSize, PktAdminMgr::PktCMD::PktSearchAck, 0, 0);
}
}
if(bResult == false)
{
cBuffer.ResizeLength(0);
}
return true;
}
// 계정명, 캐릭명으로 검색
bool CRylAdminMgrDispatch::PktSearchName(PktBase* lpPktBase)
{
PktAdminMgr::PktSearchName* lpPktSearch = static_cast<PktAdminMgr::PktSearchName*>(lpPktBase);
unsigned short wSearchCount = 0; // 캐릭명으로 검색한 경우 검색 수
bool bResult = false; // 계정명으로 검색한 경우 결과 값 존재 여부
// 우선 누적버퍼에 있는 값을 클라이언트로 전송
CCumulateBuffer cBuffer(8129, &GetSession());
if (PktAdminMgr::PktSearchName::Character == lpPktSearch->m_SearchType)
{
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktSearch->m_dwServerGroup);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktSearch->m_dwServerGroup);
if ((NULL != lpGameDB) && (NULL != lpAgentDispatch))
{
char In_Char[1024];
if (lpGameDB->CNameByCharacterList(lpPktSearch->m_szName, In_Char))
{
unsigned char Count = *In_Char;
int nSize = sizeof(PktAdminMgr::PktSearchAck) + sizeof(CGameDB::Out_CharList);
char* lpBuffer = cBuffer.GetBuffer(nSize);
PktAdminMgr::PktSearchAck* lpPktSearchAck =
reinterpret_cast<PktAdminMgr::PktSearchAck*>(lpBuffer);
char* lpCharBody = reinterpret_cast<char*>(lpPktSearchAck + 1);
lpPktSearchAck->m_CharCount = Count;
lpPktSearchAck->m_dwServerGroup = lpPktSearch->m_dwServerGroup;
lpPktSearchAck->m_dwRequestKey = lpPktSearch->m_dwRequestKey;
CopyMemory(lpCharBody, In_Char + 1, sizeof(CGameDB::Out_CharList));
++wSearchCount;
PacketWrap::WrapHeader(lpBuffer, nSize, PktAdminMgr::PktCMD::PktSearchAck, 0, 0);
}
}
}
else if(PktAdminMgr::PktSearchName::Account == lpPktSearch->m_SearchType)
{
unsigned long dwUID = 0;
CAuthDB* lpAuthDB = CAgentServerTable::GetInstance().GetAuthDB();
if (NULL != lpAuthDB)
{
dwUID = lpAuthDB->GetUIDFromAccount(lpPktSearch->m_szName);
}
else
{
ERRLOG0(g_Log, "계정명-> UID 변환 실패: 인증 디비 얻기 실패");
}
PktSearchUIDAck(dwUID, lpPktSearch->m_nOldServerID, lpPktSearch->m_dwRequestKey, bResult);
}
if((0 == wSearchCount) && (false == bResult))
{
cBuffer.ResizeLength(0);
PktSearchResultAck(PktAdminMgr::PktSearchResultAck::NoData, lpPktSearch->m_dwRequestKey);
}
else
{
cBuffer.SendAll();
PktSearchResultAck(PktAdminMgr::PktSearchResultAck::Success, lpPktSearch->m_dwRequestKey);
}
return true;
}
// 캐릭터 검색결과 클라이언트에 통보
bool CRylAdminMgrDispatch::PktSearchResultAck(unsigned char Result, unsigned long dwRequestKey)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktSearchResultAck));
PktAdminMgr::PktSearchResultAck* lpSearchResult =
reinterpret_cast<PktAdminMgr::PktSearchResultAck*>(lpBuffer->begin());
lpSearchResult->m_Result = Result;
lpSearchResult->m_dwRequestKey = dwRequestKey;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktSearchResultAck), PktAdminMgr::PktCMD::PktSearchResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 위치좌표 수정
bool CRylAdminMgrDispatch::PktChangePos(PktBase* lpPktBase)
{
PktAdminMgr::PktChangePos* lpPktChangePos = static_cast<PktAdminMgr::PktChangePos*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktChangePos->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG1(g_Log, "중계서버 디스패치를 얻는데 실패했습니다. 그룹-%d",
lpPktChangePos->m_dwServerGroup);
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktChangePos->m_dwCID);
if(NULL == lpCharacter)
{
ERRLOG1(g_Log, "캐릭터 디스패치를 얻는데 실패했습니다. CID- %u", lpPktChangePos->m_dwCID);
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
SERVER_ID ServerID;
ServerID.dwID = lpCharacter->GetServerID();
Position& Pos = lpCharacter->GetCurPos();
// 수정 전 정보 기록
CString strBeforePos;
strBeforePos.Format("UID: %u\r\nCID: %u\r\nServerGroup: %u\r\n\r\n"
"X: %f\r\nY: %f\r\nZ: %f\r\nZone: %d",
lpPktChangePos->m_dwUID, lpPktChangePos->m_dwCID, lpPktChangePos->m_dwServerGroup,
Pos.m_fPointX, Pos.m_fPointY, Pos.m_fPointZ, ServerID.GetZone());
// 수정
Pos.m_fPointX = lpPktChangePos->m_fPosX;
Pos.m_fPointY = lpPktChangePos->m_fPosY;
Pos.m_fPointZ = lpPktChangePos->m_fPosZ;
ServerID.sID.ID = lpPktChangePos->m_cZone;
lpCharacter->SetServerID(ServerID.dwID);
// 수정전, 수정후 로그 기록
m_DetailLog.SetBefore("%s", strBeforePos);
m_DetailLog.SetAfter("X: %f\r\nY: %f\r\nZ: %f\r\nZone: %d",
lpPktChangePos->m_fPosX, lpPktChangePos->m_fPosY, lpPktChangePos->m_fPosZ,
lpPktChangePos->m_cZone);
m_DetailLog.InsertLog(m_MyLogID);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
SendResult(PktAdminMgr::PktResult::Success_ChangePos);
return true;
}
// 권한이 없음을 알려버리자.
bool CRylAdminMgrDispatch::PktAuthority()
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpPktResult = reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
lpPktResult->m_Result = PktAdminMgr::PktResult::Err_Authority; // 사용권한이 없음을 알린다.
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 로그.. 수정전, 수정후 리스트를 클라이언트에 보내자.
bool CRylAdminMgrDispatch::PktBeforAfter(PktBase* lpPktBase)
{
#pragma pack(1)
struct BeforeAfter
{
char m_szBefore[PktAdminMgr::MAX_BEFORE];
char m_szAfter[PktAdminMgr::MAX_AFTER];
};
#pragma pack()
PktAdminMgr::PktBeforeAfter* lpBeforeAfter = static_cast<PktAdminMgr::PktBeforeAfter*>(lpPktBase);
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktBeforeAfterAck));
PktAdminMgr::PktBeforeAfterAck* lpBeforeAfterAck =
reinterpret_cast<PktAdminMgr::PktBeforeAfterAck*>(lpBuffer->begin());
char szQry[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQry, CDBAdminTool::MAX_QUERY_LENGTH, QUERYZ::BeforeAfter, lpBeforeAfter->m_DetailLogID);
BeforeAfter BeforeAfterData;
if (CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
if (CDBAdminTool::GetInstance().GetData(&BeforeAfterData))
{
strncpy(lpBeforeAfterAck->m_szBefore, BeforeAfterData.m_szBefore, PktAdminMgr::MAX_BEFORE);
strncpy(lpBeforeAfterAck->m_szAfter, BeforeAfterData.m_szAfter, PktAdminMgr::MAX_AFTER);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktBeforeAfterAck), PktAdminMgr::PktCMD::PktBeforeAfterAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
// 재제자 리스트 검색
bool CRylAdminMgrDispatch::PktSearchBlock(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_Data
{
unsigned long m_nidx;
unsigned char m_cServerGroup;
unsigned long m_dwUID;
char m_szClientID[PktAdminMgr::MAX_ACCOUNT];
char m_szCharacterName[PktAdminMgr::MAX_NAME];
unsigned char m_cBlockTarget;
unsigned char m_cBlockTerm;
char m_szBlockStartTime[PktAdminMgr::MAX_TIME];
char m_szBlockFinishTime[PktAdminMgr::MAX_TIME];
char m_szAdminName[PktAdminMgr::MAX_ACCOUNT];
char m_szDescription[PktAdminMgr::PktAddBlockUser::MAX_DESCRIPTION];
};
#pragma pack()
bool bExistData = false;
PktAdminMgr::PktSearchBlock* lpSearchBlock = static_cast<PktAdminMgr::PktSearchBlock*>(lpPktBase);
char szQry[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQry, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT idx, tinyServerID, UID, strClientID, strCharName, tinyType, tinyKind, "
"CONVERT(VARCHAR(20), dateStartTime, 120), CONVERT(VARCHAR(20), dateEndTime, 120), "
"strAdminID, strDescription FROM TblRestraintChar WHERE tinyServerID = %u",
lpSearchBlock->m_dwServerGroup);
CDBAdminTool* lpAdminToolDB = &(CDBAdminTool::GetInstance());
if (NULL == lpAdminToolDB)
{
ERRLOG0(g_Log, "운영 DB를 얻는데 실패했습니다.");
return true;
}
if (true == lpAdminToolDB->ExecuteQuery(szQry))
{
In_Data stIn_Data;
CCumulateBuffer cBuffer(8192, &GetSession());
while(lpAdminToolDB->GetData(&stIn_Data))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktSearchBlockAck));
PktAdminMgr::PktSearchBlockAck* lpBlockListAck =
reinterpret_cast<PktAdminMgr::PktSearchBlockAck*>(lpBuffer);
lpBlockListAck->m_cServerGroup = stIn_Data.m_cServerGroup;
lpBlockListAck->m_dwUID = stIn_Data.m_dwUID;
lpBlockListAck->m_cBlockTarget = stIn_Data.m_cBlockTarget;
lpBlockListAck->m_cBlockTerm = stIn_Data.m_cBlockTerm;
lpBlockListAck->m_nidx = stIn_Data.m_nidx;
strncpy(lpBlockListAck->m_szClientID, stIn_Data.m_szClientID, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpBlockListAck->m_szCharacterName, stIn_Data.m_szCharacterName, PktAdminMgr::MAX_NAME);
strncpy(lpBlockListAck->m_szBlockStartTime, stIn_Data.m_szBlockStartTime, PktAdminMgr::MAX_TIME);
strncpy(lpBlockListAck->m_szBlockFinishTime, stIn_Data.m_szBlockFinishTime, PktAdminMgr::MAX_TIME);
strncpy(lpBlockListAck->m_szAdminName, stIn_Data.m_szAdminName, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpBlockListAck->m_szDescription, stIn_Data.m_szDescription,
PktAdminMgr::PktAddBlockUser::MAX_DESCRIPTION);
ZeroMemory(&stIn_Data, sizeof(In_Data));
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktSearchBlockAck), PktAdminMgr::PktCMD::PktSearchBlockAck, 0, 0);
bExistData = true;
}
}
if(!bExistData)
{
SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
// 유저 블럭
bool CRylAdminMgrDispatch::PktAddBlockUser(PktBase* lpPktBase)
{
PktAdminMgr::PktAddBlockUser* lpPktAddBlockUser =
static_cast<PktAdminMgr::PktAddBlockUser*>(lpPktBase);
CDBAdminTool* lpAdminToolDB = &(CDBAdminTool::GetInstance());
if (NULL == lpAdminToolDB)
{
ERRLOG0(g_Log, "운영 DB를 얻는데 실패했습니다.");
return true;
}
// UID로 계정명 얻기(실패시엔 그냥 'Unknown'이라도 집어넣자!)
char szClientID[PktAdminMgr::MAX_ACCOUNT];
CAuthDB* lpAuthDB = CAgentServerTable::GetInstance().GetAuthDB();
if (NULL != lpAuthDB)
{
if (false == lpAuthDB->GetAccountFromUID(lpPktAddBlockUser->m_dwUID, szClientID))
{
_snprintf(szClientID, PktAdminMgr::MAX_ACCOUNT, "Unknown");
}
}
if (false == lpAdminToolDB->AddBlockUser(lpPktAddBlockUser, m_szAccount, szClientID))
{
ERRLOG0(g_Log, "계정 또는 캐릭터를 블럭 리스트에 추가하는데 실패했습니다.");
SendResult(PktAdminMgr::PktResult::Err_AddBlockUser);
}
else
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[User Block]\r\nAccount: %s\r\nTerm: %c",
m_szAccount, lpPktAddBlockUser->m_cBlockTerm);
m_DetailLog.InsertLog(m_MyLogID);
SendResult(PktAdminMgr::PktResult::Success_AddBlockUser);
}
return true;
}
// 블럭 리스트에서 삭제
bool CRylAdminMgrDispatch::PktDelBlockUser(PktBase* lpPktBase)
{
PktAdminMgr::PktDelBlockUser* lpPktDelBlockUser = static_cast<PktAdminMgr::PktDelBlockUser*>(lpPktBase);
CDBAdminTool* lpAdminToolDB = &(CDBAdminTool::GetInstance());
if (NULL == lpAdminToolDB)
{
ERRLOG0(g_Log, "운영 DB를 얻는데 실패했습니다.");
return true;
}
if (false == lpAdminToolDB->DelBlockUser(lpPktDelBlockUser))
{
ERRLOG0(g_Log, "계정 또는 캐릭터를 블럭리스트에서 삭제하는데 실패했습니다.");
SendResult(PktAdminMgr::PktResult::Err_DelBlockUser);
}
else
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Del Blocked User]\r\nAccount: %s", m_szAccount);
m_DetailLog.InsertLog(m_MyLogID);
SendResult(PktAdminMgr::PktResult::Success_DelBlockUser);
}
return true;
}
// 알수 없는 패킷을 받았습니다
bool CRylAdminMgrDispatch::PktUnkonwnPacket()
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpPktResult =
reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
lpPktResult->m_Result = PktAdminMgr::PktResult::Err_UnkonwnPacket; // 알수없는 패킷
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 각종 작업의 결과 커맨드를 클라이언트로 전송
bool CRylAdminMgrDispatch::SendResult(unsigned char cResult)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktResultAck* lpPktResult =
reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
lpPktResult->m_Result = cResult;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// Custom 결과 패킷 + 클라이언트키를 같이 보낸다.
bool CRylAdminMgrDispatch::SendResultnRequestKey(unsigned char cResult, unsigned long dwRequestKey)
{
bool bIsReleased = true;
CBuffer* lpBuffer =
CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck) + sizeof(unsigned long));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktResultAck* lpPktResult =
reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
unsigned long* dwRequest = reinterpret_cast<unsigned long*>(lpPktResult + 1);
lpPktResult->m_Result = cResult;
*dwRequest = dwRequestKey;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck) + sizeof(unsigned long), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "패킷 보내기 실패");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
bool CRylAdminMgrDispatch::PktLogin(PktBase* lpPktBase)
{
PktAdminMgr::PktLogin* lpPktLogin = static_cast<PktAdminMgr::PktLogin*>(lpPktBase);
CDBAdminTool& DBAdminTool = CDBAdminTool::GetInstance();
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpPktResult = reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
unsigned char Result = DBAdminTool.Login(lpPktLogin->m_szAccount, lpPktLogin->m_szPasswd);
char szIPBuf[PktAdminMgr::MAX_IPBUFFER];
unsigned long dwLength = PktAdminMgr::MAX_IPBUFFER;
char* szIP = NULL;
// 접속한 클라이언트 IP 얻기
INET_Addr& Addr = GetSession().GetRemoteAddr();
// INET_Addr -> String
if(SOCKET_ERROR ==
WSAAddressToString(&Addr.get_addr(), Addr.get_size(), NULL, szIPBuf, &dwLength))
{
ERRLOG0(g_Log, "INET_Addr -> String 변환 실패");
return false;
}
else
{
szIP = strtok(szIPBuf, ":");
}
if (Result == PktAdminMgr::PktResult::Success_Login) // 계정과 패스 체크
{
if (1 == m_nIPCheck)
{
Result = DBAdminTool.CheckIP(lpPktLogin->m_szAccount, szIP); // IP 체크
}
else
{
Result = PktAdminMgr::PktResult::Success_ConnectIP;
}
if (Result == PktAdminMgr::PktResult::Success_ConnectIP) // 접속허가 IP 여부 판별
{
lpPktResult->m_Result = PktAdminMgr::PktResult::Success_Login;
}
else
{
if (0 == stricmp(lpPktLogin->m_szAccount, "zunpyo")) // 내 계정인 경우 IP 무시;
{
lpPktResult->m_Result = PktAdminMgr::PktResult::Success_Login;
Result = PktAdminMgr::PktResult::Success_ConnectIP;
DETLOG1(g_Log, "MASTER 계정으로 접속 - IP: %s", szIP);
}
else
{
lpPktResult->m_Result = Result;
}
}
}
else
{
lpPktResult->m_Result = Result;
}
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
if (Result == PktAdminMgr::PktResult::Success_ConnectIP) // 인증 처리가 정상적으로 처리되었으면
{
// 접속 시 정보를 클라이언트로 보내기
SendLoginInfo(lpPktLogin->m_szAccount);
SendAgentServerInfo();
SendZoneList();
SendAdminStoreList();
DETLOG2(g_Log, "계정 %s의 사용자가 접속하였습니다. IP: %s ", lpPktLogin->m_szAccount, szIP);
}
else
{
if(NULL != szIP)
{
ERRLOG2(g_Log, "등록 된 IP가 아닙니다. Account: %s, IP: %s",
lpPktLogin->m_szAccount, szIP);
}
}
return true;
}
// 서버에서 필요로하는 권한정보 및 기타정보를 셋팅하고 클라이언트에게 권한 리스트 및 계정정보를 보내준다.
bool CRylAdminMgrDispatch::SendLoginInfo(char* szAccount)
{
#pragma pack(1)
struct LoginInfo
{
unsigned int m_UID;
char m_szAccount[PktAdminMgr::MAX_ACCOUNT];
char m_szPassword[PktAdminMgr::MAX_PASSWORD];
unsigned char m_Level[2];
char m_szName[PktAdminMgr::MAX_NAME];
char m_szIP[PktAdminMgr::MAX_IP];
char m_RegDate[PktAdminMgr::MAX_DATE];
};
#pragma pack()
LoginInfo Info;
char szQry[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQry, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::LoginInfo, szAccount);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
ERRLOG1(g_Log, "쿼리 실패 - %s", szQry);
}
else
{
ZeroMemory(&Info, sizeof(Info));
if (CDBAdminTool::GetInstance().GetData(&Info))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktLoginInfoAck));
PktAdminMgr::PktLoginInfoAck* lpPktInfoAck =
reinterpret_cast<PktAdminMgr::PktLoginInfoAck*>(lpBuffer->wr_ptr());
m_MyUID = Info.m_UID;
lpPktInfoAck->m_UID = Info.m_UID;
lpPktInfoAck->m_Level = Info.m_Level[0];
strncpy(lpPktInfoAck->m_szAccount, Info.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpPktInfoAck->m_szPassword, Info.m_szPassword, PktAdminMgr::MAX_PASSWORD);
strncpy(lpPktInfoAck->m_szName, Info.m_szName, PktAdminMgr::MAX_NAME);
strncpy(lpPktInfoAck->m_szIP, Info.m_szIP, PktAdminMgr::MAX_IP);
strncpy(lpPktInfoAck->m_RegDate, Info.m_RegDate, PktAdminMgr::MAX_DATE);
strncpy(m_szAccount, Info.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
m_MyAuthority = SetAuthorityMask(Info.m_Level[0]); // 권한 마스크를 설정한다.
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktLoginInfoAck), PktAdminMgr::PktCMD::PktLoginInfoAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
if (CDBAdminTool::GetInstance().StartupLog(Info.m_UID, Info.m_szIP)) // 로그 데이터를 DB에 작성한다.
{
m_MyLogID = CDBAdminTool::GetInstance().GetNowLogID(m_MyUID); // 로그번호를 가져온다.
}
}
}
return true;
}
// AdminToolClient에 있는 GlobalFunctions랑 동일해야함-_ -;
unsigned char CRylAdminMgrDispatch::SetAuthorityMask(unsigned char cLV)
{
switch(cLV){
case 'D': return PktAdminMgr::AuthorityMask::DEVELOPER;
case 'M': return PktAdminMgr::AuthorityMask::MASTER;
case 'G': return PktAdminMgr::AuthorityMask::GM;
case 'S': return PktAdminMgr::AuthorityMask::SUPPORTER;
default: return PktAdminMgr::AuthorityMask::QUEST_MODE;
}
}
bool CRylAdminMgrDispatch::SendZoneList()
{
unsigned char MAX_ZONE_COUNT = 30;
CDBAdminTool& ToolDB = CDBAdminTool::GetInstance();
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktSetZoneList));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktSetZoneList* lpPktSetZoneAck =
reinterpret_cast<PktAdminMgr::PktSetZoneList*>(lpBuffer->wr_ptr());
if(!ToolDB.GetZoneList(m_MyUID, lpPktSetZoneAck->m_ZoneBuffer))
{
ERRLOG0(g_Log, "사용자의 존 리스트 정보를 가져오는데 실패했습니다.");
return true;
}
unsigned long* dwSize = reinterpret_cast<unsigned long*>(lpPktSetZoneAck->m_ZoneBuffer);
unsigned int PktLength = (sizeof(PktAdminMgr::PktSetZoneList) - PktAdminMgr::PktSetZoneList::MAX_BUFFER) + *dwSize;
// 해당 테이블에 정보가 없는 경우는 보내지 않음 (현상: 결과값 사이즈가 이상하게 나옴)
if (*dwSize > PktAdminMgr::PktSetZoneList::MAX_BUFFER)
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false ==PacketWrap::WrapHeader(lpBuffer,
PktLength, PktAdminMgr::PktCMD::PktSetZoneListAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
return true;
}
// 새 계정 생성
bool CRylAdminMgrDispatch::PktNewAdmin(PktBase* lpPktBase)
{
PktAdminMgr::PktNewAdmin* lpPktNewAdmin = static_cast<PktAdminMgr::PktNewAdmin*>(lpPktBase);
// DEVELOPER 권한만이 DEVELOPER, MASTER 권한 계정을 생성 할수 있음 +_ +
unsigned char cTempRights = SetAuthorityMask(lpPktNewAdmin->m_szLev);
if(cTempRights == PktAdminMgr::AuthorityMask::DEVELOPER || cTempRights == PktAdminMgr::AuthorityMask::MASTER)
{
if(!(m_MyAuthority & PktAdminMgr::AuthorityMask::DEVELOPER))
{
SendResult(PktAdminMgr::PktResult::Err_Authority);
return true;
}
}
unsigned char Result = PktAdminMgr::PktResult::Result_Null;
if(!strlen(lpPktNewAdmin->m_szAccount)) {Result = PktAdminMgr::PktResult::Err_NewAdmin;}
if(!strlen(lpPktNewAdmin->m_szPasswd)) {Result = PktAdminMgr::PktResult::Err_NewAdmin;}
if(!strlen(lpPktNewAdmin->m_szIP)) {Result = PktAdminMgr::PktResult::Err_NewAdmin;}
if(!strlen(lpPktNewAdmin->m_szName)) {Result = PktAdminMgr::PktResult::Err_NewAdmin;}
if(!lpPktNewAdmin->m_szLev) {Result = PktAdminMgr::PktResult::Err_NewAdmin;}
if(Result == PktAdminMgr::PktResult::Result_Null)
{
Result = CDBAdminTool::GetInstance().NewAdmin(lpPktNewAdmin); // 계정 생성
}
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpPktResultAck =
reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
lpPktResultAck->m_Result = Result;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
if(PktAdminMgr::PktResult::Success_NewAdmin == Result)
{
PktNewAdminAck(lpPktNewAdmin->m_szAccount);
}
return true;
}
// 계정생성 여부
bool CRylAdminMgrDispatch::PktNewAdminAck(char* szAccount)
{
#pragma pack(1)
struct AdminList
{
char m_szAccount[PktAdminMgr::MAX_ACCOUNT];
char m_szName[PktAdminMgr::MAX_NAME];
char m_szIP[PktAdminMgr::MAX_IP];
char m_szDate[PktAdminMgr::MAX_DATE];
char m_szLevel[2];
};
#pragma pack()
AdminList GetList;
char szQry[CDBAdminTool::QUERY_BUFFER_LEN];
_snprintf(szQry, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::NewAdminAck, szAccount);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
ERRLOG2(g_Log, "쿼리 실패 - query : %s, err : %s",
szQry, CDBAdminTool::GetInstance().GetErrorString());
}
else
{
ZeroMemory(&GetList, sizeof(AdminList));
if (CDBAdminTool::GetInstance().GetData(&GetList))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktAdminListAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktAdminListAck* lpPktAdminListAck =
reinterpret_cast<PktAdminMgr::PktAdminListAck*>(lpBuffer->begin());
strncpy(lpPktAdminListAck->m_szAccount, GetList.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpPktAdminListAck->m_szName, GetList.m_szName, PktAdminMgr::MAX_NAME);
strncpy(lpPktAdminListAck->m_szIP, GetList.m_szIP, PktAdminMgr::MAX_IP);
strncpy(lpPktAdminListAck->m_szDate, GetList.m_szDate, PktAdminMgr::MAX_DATE);
lpPktAdminListAck->m_szLevel = GetList.m_szLevel[0];
ZeroMemory(&GetList, sizeof(AdminList));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAdminListAck), PktAdminMgr::PktCMD::PktNewAdmin, 0, 0 ))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
// 선택계정의 로그리스트를 보낸다.
bool CRylAdminMgrDispatch::PktLogList(PktBase* lpPktBase)
{
#pragma pack(1)
struct TblLog
{
int LogID;
char Login[20];
char Logout[20];
char UseIP[16];
};
#pragma pack()
PktAdminMgr::PktLogList* lpPktLogList = static_cast<PktAdminMgr::PktLogList*>(lpPktBase);
int UID = CDBAdminTool::GetInstance().GetMyUID(lpPktLogList->m_szAccount);
TblLog LogList;
char szQry[CDBAdminTool::QUERY_BUFFER_LEN];
CCumulateBuffer cBuffer(8192, &GetSession());
if(0 != UID)
{
ZeroMemory(&LogList, sizeof(LogList));
_snprintf(szQry, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::LoginList, UID);
if(CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
while(CDBAdminTool::GetInstance().GetData(&LogList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktLogListAck));
PktAdminMgr::PktLogListAck* lpLogAck = reinterpret_cast<PktAdminMgr::PktLogListAck*>(lpBuffer);
if(lpBuffer)
{
lpLogAck->m_LogID = LogList.LogID;
strncpy(lpLogAck->m_Login, LogList.Login, sizeof(LogList.Login));
strncpy(lpLogAck->m_Logout, LogList.Logout, sizeof(LogList.Logout));
strncpy(lpLogAck->m_UseIP, LogList.UseIP, sizeof(LogList.UseIP));
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktLogListAck), PktAdminMgr::PktCMD::PktLogListAck, 0, 0);
ZeroMemory(&LogList, sizeof(LogList));
}
}
}
}
return true;
}
// 관리서버셋업 파일의 중계서버 정보를 클라이언트로 보내기
bool CRylAdminMgrDispatch::SendAgentServerInfo()
{
char szKey[255];
for(unsigned long dwIndex = 0; dwIndex < CAgentServerTable::MAX_AGENT_SERVER; ++dwIndex)
{
_snprintf(szKey, 255, "SERVERGROUP_NAME_%02u", dwIndex);
const char* szGroupName = CServerInfo::GetInstance().GetValue(szKey);
if (NULL != szGroupName)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktAgentServerIndex));
PktAdminMgr::PktAgentServerIndex* lpPktAgentIndex =
reinterpret_cast<PktAdminMgr::PktAgentServerIndex*>(lpBuffer->begin());
lpPktAgentIndex->m_ServerGroup = (unsigned char)dwIndex;
strncpy(lpPktAgentIndex->m_szServerName, szGroupName, PktAdminMgr::MAX_ACCOUNT);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAgentServerIndex), PktAdminMgr::PktCMD::PktAgentServerIndex, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
// 상세 로그 리스트 보내기
bool CRylAdminMgrDispatch::PktDetailLog(PktBase* lpPktBase)
{
#pragma pack(1)
struct TblDetail
{
unsigned int DetailLogID;
char UpdateDate[20];
unsigned int UpdateType;
};
#pragma pack()
TblDetail TblList;
PktAdminMgr::PktDetailLog* lpPktDetailLog = static_cast<PktAdminMgr::PktDetailLog*>(lpPktBase);
CCumulateBuffer cBuffer(8129, &GetSession());
char* lpBuffer;
char szQry[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQry, CDBAdminTool::MAX_QUERY_LENGTH, QUERYZ::DetailLog, lpPktDetailLog->m_LogID);
// 상세로그 리스트를 보낸다.
if(CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
ZeroMemory(&TblList, sizeof(TblList));
while(CDBAdminTool::GetInstance().GetData(&TblList))
{
lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktDetailLogAck));
PktAdminMgr::PktDetailLogAck* lpPktDetailLogAck =
reinterpret_cast<PktAdminMgr::PktDetailLogAck*>(lpBuffer);
if(NULL != lpBuffer)
{
lpPktDetailLogAck->m_DetailLogID = TblList.DetailLogID;
lpPktDetailLogAck->m_UpdateType = TblList.UpdateType;
strncpy(lpPktDetailLogAck->m_UpdateDate, TblList.UpdateDate, 20);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktDetailLogAck), PktAdminMgr::PktCMD::PktDetailLogAck, 0, 0);
ZeroMemory(&TblList, sizeof(TblList));
}
}
}
// 사용사유도 같이 낑겨서 보내자 ㅡ.ㅡ
char szExitLog[100];
_snprintf(szQry, CDBAdminTool::MAX_QUERY_LENGTH, QUERYZ::ExitLog, lpPktDetailLog->m_LogID);
if(CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
ZeroMemory(&szExitLog, sizeof(szExitLog));
if(CDBAdminTool::GetInstance().GetData(&szExitLog))
{
lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktGetExitLogAck));
PktAdminMgr::PktGetExitLogAck* lpExitLogAck =
reinterpret_cast<PktAdminMgr::PktGetExitLogAck*>(lpBuffer);
strncpy(lpExitLogAck->m_szExitLog, szExitLog, sizeof(szExitLog));
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktGetExitLogAck), PktAdminMgr::PktCMD::PktGetExitLogAck, 0, 0);
}
}
return true;
}
// 현재 등록 되어있는 툴 운영자 목록을 요청
bool CRylAdminMgrDispatch::PktAdminList(PktBase* lpPktBase)
{
#pragma pack(1)
struct AdminList
{
char m_szAccount[PktAdminMgr::MAX_ACCOUNT];
char m_szName[PktAdminMgr::MAX_NAME];
char m_szIP[PktAdminMgr::MAX_IP];
char m_szDate[PktAdminMgr::MAX_DATE];
char m_szLevel[2];
};
#pragma pack()
AdminList GetList;
char szQry[CDBAdminTool::QUERY_BUFFER_LEN];
_snprintf(szQry, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::AdminList);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQry))
{
ERRLOG2(g_Log, "쿼리에 실패했습니다. 쿼리 문자열 : %s, 에러 : %s",
szQry, CDBAdminTool::GetInstance().GetErrorString());
}
else
{
ZeroMemory(&GetList, sizeof(AdminList));
while(CDBAdminTool::GetInstance().GetData(&GetList))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktAdminListAck));
PktAdminMgr::PktAdminListAck* lpPktAdminListAck =
reinterpret_cast<PktAdminMgr::PktAdminListAck*>(lpBuffer->begin());
strncpy(lpPktAdminListAck->m_szAccount, GetList.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpPktAdminListAck->m_szName, GetList.m_szName, PktAdminMgr::MAX_NAME);
strncpy(lpPktAdminListAck->m_szIP, GetList.m_szIP, PktAdminMgr::MAX_IP);
strncpy(lpPktAdminListAck->m_szDate, GetList.m_szDate, PktAdminMgr::MAX_DATE);
lpPktAdminListAck->m_szLevel = GetList.m_szLevel[0];
ZeroMemory(&GetList, sizeof(AdminList));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAdminListAck), PktAdminMgr::PktCMD::PktAdminListAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
// 삭제된 캐릭터 목록을 가져온다.
bool CRylAdminMgrDispatch::PktDelCharList(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_DelCharList
{
unsigned long m_dwCID;
unsigned long m_dwUID;
unsigned char m_cNewServerGroupID;
unsigned char m_cOldServerGroupID;
char m_szInsertTime[PktAdminMgr::MAX_TIME];
char m_szDeleteTime[PktAdminMgr::MAX_TIME];
char m_szCharName[PktAdminMgr::PktDelCharListAck::MAX_NAME];
unsigned int m_nLevel;
unsigned long m_dwGold;
};
#pragma pack()
bool bExistData = false;
PktAdminMgr::PktDelCharList* lpPktDelCharList = static_cast< PktAdminMgr::PktDelCharList*>(lpPktBase);
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szSearchKey[10];
if(lpPktDelCharList->m_cType == PktAdminMgr::PktDelCharList::UID) // UID 검색
{
_snprintf(szSearchKey, sizeof(szSearchKey), "intUID");
}
else // CID 검색
{
_snprintf(szSearchKey, sizeof(szSearchKey), "intCID");
}
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetDelHistory,
szSearchKey, lpPktDelCharList->m_dwValue, lpPktDelCharList->m_dwServerGroup);
In_DelCharList In_CharList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktDelCharList->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&In_CharList, sizeof(In_DelCharList));
if(lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(In_DelCharList) * 50, &GetSession());
while(lpGameDB->GetData(&In_CharList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktDelCharListAck));
PktAdminMgr::PktDelCharListAck* lpPktAck =
reinterpret_cast< PktAdminMgr::PktDelCharListAck*>(lpBuffer);
lpPktAck->m_dwUID = In_CharList.m_dwUID;
lpPktAck->m_dwCID = In_CharList.m_dwCID;
lpPktAck->m_cNewServerGroupID = In_CharList.m_cNewServerGroupID;
lpPktAck->m_cOldServerGroupID = In_CharList.m_cOldServerGroupID;
strncpy(lpPktAck->m_szInsertTime, In_CharList.m_szInsertTime,
PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szDeleteTime, In_CharList.m_szDeleteTime,
PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szCharName, In_CharList.m_szCharName,
PktAdminMgr::PktDelCharListAck::MAX_NAME);
lpPktAck->m_nLevel = In_CharList.m_nLevel;
lpPktAck->m_dwGold = In_CharList.m_dwGold;
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktDelCharListAck), PktAdminMgr::PktCMD::PktDelCharListAck, 0, 0);
ZeroMemory(&In_CharList, sizeof(In_DelCharList));
bExistData = true;
}
}
}
if(!bExistData)
{
SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
// 지워진 캐릭터 복구..
bool CRylAdminMgrDispatch::PktCharRestore(PktBase* lpPktBase)
{
PktAdminMgr::PktCharRestore* lpPktCharRestore = static_cast<PktAdminMgr::PktCharRestore*>(lpPktBase);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktCharRestore->m_dwServerGroup);
if (NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB를 얻는데 실패했습니다. 그룹-%u", lpPktCharRestore->m_dwServerGroup);
return true;
}
CGameDB::In_UserInfo stUserInfo;
if (false == lpGameDB->UIDbyUserInfo(lpPktCharRestore->m_dwUID,
m_nAgentType, (unsigned int)lpPktCharRestore->m_cOldServerGroupID, &stUserInfo))
{
ERRLOG1(g_Log, "UserInfo 얻기 실패 - UID: %u", lpPktCharRestore->m_dwUID);
return true;
}
// 비어있는 슬롯 체크
char szEmptyCol[20];
ZeroMemory(szEmptyCol, sizeof(szEmptyCol));
if (0 == stUserInfo.Char1)
{
_snprintf(szEmptyCol, sizeof(szEmptyCol), "Char1");
}
else if(0 == stUserInfo.Char2)
{
_snprintf(szEmptyCol, sizeof(szEmptyCol), "Char2");
}
else if(0 == stUserInfo.Char3)
{
_snprintf(szEmptyCol, sizeof(szEmptyCol), "Char3");
}
else if(0 == stUserInfo.Char4)
{
_snprintf(szEmptyCol, sizeof(szEmptyCol), "Char4");
}
else if(0 == stUserInfo.Char5)
{
_snprintf(szEmptyCol, sizeof(szEmptyCol), "Char5");
}
if (NULL == *szEmptyCol)
{
// 비어있는 캐릭터 슬롯이 없음.
SendResult(PktAdminMgr::PktResult::Err_NotUserInfoSlot);
return true;
}
char szName[20];
ZeroMemory(szName, sizeof(szName));
if (false == lpGameDB->CIDByCharacterName(lpPktCharRestore->m_dwCID, &szName))
{
// 캐릭터 정보가 존재 하지 않음.
SendResult(PktAdminMgr::PktResult::Err_NotCharacterInfo);
return true;
}
// 빈 슬롯도 있고 캐릭터도 존재하면 UserInfo 슬롯에 업데이트
char szQuery[CGameDB::MAX_QUERY_LENGTH];
if (NULL != *szName)
{
_snprintf(szQuery, CGameDB::MAX_QUERY_LENGTH,
"SELECT intCID FROM TblCharDelHistory "
"WHERE intUID = %d AND intCID = %d AND NewServerGroupID = %d AND OldServerGroupID = %d",
lpPktCharRestore->m_dwUID, lpPktCharRestore->m_dwCID,
lpPktCharRestore->m_cNewServerGroupID, lpPktCharRestore->m_cOldServerGroupID);
if (true == lpGameDB->ExecuteQuery(szQuery))
{
// TblCharDelHistory에 해당 UID, CID가 존재하면 복구.
int intCID = 0;
if (true == lpGameDB->GetData(&intCID))
{
_snprintf(szQuery, CGameDB::MAX_QUERY_LENGTH,
"UPDATE UserInfo SET %s = %d WHERE UID = %d AND OldServerGroupID = %d",
szEmptyCol, lpPktCharRestore->m_dwCID, lpPktCharRestore->m_dwUID,
lpPktCharRestore->m_cOldServerGroupID);
if (true == lpGameDB->ExecuteQuery(szQuery))
{
_snprintf(szQuery, CGameDB::MAX_QUERY_LENGTH,
"DELETE TblCharDelHistory "
"WHERE intUID = %d AND intCID = %d AND NewServerGroupID = %d AND OldServerGroupID = %d",
lpPktCharRestore->m_dwUID, lpPktCharRestore->m_dwCID,
lpPktCharRestore->m_cNewServerGroupID, lpPktCharRestore->m_cOldServerGroupID);
if (true == lpGameDB->ExecuteQuery(szQuery))
{
char* szCharName[20];
if (false == lpGameDB->CIDByCharacterName(lpPktCharRestore->m_dwCID, szCharName))
{
ERRLOG1(g_Log, "캐릭터명 얻기 실패. CID - %u", lpPktCharRestore->m_dwCID);
return true;
}
_snprintf(szQuery, CGameDB::MAX_QUERY_LENGTH,
"INSERT INTO TblUnifiedCharList (UID, OldServerGroupID, BeforeCID, NewCID, BeforeCharName) "
"VALUES (%u, %d, 0, %u, '%s')",
lpPktCharRestore->m_dwUID, lpPktCharRestore->m_cOldServerGroupID,
lpPktCharRestore->m_dwCID, szCharName);
if (true == lpGameDB->ExecuteQuery(szQuery))
{
m_DetailLog.SetBefore("Not exist contents");
m_DetailLog.SetAfter("[Character Restore]"
"\r\nUID: %u\r\nCID: \r\nNewServerGroupID: %d\r\nOldServerGroupID: %d",
lpPktCharRestore->m_dwUID, lpPktCharRestore->m_dwCID,
lpPktCharRestore->m_cNewServerGroupID, lpPktCharRestore->m_cOldServerGroupID);
m_DetailLog.InsertLog(m_MyLogID);
// 캐릭터 복구 성공!
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktCharRestoreAck));
PktAdminMgr::PktCharRestoreAck* lpPktCharAck =
reinterpret_cast<PktAdminMgr::PktCharRestoreAck*>(lpBuffer->begin());
lpPktCharAck->m_dwUID = lpPktCharRestore->m_dwUID;
lpPktCharAck->m_dwCID = lpPktCharRestore->m_dwCID;
lpPktCharAck->m_cNewServerGroupID = lpPktCharRestore->m_cNewServerGroupID;
lpPktCharAck->m_cOldServerGroupID = lpPktCharRestore->m_cOldServerGroupID;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktCharRestoreAck), PktAdminMgr::PktCMD::PktCharRestoreAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
SendResult(PktAdminMgr::PktResult::Success_CharacterRestore);
}
else
{
ERRLOG2(g_Log, "캐릭터 복구 후 TblUnifiedCharList에 정보 삽입 실패,%s-%s",
szQuery, lpGameDB->GetErrorString());
return true;
}
}
}
else
{
ERRLOG1(g_Log, "캐릭터 복구 후 TblCharDelhistory에서 삭제 실패. 쿼리- %s", szQuery);
return true;
}
}
}
}
return true;
}
// 관리자 계정 삭제
bool CRylAdminMgrDispatch::PktDelAdmin( PktBase* lpPktBase )
{
PktAdminMgr::PktDelAdmin* lpPktDelAdmin = static_cast<PktAdminMgr::PktDelAdmin*>(lpPktBase);
if (!CDBAdminTool::GetInstance().DelAdmin(lpPktDelAdmin->m_szAccount))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktResultAck* lpPktResult =
reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer);
lpPktResult->m_Result = PktAdminMgr::PktResult::Err_DelAdmin;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
PktDelAdminAck(lpPktDelAdmin->m_szAccount);
}
return true;
}
// 계정삭제가 성공했으면 Ack
bool CRylAdminMgrDispatch::PktDelAdminAck(char* szAccount)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktDelAdmin));
PktAdminMgr::PktDelAdmin* lpDelAdminAck = reinterpret_cast<PktAdminMgr::PktDelAdmin*>(lpBuffer->begin());
strncpy(lpDelAdminAck->m_szAccount, szAccount, PktAdminMgr::MAX_ACCOUNT);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktDelAdmin), PktAdminMgr::PktCMD::PktDelAdminAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 툴 계정 레벨변경
bool CRylAdminMgrDispatch::PktUpdateLev(PktBase* lpPktBase)
{
PktAdminMgr::PktUpdateLevel* lpPktLevel = static_cast<PktAdminMgr::PktUpdateLevel*>(lpPktBase);
// DEVELOPER 권한만이 DEVELOPER, MASTER로 레벨 변경 할 수 있음
unsigned char cTempRights = SetAuthorityMask(lpPktLevel->m_szLevel);
if(cTempRights == PktAdminMgr::AuthorityMask::DEVELOPER
|| cTempRights == PktAdminMgr::AuthorityMask::MASTER)
{
if(!(m_MyAuthority & PktAdminMgr::AuthorityMask::DEVELOPER))
{
SendResult(PktAdminMgr::PktResult::Err_Authority);
return true;
}
}
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktResultAck* lpResult = reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
if(!CDBAdminTool::GetInstance().UpdateLevel(lpPktLevel))
{
lpResult->m_Result = PktAdminMgr::PktResult::Err_UpdateLevel;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
PktUpdateLevAck(lpPktLevel->m_szAccount, lpPktLevel->m_szLevel);
}
return true;
}
// 계정 레벨변경의 성공했으면.. 보낸다.
bool CRylAdminMgrDispatch::PktUpdateLevAck(char* szAccount, unsigned char Level)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktUpdateLevel));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
PktAdminMgr::PktUpdateLevel* lpPktLevelAck = reinterpret_cast<PktAdminMgr::PktUpdateLevel*>(lpBuffer->begin());
strncpy(lpPktLevelAck->m_szAccount, szAccount, PktAdminMgr::MAX_ACCOUNT);
lpPktLevelAck->m_szLevel = Level;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktUpdateLevel), PktAdminMgr::PktCMD::PktUpdateLevelAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// Exit Log 사용사유를 남기고 클라이언트는 종료된다.
bool CRylAdminMgrDispatch::PktLogUseMessage(PktBase* lpPktBase)
{
PktAdminMgr::PktLogUseMessage* lpPktExitLog = static_cast<PktAdminMgr::PktLogUseMessage*>(lpPktBase);
if(!CDBAdminTool::GetInstance().UpdateExitLog(m_MyLogID, lpPktExitLog->m_UseMessage))
{
ERRLOG0(g_Log, "사용 사유 남기기 실패");
return true;
}
return true;
}
// 관리자 접속IP 변경
bool CRylAdminMgrDispatch::PktUpdateIP(PktBase* lpPktBase)
{
PktAdminMgr::PktUpdateIP* lpPktIP = static_cast<PktAdminMgr::PktUpdateIP*>(lpPktBase);
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpResult = reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
if (!CDBAdminTool::GetInstance().UpdateIP(lpPktIP))
{
lpResult->m_Result = PktAdminMgr::PktResult::Err_UpdateIP;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
PktUpdateIPAck(lpPktIP->m_szAccount, lpPktIP->m_szIP);
}
return true;
}
// IP변경이 성공했으면
bool CRylAdminMgrDispatch::PktUpdateIPAck(char* szAccount, char* szIP)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktUpdateIP));
PktAdminMgr::PktUpdateIP* lpPktUpdateIPAck = reinterpret_cast<PktAdminMgr::PktUpdateIP*>(lpBuffer->begin());
strncpy(lpPktUpdateIPAck->m_szAccount, szAccount, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpPktUpdateIPAck->m_szIP, szIP, PktAdminMgr::MAX_IP);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktUpdateIP), PktAdminMgr::PktCMD::PktUpdateIPAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 관리자 패스워드 변경
bool CRylAdminMgrDispatch::PktUpdatePasswd(PktBase* lpPktBase)
{
PktAdminMgr::PktUpdatePasswd* lpPktPasswd = static_cast<PktAdminMgr::PktUpdatePasswd*>(lpPktBase);
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck));
PktAdminMgr::PktResultAck* lpResult = reinterpret_cast<PktAdminMgr::PktResultAck*>(lpBuffer->begin());
if (!CDBAdminTool::GetInstance().UpdatePasswd(lpPktPasswd))
{
lpResult->m_Result = PktAdminMgr::PktResult::Err_UpdatePasswd;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktResultAck), PktAdminMgr::PktCMD::PktResultAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
return true;
}
CBuffer* CRylAdminMgrDispatch::MakeRemoveItemAck(unsigned long dwRequestKey, unsigned long dwCID,
unsigned __int64 ItemID, unsigned short PrototypeID,
PktAdminMgr::PktRemoveItem* lpRemoveItem)
{
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktRemoveItemAck));
PktAdminMgr::PktRemoveItemAck* lpRemoveItemAck =
reinterpret_cast<PktAdminMgr::PktRemoveItemAck*>(lpBuffer->begin());
CopyMemory(lpRemoveItemAck, lpRemoveItem, sizeof(PktAdminMgr::PktRemoveItemAck));
lpRemoveItemAck->m_dwCID = dwCID;
lpRemoveItemAck->m_ItemUID = ItemID;
lpRemoveItemAck->m_ItemPrototypeID = PrototypeID;
lpRemoveItemAck->m_dwRequestKey = dwRequestKey;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktRemoveItemAck), PktAdminMgr::PktCMD::PktRemoveItemAck, 0, 0))
{
SAFE_RELEASE_BUFFER(lpBuffer);
return NULL;
}
return lpBuffer;
}
// 각종 아이템 컨테이터 리셋
bool CRylAdminMgrDispatch::PktItemReset(PktBase* lpPktBase)
{
PktAdminMgr::PktItemReset* lpItemReset =
static_cast<PktAdminMgr::PktItemReset*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpItemReset->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpItemReset->m_dwCID);
if(NULL == lpCharacter)
{
ERRLOG0(g_Log, "캐릭터 세션 얻기 실패");
return true;
}
if(lpItemReset->m_cTakePos != TakeType::TS_DEPOSIT)
{
switch(lpItemReset->m_cTakePos)
{
case TakeType::TS_INVEN:
lpCharacter->GetInventory().ClearItems(); break; // 인벤토리
case TakeType::TS_EQUIP:
lpCharacter->GetEquipments().ClearItems(); break; // 장비
case TakeType::TS_TEMPINVEN:
lpCharacter->GetTempInven().ClearItems(); break; // 임시 인벤토리
case TakeType::TS_EXTRA:
lpCharacter->GetExtra().ClearItems(); break; // 기타 위치(대장장이, 옵션이식, 보상판매)
}
lpCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
CBuffer* lpBuffer =
MakeItemResetAck(lpCharacter->GetClientKey(), lpCharacter->GetCID(), lpItemReset);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
if(false == DepositCheckIt(
lpAgentDispatch->GetDepositLock(), lpItemReset->m_dwUID, lpItemReset->m_dwCID))
{
SendResult(PktAdminMgr::PktResult::Err_NotUseDeposit);
return true;
}
lpCharacter->OnChangedInfo(CModifyCharacter::ON_STROE12);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_STORE34);
CModifyCharacterMgr& CharMgr = lpAgentDispatch->GetModifyCharacterMgr();
CModifyCharacterMgr::iterator Pos = CharMgr.begin();
for(;Pos != CharMgr.end(); ++Pos)
{
CModifyCharacter* lpModifyCharacter = Pos->second;
if(NULL != (lpModifyCharacter->GetCheckSession(lpItemReset->m_dwUID)))
{
Item::CDepositContainer& Deposit = lpModifyCharacter->GetDeposit();
for(int TabNum = 0; TabNum < Deposit.GetMaxTabNum(); ++TabNum)
{
Item::CItemContainer* lpDepositTab = Deposit.GetTab(TabNum);
lpDepositTab->ClearItems();
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Character ItemInfo Clear]\r\nUID: %u\r\nCID: %u\r\nServerGroup: %u"
"\r\nTakePos: %c",
lpItemReset->m_dwUID, lpItemReset->m_dwCID,
lpItemReset->m_dwServerGroup, lpItemReset->m_cTakePos);
m_DetailLog.InsertLog(m_MyLogID);
}
CBuffer* lpBuffer =
MakeItemResetAck(lpModifyCharacter->GetClientKey(), lpModifyCharacter->GetCID(), lpItemReset);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
}
return true;
}
// 아이템 수정정보 Ack
CBuffer* CRylAdminMgrDispatch::MakeUpdateItemAck(unsigned long dwRequestKey, unsigned long dwCID,
unsigned __int64 dwItemID, unsigned short PrototypeID,
PktAdminMgr::PktUpdateItem* lpUpdateItem)
{
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktUpdateItemAck));
PktAdminMgr::PktUpdateItemAck* lpUpdateItemAck =
reinterpret_cast<PktAdminMgr::PktUpdateItemAck*>(lpBuffer->begin());
lpUpdateItemAck->m_dwUID = lpUpdateItem->m_dwUID;
lpUpdateItemAck->m_dwCID = dwCID;
lpUpdateItemAck->m_dwRequestKey = dwRequestKey;
lpUpdateItemAck->m_dwServerGroup = lpUpdateItem->m_dwServerGroup;
lpUpdateItemAck->m_ItemUID = dwItemID;
lpUpdateItemAck->m_ItemPrototypeID = PrototypeID;
CopyMemory(&lpUpdateItemAck->m_UpdataItemInfo, &lpUpdateItem->m_UpdataItemInfo,
sizeof(PktAdminMgr::CreateItemInfo));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktUpdateItemAck), PktAdminMgr::PktCMD::PktUpdateItemAck, 0, 0))
{
SAFE_RELEASE_BUFFER(lpBuffer);
return NULL;
}
return lpBuffer;
}
// 창고 독점권한및 획득 체크~~
bool CRylAdminMgrDispatch::DepositCheckIt( ItemData::CDepositLock& DepositLock, unsigned long dwUID, unsigned long dwCID )
{
bool isLock;
// 현재 다른사용자가 사용하고 있으면
if( !DepositLock.isUse( dwUID, dwCID, this, isLock ) )
{
// 리턴결과가 검색실패인지 창고가 락이 걸려있는지 판별
// isLock이 false면 검색실패닷 내가 사용해버리자..
if( !isLock )
{
// 창고독점권을 아무도 가지고 있지 않다 내소유로 만들어버리자..
DepositLock.DepositLock( dwUID, dwCID, this );
return true;
}
}
else
{
// 창고 독접권이 내 소유닷~~
return true;
}
return false;
}
// 아이템 생성
bool CRylAdminMgrDispatch::PktCreateItem(PktBase* lpPktBase)
{
PktAdminMgr::PktCreateItem* lpPktCreateItem = static_cast<PktAdminMgr::PktCreateItem*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktCreateItem->m_dwServerGroup);
if (NULL == lpAgentDispatch)
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
PktAdminMgr::CreateItemInfo& CreateItem = lpPktCreateItem->m_CreateItemInfo;
CreateItem.m_szItemName[PktAdminMgr::MAX_ITEM_NAME - 1] = 0;
const Item::ItemInfo* lpItemInfo =
Item::CItemMgr::GetInstance().GetItemInfoFromItemName(CreateItem.m_szItemName);
const unsigned long dwUID = lpPktCreateItem->m_dwUID;
const unsigned long dwCID = lpPktCreateItem->m_dwCID;
ItemData::CDepositLock& DepositLock = lpAgentDispatch->GetDepositLock();
CModifyCharacter* lpModifyCharacter = lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(dwCID);
if ((NULL == lpItemInfo) || (NULL == lpModifyCharacter))
{
SendResult(PktAdminMgr::PktResult::Err_CreateItem1);
return true;
}
else
{
if (CreateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
if (false == DepositCheckIt(lpAgentDispatch->GetDepositLock(), dwUID, dwCID))
{
SendResult(PktAdminMgr::PktResult::Err_NotUseDeposit);
return true;
}
}
Item::CItem* lpItem =
Item::CItemFactory::GetInstance().CreateItem(lpItemInfo->m_usProtoTypeID);
if (NULL == lpItem)
{
SendResult(PktAdminMgr::PktResult::Err_CreateItem2);
}
else
{
lpItem->SetNumOrDurability(CreateItem.m_cNumOrDurability);
Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);
if (NULL != lpEquipment)
{
// 아이템 장비 및 속성 데이터 변경
CModifyEquipment* lpModifyEquipment = static_cast<CModifyEquipment*>(lpEquipment);
lpModifyEquipment->AdjustData(CreateItem);
}
Item::ItemPos ItemPos = ItemData::MakeItemPos(
CreateItem.m_cTakePos, CreateItem.m_cXPos, CreateItem.m_cYPos, CreateItem.m_cZPos);
lpModifyCharacter->GetInventory().SetAdminTool();
if (false == lpModifyCharacter->SetItem(ItemPos, lpItem))
{
SendResult(PktAdminMgr::PktResult::Err_CreateItem3);
return true;
}
if (CreateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
if ((CreateItem.m_cZPos == 0) || (CreateItem.m_cZPos == 1)) // 창고 1,2 탭정보를 변경했음
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STROE12);
}
else if ((CreateItem.m_cZPos == 2) || (CreateItem.m_cZPos == 3)) // 창고 3,4 탭정보를 변경했음
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STORE34);
}
}
else
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC); // 인벤토리 정보를 변경했음
}
// 사용내역 기록
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter(
"[Item Create]\r\nUID: %u\r\nCID : %d\r\nServerGroup : %d\r\nPosition : %s\r\n"
"PrototypeID : %d\r\nItemUID : 0x%016I64X\r\nName : %s\r\nX:%d Y:%d Z:%d",
lpPktCreateItem->m_dwUID, lpModifyCharacter->GetCID(), lpModifyCharacter->GetServerGroup(),
GetItemState(CreateItem.m_cTakePos), lpItemInfo->m_usProtoTypeID, lpItem->GetUID(),
lpItemInfo->m_SpriteData.m_szName, ItemPos.GetXIndex(), ItemPos.GetYIndex(), ItemPos.GetZIndex());
// 같은 UID의 캐릭터의 정보를 열람중인 다른 사용자에게 새 창고 정보 전송.
if(CreateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
CModifyCharacterMgr& CharMgr = lpAgentDispatch->GetModifyCharacterMgr();
CModifyCharacterMgr::iterator Pos = CharMgr.begin();
for(;Pos != CharMgr.end(); ++Pos)
{
CModifyCharacter* lpCharacter = Pos->second;
CSession* lpSession = lpCharacter->GetCheckSession(dwUID);
if((NULL != lpSession) && (dwCID != lpCharacter->GetCID()))
{
Item::CItem* lpCloneItem = ItemData::CloneItem(lpItem, CreateItem);
if(NULL != lpCloneItem)
{
if(lpCharacter->SetItem(ItemPos, lpCloneItem))
{
CBuffer* lpBuffer =
MakeCreateItemAck(lpCharacter->GetClientKey(), lpCharacter->GetCID(),
lpCloneItem->GetUID(), lpCloneItem->GetPrototypeID(), lpPktCreateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
ERRLOG0(g_Log, "복사 아이템 장착이 실패했습니다.");
return true;
}
}
else
{
ERRLOG0(g_Log, "복사 아이템 생성을 실패했습니다.");
return true;
}
}
}
CBuffer* lpBuffer = MakeCreateItemAck(lpPktCreateItem->m_dwRequestKey,
dwCID, lpItem->GetUID(), lpItem->GetPrototypeID(), lpPktCreateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
CBuffer* lpBuffer = MakeCreateItemAck(lpPktCreateItem->m_dwRequestKey,
dwCID, lpItem->GetUID(), lpItem->GetPrototypeID(), lpPktCreateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
}
m_DetailLog.InsertLog(m_MyLogID);
return true;
}
// 인벤토리, 장비, 창고등등의 모든 아이템데이터를 변경한다 cTakePos로 판별
bool CRylAdminMgrDispatch::PktUpdateItem(PktBase* lpPktBase)
{
PktAdminMgr::PktUpdateItem* lpPktUpdateItem = static_cast<PktAdminMgr::PktUpdateItem*>(lpPktBase);
PktAdminMgr::CreateItemInfo& UpdateItem = lpPktUpdateItem->m_UpdataItemInfo;
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktUpdateItem->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
return true;
}
const unsigned long dwUID = lpPktUpdateItem->m_dwUID;
const unsigned long dwCID = lpPktUpdateItem->m_dwCID;
ItemData::CDepositLock& DepositLock = lpAgentDispatch->GetDepositLock();
CModifyCharacter* lpModifyCharacter = lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(dwCID);
if(NULL != lpModifyCharacter)
{
if(UpdateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
if(!DepositCheckIt(lpAgentDispatch->GetDepositLock(), dwUID, dwCID))
{
// 창고 독점권 획득 실패 혹은 접근불가
SendResult(PktAdminMgr::PktResult::Err_NotUseDeposit); // 창고 정보 변경 불가
return true;
}
}
Item::ItemPos ItemPos =
ItemData::MakeItemPos(UpdateItem.m_cTakePos, UpdateItem.m_cXPos, UpdateItem.m_cYPos, UpdateItem.m_cZPos);
Item::CItem* lpItem = lpModifyCharacter->GetItem(ItemPos);
if(NULL != lpItem)
{
unsigned short uPrototypeID = lpPktUpdateItem->m_ItemPrototypeID;
unsigned __int64 ItemUID = lpPktUpdateItem->m_ItemUID;
// 안전빵으로 ItemprototypeID, ItemUID를 한번더 비교해보자. ㅡ.ㅡ;
if((uPrototypeID == lpItem->GetPrototypeID()) && (ItemUID == lpItem->GetUID()))
{
lpItem->SetNumOrDurability(UpdateItem.m_cNumOrDurability); // 현재 내구도 또는 개수 셋팅
Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpItem);
if(NULL != lpEquipment)
{
CModifyEquipment* lpEquip = static_cast<CModifyEquipment*>(lpEquipment);
if (NULL != lpEquip)
{
lpEquip->AdjustData(UpdateItem);
}
}
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Item Attribute Edit]\r\nUID: %u\r\nCID : %d\r\nServerGroup : %d\r\nPosition : %s\r\nPrototypeID : %d\r\nItemUID : 0x%016I64X\r\nName : %s\r\nX:%d Y:%d Z:%d",
lpPktUpdateItem->m_dwUID, lpModifyCharacter->GetCID(), lpModifyCharacter->GetServerGroup(), GetItemState(UpdateItem.m_cTakePos),
lpItem->GetItemInfo().m_usProtoTypeID, lpItem->GetUID(), lpItem->GetItemInfo().m_SpriteData.m_szName,
ItemPos.GetXIndex(), ItemPos.GetYIndex(), ItemPos.GetZIndex());
m_DetailLog.InsertLog(m_MyLogID);
// 아이템 정보변경 성공
// 캐릭터 데이터 수정을 체크 ------------------------------------------------------------------------
if(UpdateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
if((UpdateItem.m_cZPos == 0) || (UpdateItem.m_cZPos == 1)) // 창고 1,2 탭정보를 변경
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STROE12);
else if((UpdateItem.m_cZPos == 2) || (UpdateItem.m_cZPos == 3)) // 창고 3,4 탭정보를 변경
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STORE34);
}
else
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
}
//-------------------------------------------------------------------------------------------------------
// UpdateItem Ack를 클라이언트에게 보내자..
if(UpdateItem.m_cTakePos == TakeType::TS_DEPOSIT)
{
CModifyCharacterMgr& CharMgr = lpAgentDispatch->GetModifyCharacterMgr();
CModifyCharacterMgr::iterator Pos = CharMgr.begin();
for(;Pos != CharMgr.end(); ++Pos)
{
CModifyCharacter* lpCharacter = Pos->second;
CSession* lpSession = lpCharacter->GetCheckSession(dwUID);
if((NULL != lpSession) && (dwCID != lpCharacter->GetCID()))
{
Item::CItem* lpCloneItem = lpCharacter->GetItem(ItemPos);
if(NULL != lpCloneItem)
{
if(lpCharacter->RemoveItem(ItemPos))
{
DELETE_ITEM(lpCloneItem);
lpCloneItem = ItemData::CloneItem( lpItem, UpdateItem );
if( NULL != lpCloneItem )
{
if( !lpCharacter->SetItem( ItemPos, lpCloneItem ) )
{
CBuffer* lpBuffer =
MakeUpdateItemAck(lpCharacter->GetClientKey(),
lpCharacter->GetCID(), lpItem->GetUID(), lpItem->GetPrototypeID(),
lpPktUpdateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
ERRLOG0(g_Log, "복사 아이템 장착이 실패했습니다." );
}
}
else
{
ERRLOG0(g_Log, "복사 아이템 생성을 실패했습니다." );
}
}
else
{
ERRLOG0(g_Log, "복사아이템을 장착하기 위해 기존아이템을 지우는데 실패했습니다." );
}
}
else
{
ERRLOG0(g_Log, "UID간 창고 아이템 동기화가 정확하지 않습니다. (아이템을 찾을수 없습니다.)");
}
}
}
CBuffer* lpBuffer = MakeUpdateItemAck(lpPktUpdateItem->m_dwRequestKey,
lpPktUpdateItem->m_dwCID, lpItem->GetUID(), lpItem->GetPrototypeID(), lpPktUpdateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
CBuffer* lpBuffer = MakeUpdateItemAck(lpPktUpdateItem->m_dwRequestKey,
lpPktUpdateItem->m_dwCID, lpItem->GetUID(), lpItem->GetPrototypeID(), lpPktUpdateItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "Ack 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
else
{
// 아이템 식별번호가 일치하지 안습니다.
SendResult(PktAdminMgr::PktResult::Err_Invalid_ItemID);
}
}
else
{
//아이템이 존재 하지 안는다
SendResult(PktAdminMgr::PktResult::Err_Invalid_Item);
}
}
else
{
// 캐릭터가 존재하지 않는다.
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
}
return true;
}
// 아이템 삭제
bool CRylAdminMgrDispatch::PktRemoveItem(PktBase* lpPktBase)
{
PktAdminMgr::PktRemoveItem* lpPktRemoveItem = static_cast<PktAdminMgr::PktRemoveItem*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktRemoveItem->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktRemoveItem->m_dwCID);
if(NULL == lpModifyCharacter)
{
ERRLOG0(g_Log, "캐릭터 세션 얻기 실패");
return true;
}
const unsigned long dwUID = lpPktRemoveItem->m_dwUID;
const unsigned long dwCID = lpPktRemoveItem->m_dwCID;
const unsigned char cTakePos = lpPktRemoveItem->m_cTakePos;
const unsigned char cXPos = lpPktRemoveItem->m_cXPos;
const unsigned char cYPos = lpPktRemoveItem->m_cYPos;
const unsigned char cZPos = lpPktRemoveItem->m_cZPos;
const unsigned __int64 ItemUID = lpPktRemoveItem->m_ItemUID;
const unsigned short PrototypeID = lpPktRemoveItem->m_ItemPrototypeID;
if(cTakePos == TakeType::TS_DEPOSIT)
{
if(!DepositCheckIt(lpAgentDispatch->GetDepositLock(), dwUID, dwCID))
{
SendResult(PktAdminMgr::PktResult::Err_NotUseDeposit);
return true;
}
}
Item::ItemPos ItemPos = ItemData::MakeItemPos(cTakePos, cXPos, cYPos, cZPos);
Item::CItem* lpItem = lpModifyCharacter->GetItem(ItemPos);
// 인벤토리 컨테이너안의 RemoveItem, SetItem 메소드내에서 CheckTrigger 사용안하도록!
lpModifyCharacter->GetInventory().SetAdminTool();
if ((NULL != lpItem) && (lpItem->GetUID() == ItemUID) && (lpItem->GetPrototypeID() == PrototypeID))
{
if (false == lpModifyCharacter->RemoveItem(ItemPos))
{
ERRLOG0(g_Log, "아이템 삭제 실패");
SendResult(PktAdminMgr::PktResult::Err_RemoveItem);
}
else
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Item Delete]\r\nUID: %u\r\nCID : %d\r\nServerGroup : %d\r\n"
"Position : %s\r\nPrototypeID : %d\r\nItemUID : 0x%016I64X\r\nName : %s\r\nX:%d Y:%d Z:%d",
lpPktRemoveItem->m_dwUID, lpModifyCharacter->GetCID(), lpModifyCharacter->GetServerGroup(),
GetItemState(cTakePos), lpItem->GetItemInfo().m_usProtoTypeID, lpItem->GetUID(),
lpItem->GetItemInfo().m_SpriteData.m_szName, ItemPos.GetXIndex(), ItemPos.GetYIndex(), ItemPos.GetZIndex());
m_DetailLog.InsertLog(m_MyLogID);
DELETE_ITEM(lpItem);
if(cTakePos == TakeType::TS_DEPOSIT)
{
if((0 == cZPos) || (1 == cZPos))
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STROE12);
}
else if((cZPos == 2) || (cZPos == 3))
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_STORE34);
}
}
else
{
lpModifyCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
}
// RemoveItem Ack를 클라이언트로 전송
if(cTakePos == TakeType::TS_DEPOSIT)
{
CModifyCharacterMgr& CharMgr = lpAgentDispatch->GetModifyCharacterMgr();
CModifyCharacterMgr::iterator Pos = CharMgr.begin();
for(;Pos != CharMgr.end(); ++Pos)
{
CModifyCharacter* lpCharacter = Pos->second;
if(NULL == lpCharacter)
{
ERRLOG0(g_Log, "널 세션");
return true;
}
if((NULL != lpCharacter->GetCheckSession(dwUID)) && (dwCID != lpCharacter->GetCID()))
{
Item::CItem* CloneItem = lpCharacter->GetItem(ItemPos);
if(lpCharacter->RemoveItem(ItemPos)) // 아이템 삭제
{
if(NULL != CloneItem)
{
DELETE_ITEM(CloneItem);
}
CBuffer* lpBuffer = MakeRemoveItemAck(lpCharacter->GetClientKey(),
lpCharacter->GetCID(), ItemUID, PrototypeID, lpPktRemoveItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "ACK 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
}
CBuffer* lpBuffer = MakeRemoveItemAck(lpPktRemoveItem->m_dwRequestKey,
dwCID, ItemUID, PrototypeID, lpPktRemoveItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "ACK 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
CBuffer* lpBuffer = MakeRemoveItemAck(lpPktRemoveItem->m_dwRequestKey,
dwCID, ItemUID, PrototypeID, lpPktRemoveItem);
if (NULL == lpBuffer)
{
ERRLOG0(g_Log, "ACK 버퍼 생성 실패");
return true;
}
if (false == GetSession().SendPending(lpBuffer))
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
}
return true;
}
// 인벤토리 골드 수정
bool CRylAdminMgrDispatch::PktInvenGold(PktBase* lpPktBase)
{
PktAdminMgr::PktInvenGold* lpInvenGold = static_cast<PktAdminMgr::PktInvenGold*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpInvenGold->m_dwServerGroup);
if(NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter = lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpInvenGold->m_dwCID);
if(NULL != lpCharacter)
{
m_DetailLog.SetBefore("UID: %u\r\nCID: %u\r\nServerGroup: %u\r\n\r\nInventory Gold : %u",
lpInvenGold->m_dwUID, lpInvenGold->m_dwCID, lpInvenGold->m_dwServerGroup, lpCharacter->GetGold());
if (lpCharacter->SetGold(lpInvenGold->m_dwGold))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktInvenGold));
PktAdminMgr::PktInvenGold* lpPktInvenGold =
reinterpret_cast<PktAdminMgr::PktInvenGold*>(lpBuffer->begin());
CopyMemory(lpPktInvenGold, lpInvenGold, sizeof(PktAdminMgr::PktInvenGold));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktInvenGold), PktAdminMgr::PktCMD::PktInvenGold, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
lpCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
m_DetailLog.SetAfter("Inventory Gold : %u", lpCharacter->GetGold());
m_DetailLog.InsertLog(m_MyLogID);
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_SetInventoryGold);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
}
return true;
}
// 아이템 만들기 Ack
CBuffer* CRylAdminMgrDispatch::MakeCreateItemAck(unsigned long dwRequestKey, unsigned long dwCID,
unsigned __int64 dwItemID, unsigned short dwPrototypeID,
PktAdminMgr::PktCreateItem* lpCreateItem)
{
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktCreateItemAck));
PktAdminMgr::PktCreateItemAck* lpPktCreateItemAck =
reinterpret_cast<PktAdminMgr::PktCreateItemAck*>(lpBuffer->begin());
lpPktCreateItemAck->m_dwCID = dwCID;
lpPktCreateItemAck->m_dwUID = lpCreateItem->m_dwUID;
lpPktCreateItemAck->m_dwRequestKey = dwRequestKey;
lpPktCreateItemAck->m_dwServerGroup = lpCreateItem->m_dwServerGroup;
lpPktCreateItemAck->m_ItemID = dwItemID;
lpPktCreateItemAck->m_PrototypeID = dwPrototypeID;
CopyMemory(&lpPktCreateItemAck->m_CreateItemInfo, &lpCreateItem->m_CreateItemInfo,
sizeof(PktAdminMgr::CreateItemInfo));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktCreateItemAck), PktAdminMgr::PktCMD::PktCreateItemAck, 0, 0))
{
SAFE_RELEASE_BUFFER(lpBuffer);
return NULL;
}
return lpBuffer;
}
// 각종 아이템 컨테이너 리셋 ACK
CBuffer* CRylAdminMgrDispatch::MakeItemResetAck(unsigned long dwRequestKey, unsigned long dwCID,
PktAdminMgr::PktItemReset* lpPktItemReset)
{
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktItemReset));
PktAdminMgr::PktItemResetAck* lpItemReset =
reinterpret_cast<PktAdminMgr::PktItemResetAck*>(lpBuffer->begin());
lpItemReset->m_dwCID = dwCID;
lpItemReset->m_dwUID = lpPktItemReset->m_dwUID;
lpItemReset->m_cTakePos = lpPktItemReset->m_cTakePos;
lpItemReset->m_dwRequest = dwRequestKey;
lpItemReset->m_dwServerGroup = lpPktItemReset->m_dwServerGroup;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktItemResetAck), PktAdminMgr::PktCMD::PktItemResetAck, 0, 0))
{
SAFE_RELEASE_BUFFER(lpBuffer);
return NULL;
}
return lpBuffer;
}
// 스킬 추가, 편집, 삭제
bool CRylAdminMgrDispatch::PktSkillEdit(PktBase* lpPktBase)
{
PktAdminMgr::PktSkillEdit* lpPktSkillEdit = static_cast<PktAdminMgr::PktSkillEdit*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktSkillEdit->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계 서버 디스패치 찾기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktSkillEdit->m_dwCID);
if(NULL == lpCharacter)
{
ERRLOG2(g_Log, "캐릭터 세션 얻기 실패. 그룹: %u, CID: %u",
lpPktSkillEdit->m_dwServerGroup, lpPktSkillEdit->m_dwCID);
return true;
}
unsigned short wSkillID = lpPktSkillEdit->m_wSkillID;
char cLevel = lpPktSkillEdit->m_SkillLevel;
char cLockCount = lpPktSkillEdit->m_SkillLockCount;
unsigned char cResult = 0;
CString strTemp;
strTemp.Format("[Skill");
if(NULL != lpCharacter)
{
switch(lpPktSkillEdit->m_cType)
{
case PktAdminMgr::PktSkillEdit::Create:
cResult = lpCharacter->AppendSkill(wSkillID, cLevel, cLockCount); // 스킬 추가
strTemp.AppendFormat(" Add]");
break;
case PktAdminMgr::PktSkillEdit::Edit:
cResult = lpCharacter->AppendSkill(wSkillID, cLevel, cLockCount); // 스킬 편집
strTemp.AppendFormat(" Edit]");
break;
case PktAdminMgr::PktSkillEdit::Delete:
cResult = lpCharacter->DeleteSkill(wSkillID, cLevel, cLockCount); // 스킬 삭제
strTemp.AppendFormat(" Del]");
break;
}
}
strTemp.AppendFormat("\r\nUID: %u\r\nCID: %u\r\n"
"ServerGroup: %u\r\n\r\nSkill ID: 0x%04d\r\nLevel: %d\r\nLockCount: %d",
lpPktSkillEdit->m_dwUID, lpPktSkillEdit->m_dwCID, lpPktSkillEdit->m_dwServerGroup,
wSkillID, cLevel, cLockCount);
if(cResult == PktAdminMgr::PktSkillEdit::SUCCESS)
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("%s", strTemp);
m_DetailLog.InsertLog(m_MyLogID);
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktSkillEdit));
PktAdminMgr::PktSkillEdit* lpPktSkillEditAck =
reinterpret_cast<PktAdminMgr::PktSkillEdit*>(lpBuffer->begin());
lpCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
CopyMemory(lpPktSkillEditAck, lpPktSkillEdit, sizeof(PktAdminMgr::PktSkillEdit));
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktSkillEdit), PktAdminMgr::PktCMD::PktSkillEditAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
switch(cResult)
{
case PktAdminMgr::PktSkillEdit::NOT_ENOUGH_STAT:
SendResult(PktAdminMgr::PktResult::Err_NOT_ENOUGH_STAT);
break;
case PktAdminMgr::PktSkillEdit::NOT_ENOUGH_SKILLSLOT:
SendResult(PktAdminMgr::PktResult::Err_NOT_ENOUGH_SKILLSLOT);
break;
case PktAdminMgr::PktSkillEdit::FAILED_TO_GET_SKILLPROTOTYPE:
SendResult(PktAdminMgr::PktResult::Err_FAILED_TO_GET_SKILLPROTOTYPE);
break;
case PktAdminMgr::PktSkillEdit::OVERED_MAX_LOCKCOUNT:
SendResult(PktAdminMgr::PktResult::Err_OVERED_MAX_LOCKCOUNT);
break;
case PktAdminMgr::PktSkillEdit::OVERED_MAX_SKILL_LEVEL:
SendResult(PktAdminMgr::PktResult::Err_OVERED_MAX_SKILL_LEVEL);
break;
case PktAdminMgr::PktSkillEdit::NOT_CURRENT_CLASS:
SendResult(PktAdminMgr::PktResult::Err_NOT_CURRENT_CLASS);
break;
case PktAdminMgr::PktSkillEdit::FAILED:
SendResult(PktAdminMgr::PktResult::Err_SkillEdit);
break;
default:
SendResult(PktAdminMgr::PktResult::Err_SkillEdit);
break;
}
}
return true;
}
// 관리자 존, 좌표 목록 디비에 저장
bool CRylAdminMgrDispatch::PktSetZoneList(PktBase* lpPktBase)
{
PktAdminMgr::PktSetZoneList* lpPktSetZone = static_cast< PktAdminMgr::PktSetZoneList* >(lpPktBase);
unsigned char* cZoneCount = reinterpret_cast< unsigned char* >( lpPktSetZone->m_ZoneBuffer );
CDBAdminTool& ToolDB = CDBAdminTool::GetInstance();
if(!ToolDB.UpdateZoneList(m_MyUID, lpPktSetZone->m_ZoneBuffer))
{
ERRLOG0(g_Log, "존 리스트정보를 디비에 저장하는데 실패했습니다");
}
return true;
}
// 창고 패스워드 변경
bool CRylAdminMgrDispatch::PktDepositPasswd(PktBase* lpPktBase)
{
PktAdminMgr::PktDepositPasswd* lpPktDepositPwd = static_cast<PktAdminMgr::PktDepositPasswd*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktDepositPwd->m_dwServerGroup);
if (NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktDepositPwd->m_dwCID);
if ((NULL != lpCharacter) && (0 < strlen(lpPktDepositPwd->m_cPasswd)))
{
Item::CDepositContainer& DepositContainer = lpCharacter->GetDeposit();
m_DetailLog.SetBefore("UID: %u\r\nServerGroup: %u\r\n\r\nStore Password: %s",
lpPktDepositPwd->m_dwUID, lpPktDepositPwd->m_dwServerGroup, DepositContainer.GetPassword());
m_DetailLog.SetAfter("Store Password: %s", lpPktDepositPwd->m_cPasswd);
m_DetailLog.InsertLog(m_MyLogID);
DepositContainer.SetPassword(lpPktDepositPwd->m_cPasswd, lpPktDepositPwd->PASSWORD_LENGTH);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
SendResult(PktAdminMgr::PktResult::Success_DepositPasswd);
}
}
else
{
SendResult( PktAdminMgr::PktResult::Err_NotFoundAgentDispatch );
ERRLOG0(g_Log, "서버 디스 패치를 찾을 수 없습니다");
}
return true;
}
// 해당 캐릭터이름이 디비에 존재하는지 확인한다.
bool CRylAdminMgrDispatch::PktCheckName(PktBase* lpPktBase)
{
PktAdminMgr::PktCheckName* lpPktCheckName = static_cast<PktAdminMgr::PktCheckName*>(lpPktBase);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktCheckName->m_dwServerGroup);
if(NULL != lpGameDB)
{
bool bIsUse = lpGameDB->UseCharacterName( lpPktCheckName->m_szCharacterName );
if( bIsUse )
{
SendResult( PktAdminMgr::PktResult::Err_NotUseName ); // 사용할수 없는 캐릭터 이름
}
else
{
SendResult( PktAdminMgr::PktResult::Success_UseName ); // 사용할수 있는 캐릭터 이름.
}
}
return true;
}
// 캐릭터 이름바꾸기..
bool CRylAdminMgrDispatch::PktChangeName(PktBase* lpPktBase)
{
PktAdminMgr::PktChangeName* lpPktChangeName = static_cast<PktAdminMgr::PktChangeName*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktChangeName->m_dwServerGroup);
if (NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktChangeName->m_dwCID);
if (NULL != lpCharacter)
{
CString strBefore;
strBefore.Format("UID: %u\r\nCID: %u\r\nServerGroup: %u\r\n\r\nCharacter Name: %s",
lpPktChangeName->m_dwUID, lpPktChangeName->m_dwCID,
lpPktChangeName->m_dwServerGroup, lpCharacter->GetCharacterName());
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAgentServer::PktAdminToolGetData));
PktAgentServer::PktAdminToolGetData* lpPktAdminToolGetData =
reinterpret_cast<PktAgentServer::PktAdminToolGetData*>(lpBuffer->begin());
lpPktAdminToolGetData->m_cType = PktAgentServer::PktAdminToolGetData::CHANGE_CHAR_NAME;
lpPktAdminToolGetData->m_dwUID = lpPktChangeName->m_dwUID;
lpPktAdminToolGetData->m_dwCID = lpPktChangeName->m_dwCID;
lpPktAdminToolGetData->m_dwRequestKey = lpPktChangeName->m_dwRequest;
strncpy(lpPktAdminToolGetData->m_szName,
lpPktChangeName->m_szCharacterName, PktAdminMgr::MAX_NAME);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAgentServer::PktAdminToolGetData), CmdAdminToolGetData, 0, 0))
{
ERRLOG0(g_Log, "캐릭명 변경 패킷 랩핑 실패");
bIsReleased = false;
}
else
{
if (false == lpAgentDispatch->Send(lpBuffer))
{
ERRLOG0(g_Log, "캐릭명 변경 패킷 보내기 실패");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
}
}
return true;
}
// 관리자 창고에 아이템을 추가한다.
bool CRylAdminMgrDispatch::PktAdminStoreInsert( PktBase* lpPktBase )
{
PktAdminMgr::PktAdminStoreInsert* lpPktAck = static_cast< PktAdminMgr::PktAdminStoreInsert* >( lpPktBase );
unsigned long dwUID = 0;
char szQuery[ CDBAdminTool::MAX_QUERY_LENGTH ];
char szName [ 20 ];
if( lpPktAck->m_cServerIdx == lpPktAck->EMPTY_SERVERID )
{
strncpy( szName, m_szAccount, 20 );
}
else
{
strncpy( szName, lpPktAck->m_szOwnerName, 20 );
}
_snprintf( szQuery, CDBAdminTool::MAX_QUERY_LENGTH, "INSERT INTO TblAdminStore( server, owner, ItemName ) VALUES( %d, '%s', '%s' )",
lpPktAck->m_cServerIdx, szName, lpPktAck->m_szItemName );
if( CDBAdminTool::GetInstance().ExecuteQuery( szQuery ) )
{ // 관리자 창고 기본정보를 채워놓고...
_snprintf( szQuery, CDBAdminTool::MAX_QUERY_LENGTH, "SELECT uid FROM TblAdminStore ORDER BY uid DESC" );
if( CDBAdminTool::GetInstance().ExecuteQueryGetData( szQuery, &dwUID ) )
{ // 지금 추가된 창고 uid를 가져온다.. 다른 좋은 방법있으면 바꿀것.. ㅡ.ㅡa
_snprintf( szQuery, CDBAdminTool::MAX_QUERY_LENGTH, "SELECT ItemInfo FROM TblAdminStore WHERE uid=%d", dwUID );
if( CDBAdminTool::GetInstance().ExecuteQuery( szQuery, OleDB::Rowset_Update ) )
{ // 얻어온 uid로 아이템 정보를 binary로 써넣자~~~
if( !CDBAdminTool::GetInstance().SetBinaryData( 1, ( OleDB::LPSET_BINARY )lpPktAck->m_binItemInfo ) )
{
SendResult( PktAdminMgr::PktResult::Err_AdminStore );
return true;
}
}
}
}
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktAdminStoreInsertAck));
PktAdminMgr::PktAdminStoreInsertAck* lpPktStore =
reinterpret_cast<PktAdminMgr::PktAdminStoreInsertAck*>(lpBuffer->begin());
lpPktStore->m_dwStoreUID = dwUID;
lpPktStore->m_cServerIdx = lpPktAck->m_cServerIdx;
strncpy(lpPktStore->m_szItemName, lpPktAck->m_szItemName, PktAdminMgr::MAX_ITEM_NAME);
strncpy(lpPktStore->m_szOwnerName, szName, PktAdminMgr::MAX_NAME);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAdminStoreInsertAck), PktAdminMgr::PktCMD::PktAdminStoreInsertAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
bool CRylAdminMgrDispatch::PktUpdateAdminStore( PktBase* lpPktBase )
{
PktAdminMgr::PktUpdateAdminStore* lpPktAck = static_cast< PktAdminMgr::PktUpdateAdminStore* >( lpPktBase );
char szQuery[ CDBAdminTool::MAX_QUERY_LENGTH ];
_snprintf( szQuery, CDBAdminTool::MAX_QUERY_LENGTH, "SELECT ItemInfo FROM TblAdminStore WHERE uid=%d", lpPktAck->m_dwStoreUID );
if( CDBAdminTool::GetInstance().ExecuteQuery( szQuery, OleDB::Rowset_Update ) )
{
if( !CDBAdminTool::GetInstance().SetBinaryData( 1, ( OleDB::LPSET_BINARY )lpPktAck->m_binItemInfo ) )
{
SendResult( PktAdminMgr::PktResult::Err_AdminStore );
return true;
}
}
SendResult(PktAdminMgr::PktResult::Success_UpdateAdminStore);
return true;
}
bool CRylAdminMgrDispatch::SendAdminStoreList()
{
#pragma pack(1)
struct In_Data
{
unsigned long m_dwStoreUID;
unsigned char m_cServerID;
char m_szOwnerName[PktAdminMgr::MAX_NAME];
char m_szItemName[PktAdminMgr::MAX_ITEM_NAME];
};
#pragma pack()
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktAdminStoreInsertAck) * 20, &GetSession());
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery,
CDBAdminTool::MAX_QUERY_LENGTH, "SELECT uid, server, Owner, ItemName FROM TblAdminStore");
if(CDBAdminTool::GetInstance().ExecuteQuery(szQuery))
{
In_Data In_Store;
while(CDBAdminTool::GetInstance().GetData(&In_Store))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktAdminStoreInsertAck));
PktAdminMgr::PktAdminStoreInsertAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktAdminStoreInsertAck*>(lpBuffer);
lpPktAck->m_dwStoreUID = In_Store.m_dwStoreUID;
lpPktAck->m_cServerIdx = In_Store.m_cServerID;
strncpy(lpPktAck->m_szOwnerName, In_Store.m_szOwnerName, PktAdminMgr::MAX_NAME);
strncpy(lpPktAck->m_szItemName, In_Store.m_szItemName, PktAdminMgr::MAX_ITEM_NAME);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAdminStoreInsertAck), PktAdminMgr::PktCMD::PktAdminStoreInsertAck, 0, 0);
ZeroMemory(&In_Store, sizeof(In_Data));
}
}
return true;
}
bool CRylAdminMgrDispatch::PktAdminStoreDelete( PktBase* lpPktBase )
{
PktAdminMgr::PktAdminStoreDelete* lpPktStore = static_cast< PktAdminMgr::PktAdminStoreDelete* >( lpPktBase );
char szQuery[ CDBAdminTool::QUERY_BUFFER_LEN ];
_snprintf( szQuery, CDBAdminTool::QUERY_BUFFER_LEN, "DELETE TblAdminStore WHERE uid = %d", lpPktStore->m_dwStoreUID );
if( !CDBAdminTool::GetInstance().ExecuteQuery( szQuery ) )
{
SendResult( PktAdminMgr::PktResult::Err_AdminStoreDelete );
return true;
}
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktAdminStoreDelete));
PktAdminMgr::PktAdminStoreDelete* lpPktAck =
reinterpret_cast<PktAdminMgr::PktAdminStoreDelete*>(lpBuffer->begin());
lpPktAck->m_dwStoreUID = lpPktStore->m_dwStoreUID;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktAdminStoreDelete), PktAdminMgr::PktCMD::PktAdminStoreDeleteAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
bool CRylAdminMgrDispatch::PktGetAdminStoreItem(PktBase* lpPktBase)
{
PktAdminMgr::PktGetAdminStoreItem* lpPktGetStoreItem =
static_cast<PktAdminMgr::PktGetAdminStoreItem*>(lpPktBase);
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktGetAdminStoreItemAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
return false;
}
PktAdminMgr::PktGetAdminStoreItemAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGetAdminStoreItemAck*>(lpBuffer->begin());
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN,
"SELECT ItemInfo FROM TblAdminStore WHERE uid = %d", lpPktGetStoreItem->m_dwStoreUID);
if (CDBAdminTool::GetInstance().ExecuteQueryGetData(szQuery, lpPktAck->m_binItemInfo))
{
unsigned long dwInfoLength = *reinterpret_cast<unsigned long*>(lpPktAck->m_binItemInfo);
if (PktAdminMgr::PktGetAdminStoreItemAck::MAX_ITEM_INFO > dwInfoLength)
{
lpPktAck->m_cType = lpPktGetStoreItem->m_cType;
lpPktAck->m_dwStoreUID = lpPktGetStoreItem->m_dwStoreUID;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktGetAdminStoreItemAck), PktAdminMgr::PktCMD::PktGetAdminStoreItemAck, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
return true;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
bool CRylAdminMgrDispatch::PktForcedDis(PktBase *lpPktBase)
{
LPPktUK lpPktUK = static_cast<LPPktUK>(lpPktBase);
// 현재 운영서버와 연결된 중계서버로 강제 접속 끊기 커맨드 보내기
for(unsigned int nIndex = 0; nIndex < CAgentServerTable::MAX_AGENT_SERVER; ++nIndex)
{
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(nIndex);
if (NULL != lpAgentDispatch)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(LPPktUK));
*reinterpret_cast<LPPktUK>(lpBuffer->wr_ptr()) = *lpPktUK;
if (false == PacketWrap::WrapHeader(lpBuffer, sizeof(PktUK), CmdUserKill, 0, 0))
{
ERRLOG0(g_Log, "강제 접속 끊기 패킷 랩핑 실패");
bIsReleased = false;
}
else
{
if (false == lpAgentDispatch->Send(lpBuffer))
{
ERRLOG0(g_Log, "강제 접속 끊기 패킷 보내기 실패");
bIsReleased = false;
}
else
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[Forced Disconnect]\r\nUID: %u", lpPktUK->m_dwUserID);
m_DetailLog.InsertLog(m_MyLogID);
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktGuildSearch(PktBase *lpPktBase)
{
#pragma pack(1)
struct In_GuildList
{
unsigned long m_dwGID;
unsigned int m_nOldServerID;
char m_szName[PktAdminMgr::MAX_NAME];
int m_nLevel;
unsigned long m_dwFame;
unsigned long m_dwGold;
int m_nNation;
int m_nMemberNum;
};
#pragma pack()
PktAdminMgr::PktGuildSearch* lpPktGuildSearch = static_cast<PktAdminMgr::PktGuildSearch*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
switch(lpPktGuildSearch->m_cSearchType)
{
case PktAdminMgr::PktGuildSearch::ALLGROUP_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "");
break;
case PktAdminMgr::PktGuildSearch::ALLGROUP_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.nGuildID = %s", lpPktGuildSearch->m_szSearchValue);
break;
case PktAdminMgr::PktGuildSearch::ALLGROUP_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.strGuildName LIKE '%%%s%%'", lpPktGuildSearch->m_szSearchValue);
break;
case PktAdminMgr::PktGuildSearch::SPEGROUP_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "");
break;
case PktAdminMgr::PktGuildSearch::SPEGROUP_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.nGuildID = %s", lpPktGuildSearch->m_szSearchValue);
break;
case PktAdminMgr::PktGuildSearch::SPEGROUP_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.strGuildName LIKE '%%%s%%'", lpPktGuildSearch->m_szSearchValue);
break;
default:
break;
}
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetGuildInfo, szWHERE);
In_GuildList GuildList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktGuildSearch->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&GuildList, sizeof(In_GuildList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktGuildSearchAck) * 30, &GetSession());
while(lpGameDB->GetData(&GuildList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktGuildSearchAck));
PktAdminMgr::PktGuildSearchAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGuildSearchAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktGuildSearchAck));
lpPktAck->m_dwGID = GuildList.m_dwGID;
lpPktAck->m_nOldServerID = GuildList.m_nOldServerID;
lpPktAck->m_dwLevel = GuildList.m_nLevel;
lpPktAck->m_dwFame = GuildList.m_dwFame;
lpPktAck->m_dwGold = GuildList.m_dwGold;
lpPktAck->m_dwNation = GuildList.m_nNation;
lpPktAck->m_dwMemberNum = GuildList.m_nMemberNum;
lpPktAck->m_dwServerGroup = lpPktGuildSearch->m_dwServerGroup;
strncpy(lpPktAck->m_szName, GuildList.m_szName, PktAdminMgr::MAX_NAME);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktGuildSearchAck), PktAdminMgr::PktCMD::PktGuildSearchAck, 0, 0);
ZeroMemory(&GuildList, sizeof(In_GuildList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktRequestGuildMemberList(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_GuildMemberInfo
{
unsigned long m_dwGID;
unsigned long m_dwCID;
int m_nPostion;
int m_nPositionInGuild;
char m_szLeaveGuildTime[PktAdminMgr::MAX_TIME];
char m_szCharName[PktAdminMgr::PktRequestGuildMemberListAck::MAX_NAME];
int m_nLevel;
unsigned long m_dwFame;
unsigned short m_nClass;
unsigned long m_dwGold;
};
#pragma pack()
PktAdminMgr::PktRequestGuildMemberList* lpPktGuildMemberList =
static_cast<PktAdminMgr::PktRequestGuildMemberList*>(lpPktBase);
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szFormat[256];
sprintf(szFormat, "%u", lpPktGuildMemberList->m_dwGID);
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetGuildMemberList, szFormat);
In_GuildMemberInfo GuildMemberInfo;
ZeroMemory(&GuildMemberInfo, sizeof(In_GuildMemberInfo));
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktGuildMemberList->m_dwServerGroup);
if(NULL != lpGameDB)
{
if(lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(In_GuildMemberInfo) * 20, &GetSession());
while(lpGameDB->GetData(&GuildMemberInfo))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktRequestGuildMemberListAck));
PktAdminMgr::PktRequestGuildMemberListAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktRequestGuildMemberListAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(lpPktAck));
lpPktAck->m_dwGID = GuildMemberInfo.m_dwGID;
lpPktAck->m_dwCID = GuildMemberInfo.m_dwCID;
lpPktAck->m_nPosition = GuildMemberInfo.m_nPostion;
lpPktAck->m_nPositionInGuild = GuildMemberInfo.m_nPositionInGuild;
strncpy(lpPktAck->m_szLeaveGuildTime,
GuildMemberInfo.m_szLeaveGuildTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szCharName, GuildMemberInfo.m_szCharName,
PktAdminMgr::PktRequestGuildMemberListAck::MAX_NAME);
lpPktAck->m_nLevel = GuildMemberInfo.m_nLevel;
lpPktAck->m_dwFame = GuildMemberInfo.m_dwFame;
lpPktAck->m_nClass = GuildMemberInfo.m_nClass;
lpPktAck->m_dwGold = GuildMemberInfo.m_dwGold;
PacketWrap::WrapHeader(lpBuffer,sizeof(PktAdminMgr::PktRequestGuildMemberListAck),
PktAdminMgr::PktCMD::PktRequestGuildMemberListAck, 0, 0);
ZeroMemory(&GuildMemberInfo, sizeof(In_GuildMemberInfo));
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktGuildRestoreDataList(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_GuildRestoreData
{
unsigned long m_dwGID;
char m_szGuildName[PktAdminMgr::MAX_NAME];
unsigned long m_dwGold;
char m_szDeleteDate[PktAdminMgr::MAX_TIME];
};
#pragma pack()
bool bExistData = false;
PktAdminMgr::PktGuildRestoreDataList* lpPktGuildRestoreDataList =
static_cast<PktAdminMgr::PktGuildRestoreDataList*>(lpPktBase);
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetGuildRestoreData);
In_GuildRestoreData GuildRestoreData;
ZeroMemory(&GuildRestoreData, sizeof(In_GuildRestoreData));
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktGuildRestoreDataList->m_dwServerGroup);
if(NULL != lpGameDB)
{
if(lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(In_GuildRestoreData) * 20, &GetSession());
while(lpGameDB->GetData(&GuildRestoreData))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktGuildRestoreDataListAck));
PktAdminMgr::PktGuildRestoreDataListAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGuildRestoreDataListAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(lpPktAck));
lpPktAck->m_dwServerGroup = lpPktGuildRestoreDataList->m_dwServerGroup;
lpPktAck->m_dwGID = GuildRestoreData.m_dwGID;
strncpy(lpPktAck->m_szGuildName,
GuildRestoreData.m_szGuildName, PktAdminMgr::MAX_NAME);
lpPktAck->m_dwGold = GuildRestoreData.m_dwGold;
strncpy(lpPktAck->m_szDeleteDate,
GuildRestoreData.m_szDeleteDate, PktAdminMgr::MAX_TIME);
PacketWrap::WrapHeader(lpBuffer,sizeof(PktAdminMgr::PktGuildRestoreDataListAck),
PktAdminMgr::PktCMD::PktGuildRestoreDataListAck, 0, 0);
ZeroMemory(&GuildRestoreData, sizeof(In_GuildRestoreData));
bExistData = true;
}
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktFortSearch(PktBase *lpPktBase)
{
#pragma pack(1)
struct In_FortList
{
unsigned long m_dwCampID;
unsigned long m_dwGuildID;
char m_szGuildName[PktAdminMgr::MAX_NAME];
unsigned long m_dwHP;
unsigned char m_cZone;
unsigned char m_cChannel;
unsigned short m_usObjectType;
unsigned char m_cState;
unsigned char m_cSubState;
unsigned char m_cUpgradeStep;
char m_szRemainTime[PktAdminMgr::MAX_TIME];
char m_szLastUseTime[PktAdminMgr::MAX_TIME];
float m_fPosX;
float m_fPosY;
float m_fPosZ;
unsigned char m_cMaterial;
unsigned char m_cSiegeCount;
char m_aryRight[CastleRight::MAX_RIGHT_NUM];
};
#pragma pack()
PktAdminMgr::PktFortSearch* lpPktFortSearch = static_cast<PktAdminMgr::PktFortSearch*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
switch(lpPktFortSearch->m_cSearchType)
{
case PktAdminMgr::PktFortSearch::ALLSERVER_ALLZONE_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u", lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::ALLSERVER_ALLZONE_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.nGuildID = %s AND A.tnZone = %u", lpPktFortSearch->m_szSearchValue, lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::ALLSERVER_ALLZONE_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE B.strGuildName LIKE '%%%s%%' AND A.tnZone = %u", lpPktFortSearch->m_szSearchValue, lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::ALLSERVER_SPEZONE_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u", lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::ALLSERVER_SPEZONE_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u AND A.nGuildID = %s", lpPktFortSearch->m_dwZoneGroup, lpPktFortSearch->m_szSearchValue);
break;
case PktAdminMgr::PktFortSearch::ALLSERVER_SPEZONE_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE B.tnZone = %u AND A.strGuildName = %s", lpPktFortSearch->m_dwZoneGroup, lpPktFortSearch->m_szSearchValue);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_ALLZONE_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u", lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_ALLZONE_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.nGuildID = %s AND A.tnZone = %u", lpPktFortSearch->m_szSearchValue, lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_ALLZONE_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE B.strGuildName LIKE '%%%s%%' AND A.tnZone = %u", lpPktFortSearch->m_szSearchValue, lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_SPEZONE_ALLGUILD:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u", lpPktFortSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_SPEZONE_SPEGUILD_GID:
_snprintf(szWHERE, MAX_WHERE, "WHERE A.tnZone = %u AND A.nGuildID = %s", lpPktFortSearch->m_dwZoneGroup, lpPktFortSearch->m_szSearchValue);
break;
case PktAdminMgr::PktFortSearch::SPESERVER_SPEZONE_SPEGUILD_NAME:
_snprintf(szWHERE, MAX_WHERE, "WHERE B.tnZone = %u AND A.strGuildName = %s", lpPktFortSearch->m_dwZoneGroup, lpPktFortSearch->m_szSearchValue);
break;
default:
break;
}
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetFortInfo, szWHERE);
In_FortList FortList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktFortSearch->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&FortList, sizeof(In_FortList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktFortSearchAck) * 30, &GetSession());
while(lpGameDB->GetData(&FortList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktFortSearchAck));
PktAdminMgr::PktFortSearchAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktFortSearchAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktFortSearchAck));
lpPktAck->m_dwCampID = FortList.m_dwCampID;
lpPktAck->m_dwGuildID = FortList.m_dwGuildID;
lpPktAck->m_dwHP = FortList.m_dwHP;
lpPktAck->m_cZone = FortList.m_cZone;
lpPktAck->m_cChannel = FortList.m_cChannel;
lpPktAck->m_usObjectType = FortList.m_usObjectType;
lpPktAck->m_cState = FortList.m_cState;
lpPktAck->m_cSubState = FortList.m_cSubState;
lpPktAck->m_cUpgradeStep = FortList.m_cUpgradeStep;
lpPktAck->m_fPosX = FortList.m_fPosX;
lpPktAck->m_fPosY = FortList.m_fPosY;
lpPktAck->m_fPosZ = FortList.m_fPosZ;
lpPktAck->m_cMaterial = FortList.m_cMaterial;
lpPktAck->m_cSiegeCount = FortList.m_cSiegeCount;
lpPktAck->m_dwServerGroup = lpPktFortSearch->m_dwServerGroup;
lpPktAck->m_cRight = FortList.m_aryRight[0];
strncpy(lpPktAck->m_szRemainTime, FortList.m_szRemainTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szLastUseTime, FortList.m_szLastUseTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szGuildName, FortList.m_szGuildName, PktAdminMgr::MAX_NAME);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktFortSearchAck), PktAdminMgr::PktCMD::PktFortSearchAck, 0, 0);
ZeroMemory(&FortList, sizeof(In_FortList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktMiningCamp(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_MiningCampList
{
unsigned long m_dwCampID;
unsigned short m_sMineralID;
unsigned short m_sAmount;
char m_cFlag;
};
#pragma pack()
PktAdminMgr::PktMiningCamp* lpPktMiningCamp = static_cast<PktAdminMgr::PktMiningCamp*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
_snprintf(szWHERE, MAX_WHERE, "WHERE nCampID = %u", lpPktMiningCamp->m_dwCampID);
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetMiningCamp, szWHERE);
In_MiningCampList MiningCampList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktMiningCamp->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&MiningCampList, sizeof(In_MiningCampList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktMiningCampAck) * 30, &GetSession());
while(lpGameDB->GetData(&MiningCampList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktMiningCampAck));
PktAdminMgr::PktMiningCampAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktMiningCampAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktMiningCampAck));
lpPktAck->m_dwCampID = MiningCampList.m_dwCampID;
lpPktAck->m_sMineralID = MiningCampList.m_sMineralID;
lpPktAck->m_sAmount = MiningCampList.m_sAmount;
lpPktAck->m_cFlag = MiningCampList.m_cFlag;
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktMiningCampAck), PktAdminMgr::PktCMD::PktMiningCampAck, 0, 0);
ZeroMemory(&MiningCampList, sizeof(In_MiningCampList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktShopCamp(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_ShopCampList
{
unsigned long m_dwCampID;
char m_szItem[PktAdminMgr::MAX_ITEM_BUFFER];
unsigned long m_dwTempMoney;
char m_cTax;
};
#pragma pack()
PktAdminMgr::PktShopCamp* lpPktShopCamp = static_cast<PktAdminMgr::PktShopCamp*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
_snprintf(szWHERE, MAX_WHERE, "WHERE CampID = %u", lpPktShopCamp->m_dwCampID);
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetShopCamp, szWHERE);
In_ShopCampList ShopCampList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktShopCamp->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&ShopCampList, sizeof(In_ShopCampList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktShopCampAck) * 30, &GetSession());
while(lpGameDB->GetData(&ShopCampList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktShopCampAck));
PktAdminMgr::PktShopCampAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktShopCampAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktShopCampAck));
lpPktAck->m_dwCampID = ShopCampList.m_dwCampID;
lpPktAck->m_dwTempMoney = ShopCampList.m_dwTempMoney;
lpPktAck->m_cTax = ShopCampList.m_cTax;
lpPktAck->m_dwServerGroup = lpPktShopCamp->m_dwServerGroup;
memcpy(lpPktAck->m_szItem, ShopCampList.m_szItem, sizeof(char) * PktAdminMgr::MAX_ITEM_BUFFER);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktShopCampAck), PktAdminMgr::PktCMD::PktShopCampAck, 0, 0);
ZeroMemory(&ShopCampList, sizeof(In_ShopCampList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktShopCampGold(PktBase* lpPktBase)
{
PktAdminMgr::PktShopCampGold* lpPktShopCampGold = static_cast<PktAdminMgr::PktShopCampGold*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, "Update tblCampShopInfo Set TempMoney = %u where CampID = %u", lpPktShopCampGold->m_dwTempMoney, lpPktShopCampGold->m_dwCampID);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktShopCampGold->m_dwServerGroup);
if(NULL != lpGameDB)
{
if(false == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktShopCampTax(PktBase* lpPktBase)
{
PktAdminMgr::PktShopCampTax* lpPktShopCampTax = static_cast<PktAdminMgr::PktShopCampTax*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, "Update tblCampShopInfo Set Tax = %u where CampID = %u", lpPktShopCampTax->m_dwTax, lpPktShopCampTax->m_dwCampID);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktShopCampTax->m_dwServerGroup);
if(NULL != lpGameDB)
{
if(false == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktCastleSearch(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_CastleList
{
unsigned long m_dwCastleID;
unsigned char m_cNation;
unsigned char m_cZone;
unsigned char m_cChannel;
unsigned char m_cName;
unsigned char m_cSiegeCount;
unsigned char m_cInvincibleCount;
unsigned short m_wTotalSiegeCount;
unsigned long m_dwTotalTaxMoney;
char m_aryRight[CastleRight::MAX_RIGHT_NUM];
float m_fPosInX;
float m_fPosInY;
float m_fPosInZ;
float m_fPosOutX;
float m_fPosOutY;
float m_fPosOutZ;
unsigned short m_wItemID;
unsigned char m_cItemNum;
};
#pragma pack()
PktAdminMgr::PktCastleSearch* lpPktCastleSearch = static_cast<PktAdminMgr::PktCastleSearch*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
switch(lpPktCastleSearch->m_cSearchType)
{
case PktAdminMgr::PktCastleSearch::ALLSERVER_ALLZONE_ALLCASTLE:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u", lpPktCastleSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktCastleSearch::ALLSERVER_ALLZONE_SPECASTLE_ID:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u AND nCastleID = %s", lpPktCastleSearch->m_dwZoneGroup, lpPktCastleSearch->m_szSearchValue);
break;
case PktAdminMgr::PktCastleSearch::ALLSERVER_SPEZONE_ALLCASTLE:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u AND tnZone = %u", lpPktCastleSearch->m_dwZoneGroup, lpPktCastleSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktCastleSearch::ALLSERVER_SPEZONE_SPECASTLE_ID:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u AND nCastleID = %s", lpPktCastleSearch->m_dwZoneGroup, lpPktCastleSearch->m_szSearchValue);
break;
case PktAdminMgr::PktCastleSearch::SPESERVER_ALLZONE_ALLCASTLE:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u", lpPktCastleSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktCastleSearch::SPESERVER_ALLZONE_SPECASTLE_ID:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u AND nCastleID = %s", lpPktCastleSearch->m_dwZoneGroup, lpPktCastleSearch->m_szSearchValue);
break;
case PktAdminMgr::PktCastleSearch::SPESERVER_SPEZONE_ALLCASTLE:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u", lpPktCastleSearch->m_dwZoneGroup);
break;
case PktAdminMgr::PktCastleSearch::SPESERVER_SPEZONE_SPECASTLE_ID:
_snprintf(szWHERE, MAX_WHERE, "WHERE tnZone = %u AND nCastleID = %s", lpPktCastleSearch->m_dwZoneGroup, lpPktCastleSearch->m_szSearchValue);
break;
default:
break;
}
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetCastleInfo, szWHERE);
In_CastleList CastleList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktCastleSearch->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&CastleList, sizeof(In_CastleList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktCastleSearchAck) * 30, &GetSession());
while(lpGameDB->GetData(&CastleList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktCastleSearchAck));
PktAdminMgr::PktCastleSearchAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktCastleSearchAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktCastleSearchAck));
lpPktAck->m_dwServerGroup = lpPktCastleSearch->m_dwServerGroup;
lpPktAck->m_dwCastleID = CastleList.m_dwCastleID;
lpPktAck->m_cNation = CastleList.m_cNation;
lpPktAck->m_cZone = CastleList.m_cZone;
lpPktAck->m_cChannel = CastleList.m_cChannel;
lpPktAck->m_cName = CastleList.m_cName;
lpPktAck->m_cSiegeCount = CastleList.m_cSiegeCount;
lpPktAck->m_cInvincibleCount = CastleList.m_cInvincibleCount;
lpPktAck->m_wTotalSiegeCount = CastleList.m_wTotalSiegeCount;
lpPktAck->m_dwTotalTaxMoney = CastleList.m_dwTotalTaxMoney;
lpPktAck->m_cRight = CastleList.m_aryRight[0];
lpPktAck->m_fPosInX = CastleList.m_fPosInX;
lpPktAck->m_fPosInY = CastleList.m_fPosInY;
lpPktAck->m_fPosInZ = CastleList.m_fPosInZ;
lpPktAck->m_fPosOutX = CastleList.m_fPosOutX;
lpPktAck->m_fPosOutY = CastleList.m_fPosOutY;
lpPktAck->m_fPosOutZ = CastleList.m_fPosOutZ;
lpPktAck->m_wItemID = CastleList.m_wItemID;
lpPktAck->m_cItemNum = CastleList.m_cItemNum;
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktCastleSearchAck), PktAdminMgr::PktCMD::PktCastleSearchAck, 0, 0);
ZeroMemory(&CastleList, sizeof(In_CastleList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktCastleCreature(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_CastleCreatureList
{
unsigned long m_dwCreatureID;
unsigned long m_dwCastleID;
unsigned long m_dwOwnerID;
unsigned long m_dwHP;
unsigned short m_wObjectType;
float m_fDirection;
unsigned char m_cState;
unsigned char m_cSubState;
unsigned char m_cUpgradeStep;
unsigned char m_cUpgradeType;
char m_szRemainTime[PktAdminMgr::MAX_TIME];
char m_szLastUseTime[PktAdminMgr::MAX_TIME];
float m_fPosX;
float m_fPosY;
float m_fPosZ;
};
#pragma pack()
PktAdminMgr::PktCastleCreature* lpPktCastleCreature = static_cast<PktAdminMgr::PktCastleCreature*>(lpPktBase);
bool bExistData = false;
// 검색 타입에 맞는 쿼리 만들기
const int MAX_WHERE = 256;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szWHERE[MAX_WHERE];
_snprintf(szWHERE, MAX_WHERE, "WHERE nCastleID = %u", lpPktCastleCreature->m_dwCastleID);
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetCastleCreatureInfo, szWHERE);
In_CastleCreatureList castleCreatureList;
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktCastleCreature->m_dwServerGroup);
if(NULL != lpGameDB)
{
ZeroMemory(&castleCreatureList, sizeof(In_CastleCreatureList));
if(true == lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(PktAdminMgr::PktCastleSearchAck) * 30, &GetSession());
while(lpGameDB->GetData(&castleCreatureList))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktCastleCreatureAck));
PktAdminMgr::PktCastleCreatureAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktCastleCreatureAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktCastleCreatureAck));
lpPktAck->m_dwCreatureID = castleCreatureList.m_dwCreatureID;
lpPktAck->m_dwCastleID = castleCreatureList.m_dwCastleID;
lpPktAck->m_dwOwnerID = castleCreatureList.m_dwOwnerID;
lpPktAck->m_dwHP = castleCreatureList.m_dwHP;
lpPktAck->m_wObjectType = castleCreatureList.m_wObjectType;
lpPktAck->m_fDirection = castleCreatureList.m_fDirection;
lpPktAck->m_cState = castleCreatureList.m_cState;
lpPktAck->m_cSubState = castleCreatureList.m_cSubState;
lpPktAck->m_cUpgradeStep = castleCreatureList.m_cUpgradeStep;
lpPktAck->m_cUpgradeType = castleCreatureList.m_cUpgradeType;
lpPktAck->m_fPosX = castleCreatureList.m_fPosX;
lpPktAck->m_fPosY = castleCreatureList.m_fPosY;
lpPktAck->m_fPosZ = castleCreatureList.m_fPosZ;
strncpy(lpPktAck->m_szRemainTime, castleCreatureList.m_szRemainTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szLastUseTime, castleCreatureList.m_szLastUseTime, PktAdminMgr::MAX_TIME);
PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktCastleCreatureAck), PktAdminMgr::PktCMD::PktCastleCreatureAck, 0, 0);
ZeroMemory(&castleCreatureList, sizeof(In_CastleCreatureList));
bExistData = true;
}
}
else
{
ERRLOG2(g_Log, "쿼리 실패. qry- %s, err- %s", szQuery, lpGameDB->GetErrorString());
}
}
if(!bExistData)
{
//SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktItemQtyControlData(PktBase* lpPktBase)
{
PktAdminMgr::PktItemQtyControl* lpPktItemQtyControl =
static_cast<PktAdminMgr::PktItemQtyControl*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch((unsigned long)lpPktItemQtyControl->m_cServerGroup);
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(lpPktItemQtyControl));
*reinterpret_cast<PktAdminMgr::PktItemQtyControl*>(lpBuffer->wr_ptr()) = *lpPktItemQtyControl;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktItemQtyControl), CmdItemQtyCheck, 0, 0))
{
ERRLOG0(g_Log, "아이템 수량 제어 패킷 랩핑 실패");
bIsReleased = false;
}
else
{
if (false == lpAgentDispatch->Send(lpBuffer))
{
ERRLOG0(g_Log, "아이템 수량 제어 패킷 보내기 실패");
bIsReleased = false;
}
else
{
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[ItemQty Packet Send]");
m_DetailLog.InsertLog(m_MyLogID);
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
bool CRylAdminMgrDispatch::PktSetGold(PktBase* lpPktBase)
{
PktAdminMgr::PktInvenGold* lpPktInvenGold =
reinterpret_cast<PktAdminMgr::PktInvenGold*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktInvenGold->m_dwServerGroup);
if(NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktInvenGold->m_dwCID);
CString strTemp;
strTemp.Format("UID: %u\r\nCID: %u\r\nServerGroup: %u\r\nInventory Gold: %u",
lpPktInvenGold->m_dwUID, lpPktInvenGold->m_dwCID, lpPktInvenGold->m_dwServerGroup, lpCharacter->GetGold());
if(NULL != lpCharacter)
{
if(!lpCharacter->SetGold(lpPktInvenGold->m_dwGold))
{
ERRLOG0(g_Log, "인벤토리 골드 수정 실패");
}
else
{
m_DetailLog.SetBefore("%s", strTemp);
m_DetailLog.SetAfter("Inventory Gold: %u", lpPktInvenGold->m_dwGold);
m_DetailLog.InsertLog(m_MyLogID);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_BASIC);
}
}
else
{
ERRLOG1(g_Log, "CID : %u의 캐릭터 세션 얻기 실패", lpPktInvenGold->m_dwCID);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
}
return true;
}
bool CRylAdminMgrDispatch::PktStoreGoldUpdate(PktBase* lpPktBase)
{
PktAdminMgr::PktStoreGoldUpdate* lpPktStoreGoldUpdate =
reinterpret_cast<PktAdminMgr::PktStoreGoldUpdate*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktStoreGoldUpdate->m_dwServerGroup);
if(NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktStoreGoldUpdate->m_dwCID);
if(NULL != lpCharacter)
{
Item::CDepositContainer& Deposit = lpCharacter->GetDeposit();
if(lpPktStoreGoldUpdate->m_dwGold >= Deposit.GetGold())
{
Deposit.AddGold(lpPktStoreGoldUpdate->m_dwGold - Deposit.GetGold());
}
else
{
Deposit.DeductGold(Deposit.GetGold() - lpPktStoreGoldUpdate->m_dwGold);
}
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_STROE12);
m_DetailLog.SetBefore("UID: %u\r\nServerGroup: %u\r\n\r\nStoreGold: %u",
lpPktStoreGoldUpdate->m_dwUID, lpPktStoreGoldUpdate->m_dwServerGroup, Deposit.GetGold());
m_DetailLog.SetAfter("StoreGold: %u", lpPktStoreGoldUpdate->m_dwGold);
m_DetailLog.InsertLog(m_MyLogID);
}
else
{
ERRLOG1(g_Log, "CID : %u의 캐릭터 세션 얻기 실패", lpPktStoreGoldUpdate->m_dwCID);
}
}
else
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
}
return true;
}
bool CRylAdminMgrDispatch::PktUserBillingLogRequest(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_UserBillingLog
{
char m_szClientID[PktAdminMgr::MAX_ACCOUNT];
unsigned long m_dwUID;
unsigned int m_sServerIndex;
char m_szFirstLoginTime[PktAdminMgr::MAX_TIME];
char m_szLogoutTime[PktAdminMgr::MAX_TIME];
char m_szIP[PktAdminMgr::MAX_IP];
};
#pragma pack()
PktAdminMgr::PktUserBillingLog* lpPktUserBillingLog =
static_cast<PktAdminMgr::PktUserBillingLog*>(lpPktBase);
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
char szFormat[256];
char szTimeFormat[256];
sprintf(szTimeFormat, "FirstLoginTime >= '%d-%d-%d' and FirstLoginTime <= '%d-%d-%d'",
lpPktUserBillingLog->m_tStartTime.GetYear(),
lpPktUserBillingLog->m_tStartTime.GetMonth(),
lpPktUserBillingLog->m_tStartTime.GetDay(),
lpPktUserBillingLog->m_tEndTime.GetYear(),
lpPktUserBillingLog->m_tEndTime.GetMonth(),
lpPktUserBillingLog->m_tEndTime.GetDay());
if(lpPktUserBillingLog->m_cSearchType == PktAdminMgr::PktUserBillingLog::ACCOUNT)
{
sprintf(szFormat, "strClientid = '%s' and %s", lpPktUserBillingLog->m_szSearchValue, szTimeFormat);
}
else if(lpPktUserBillingLog->m_cSearchType == PktAdminMgr::PktUserBillingLog::UID)
{
sprintf(szFormat, "UID = %s and %s", lpPktUserBillingLog->m_szSearchValue, szTimeFormat);
}
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN, QUERYZ::GetUserBillingLog, szFormat);
In_UserBillingLog UserBillingLog;
ZeroMemory(&UserBillingLog, sizeof(In_UserBillingLog));
CBillingDB* lpRYLBillingDB = NULL;
if (0 == strcmp(m_szToolNation, "JAPAN"))
{
lpRYLBillingDB = CAgentServerTable::GetInstance().GetBillingDB();
}
else
{
lpRYLBillingDB = CAgentServerTable::GetInstance().GetBillingLogDB();
}
bool bExistData = false;
if(NULL != lpRYLBillingDB)
{
if(lpRYLBillingDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(In_UserBillingLog) * 40, &GetSession());
while(lpRYLBillingDB->GetData(&UserBillingLog))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktUserBillingLogAck));
if(NULL == lpBuffer) return true;
PktAdminMgr::PktUserBillingLogAck* lpPktAck =
reinterpret_cast<PktAdminMgr::PktUserBillingLogAck*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(PktAdminMgr::PktUserBillingLogAck));
strncpy(lpPktAck->m_szClientID, UserBillingLog.m_szClientID, PktAdminMgr::MAX_ACCOUNT);
lpPktAck->m_dwUID = UserBillingLog.m_dwUID;
strncpy(lpPktAck->m_szIP, UserBillingLog.m_szIP, PktAdminMgr::MAX_IP);
lpPktAck->m_sServerIndex = UserBillingLog.m_sServerIndex;
strncpy(lpPktAck->m_szFirstLoginTime, UserBillingLog.m_szFirstLoginTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktAck->m_szLogoutTime, UserBillingLog.m_szLogoutTime, PktAdminMgr::MAX_TIME);
PacketWrap::WrapHeader(lpBuffer,sizeof(PktAdminMgr::PktUserBillingLogAck),
PktAdminMgr::PktCMD::PktUserBillingLogAck, 0, 0);
ZeroMemory(&UserBillingLog, sizeof(In_UserBillingLog));
bExistData = true;
}
}
}
if (false == bExistData)
{
SendResult(PktAdminMgr::PktResult::Result_Null);
}
return true;
}
bool CRylAdminMgrDispatch::PktGameAdmin(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_GameAdminInfo
{
unsigned long m_dwUID;
unsigned int m_nLevel;
char m_szIP_S[PktAdminMgr::MAX_IP];
char m_szIP_E[PktAdminMgr::MAX_IP];
};
#pragma pack()
PktAdminMgr::PktGameAdmin* lpPktGameAdmin = static_cast<PktAdminMgr::PktGameAdmin*>(lpPktBase);
CString strAfterLog;
char szQuery[CDBAdminTool::QUERY_BUFFER_LEN];
bool bDBReload = false; // 중계서버로 reloadadmin 명령을 내릴지 여부
bool bExistData = false; // 데이터를 요청한 경우 결과값 존재 여부
if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::REG)
{
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN,
"INSERT INTO AdminList(UID, Level, IP_S, IP_E) VALUES(%u, %d, '%s', '%s')",
lpPktGameAdmin->m_dwUID, lpPktGameAdmin->m_nAdminLV,
lpPktGameAdmin->m_szStartIP, lpPktGameAdmin->m_szEndIP);
strAfterLog.Format("[Game Admin Add]\r\nUID: %d\r\nLV: %d\r\nIP_S: %s\r\nIP_E: %s",
lpPktGameAdmin->m_dwUID, lpPktGameAdmin->m_nAdminLV,
lpPktGameAdmin->m_szStartIP, lpPktGameAdmin->m_szEndIP);
}
else if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::EDIT)
{
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN,
"UPDATE AdminList SET Level = %d, IP_S = '%s', IP_E = '%s' WHERE UID = %u",
lpPktGameAdmin->m_nAdminLV, lpPktGameAdmin->m_szStartIP,
lpPktGameAdmin->m_szEndIP, lpPktGameAdmin->m_dwUID);
strAfterLog.Format("[Game Admin Edit]\r\nUID: %d\r\nLV: %d\r\nIP_S: %s\r\nIP_E: %s",
lpPktGameAdmin->m_dwUID, lpPktGameAdmin->m_nAdminLV,
lpPktGameAdmin->m_szStartIP, lpPktGameAdmin->m_szEndIP);
}
else if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::DEL)
{
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN,
"DELETE FROM AdminList WHERE UID = %u", lpPktGameAdmin->m_dwUID);
strAfterLog.Format("[Game Admin Del]\r\nUID: %d", lpPktGameAdmin->m_dwUID);
}
else if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::SEARCH)
{
_snprintf(szQuery, CDBAdminTool::QUERY_BUFFER_LEN,
"SELECT UID, CAST(Level AS INT), IP_S, IP_E FROM AdminList");
}
else
{
SendResult(PktAdminMgr::PktResult::Err_GameAdminManage);
ERRLOG1(g_Log, "게임 운영자 관리 쿼리문 작성 실패 - 올바른 타입의 패킷이 아닙니다.(Type-%c)",
lpPktGameAdmin->m_cPktType);
}
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktGameAdmin->m_dwServerGroup);
if(NULL != lpGameDB)
{
if(lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::SEARCH)
{
In_GameAdminInfo GameAdminInfo;
ZeroMemory(&GameAdminInfo, sizeof(In_GameAdminInfo));
if(lpGameDB->ExecuteQuery(szQuery))
{
CCumulateBuffer cBuffer(sizeof(In_GameAdminInfo) * 20, &GetSession());
while(lpGameDB->GetData(&GameAdminInfo))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktGameAdmin));
if(NULL == lpBuffer) return true;
PktAdminMgr::PktGameAdmin* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGameAdmin*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(lpPktAck));
lpPktAck->m_dwServerGroup = lpPktGameAdmin->m_dwServerGroup;
lpPktAck->m_cPktType = PktAdminMgr::PktGameAdmin::ACK;
lpPktAck->m_dwUID = GameAdminInfo.m_dwUID;
lpPktAck->m_nAdminLV = GameAdminInfo.m_nLevel;
strncpy(lpPktAck->m_szStartIP, GameAdminInfo.m_szIP_S, PktAdminMgr::MAX_IP);
strncpy(lpPktAck->m_szEndIP, GameAdminInfo.m_szIP_E, PktAdminMgr::MAX_IP);
PacketWrap::WrapHeader(lpBuffer,sizeof(PktAdminMgr::PktGameAdmin),
PktAdminMgr::PktCMD::PktGameAdminAck, 0, 0);
ZeroMemory(&GameAdminInfo, sizeof(In_GameAdminInfo));
bExistData = true;
}
}
else
{
ERRLOG0(g_Log, "게임 운영자 리스트 검색 - 쿼리 실행 실패");
}
}
else
{
CCumulateBuffer cBuffer(sizeof(In_GameAdminInfo) * 20, &GetSession());
if(lpGameDB->ExecuteQuery(szQuery))
{
char* lpBuffer = cBuffer.GetBuffer(sizeof(PktAdminMgr::PktGameAdmin));
if(NULL == lpBuffer) return true;
PktAdminMgr::PktGameAdmin* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGameAdmin*>(lpBuffer);
ZeroMemory(lpPktAck, sizeof(lpPktAck));
lpPktAck->m_cPktType = PktAdminMgr::PktGameAdmin::REFRESH;
PacketWrap::WrapHeader(lpBuffer,sizeof(PktAdminMgr::PktGameAdmin),
PktAdminMgr::PktCMD::PktGameAdminAck, 0, 0);
bDBReload = true;
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("%s", strAfterLog);
m_DetailLog.InsertLog(m_MyLogID);
}
else
{
SendResult(PktAdminMgr::PktResult::Err_GameAdminManage);
ERRLOG0(g_Log, "게임 운영자 관리 - 쿼리 실행 실패");
}
}
}
if(bDBReload)
{
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktGameAdmin->m_dwServerGroup);
if (NULL != lpAgentDispatch)
{
PktAgentServer::PktAdminToolSetData* lpPktAdminToolSetData = new PktAgentServer::PktAdminToolSetData;
ZeroMemory(lpPktAdminToolSetData, sizeof(PktAgentServer::PktAdminToolSetData*));
lpPktAdminToolSetData->m_cType = PktAgentServer::PktAdminToolSetData::RELOAD_ADMINLIST;
bool bIsReleased = true;
CBuffer* lpCmdBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAgentServer::PktAdminToolSetData));
if (NULL == lpCmdBuffer) return true;
*reinterpret_cast<PktAgentServer::PktAdminToolSetData*>(lpCmdBuffer->wr_ptr()) = *lpPktAdminToolSetData;
if (false == PacketWrap::WrapHeader(lpCmdBuffer,
sizeof(PktAgentServer::PktAdminToolSetData),CmdAdminToolSetData, 0, 0))
{
ERRLOG0(g_Log, "운영자 리스트 리로드 패킷 랩핑 실패");
bIsReleased = false;
}
else
{
if (false == lpAgentDispatch->Send(lpCmdBuffer))
{
ERRLOG0(g_Log, "운영자 리스트 리로드 패킷 보내기 실패");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpCmdBuffer);
}
delete lpPktAdminToolSetData;
}
else
{
ERRLOG1(g_Log, "중계서버 디스패치 얻기 실패 (Index - %u)", lpPktGameAdmin->m_dwServerGroup);
}
}
if (lpPktGameAdmin->m_cPktType == PktAdminMgr::PktGameAdmin::SEARCH)
{
if(!bExistData)
{
SendResult(PktAdminMgr::PktResult::Result_Null);
}
}
return true;
}
bool CRylAdminMgrDispatch::PktConnectAllServerz(PktBase* lpPktBase)
{
CAgentServerTable::GetInstance().InitAgentServerTable(
*CRylAdminManagerServer::GetInstance().GetIOCPNet());
SendConnectedServerIndex();
return true;
}
bool CRylAdminMgrDispatch::SendConnectedServerIndex(void)
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktConnectAllServerz));
if (NULL == lpBuffer) return true;
PktAdminMgr::PktConnectAllServerz* lpConnectAllServerz = new PktAdminMgr::PktConnectAllServerz;
ZeroMemory(lpConnectAllServerz->m_nConnectedServerIndex, sizeof(lpConnectAllServerz->m_nConnectedServerIndex));
int nArrayIndex = 0;
CAgentServerTable* lpAgentServerTable = &CAgentServerTable::GetInstance();
if (NULL == lpAgentServerTable) return true;
for(unsigned int nIndex = 0; nIndex < CAgentServerTable::MAX_AGENT_SERVER; ++nIndex)
{
if(NULL != lpAgentServerTable->GetDispatch(nIndex)) // 중계서버 연결 체크
{
// 배열 앞부분부터 차례대로 '연결된 서버 인덱스 + 1' 을 대입
lpConnectAllServerz->m_nConnectedServerIndex[nArrayIndex] = nIndex + 1;
++nArrayIndex;
}
}
*reinterpret_cast<PktAdminMgr::PktConnectAllServerz*>(lpBuffer->wr_ptr()) = *lpConnectAllServerz;
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktConnectAllServerz), PktAdminMgr::PktCMD::PktRefreshConnectedList, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
delete lpConnectAllServerz;
return true;
}
bool CRylAdminMgrDispatch::PktInterestedUser(PktBase* lpPktBase)
{
PktAdminMgr::PktInterestedUser* lpPktInterestedUser =
reinterpret_cast<PktAdminMgr::PktInterestedUser*>(lpPktBase);
bool bResult = true;
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
switch(lpPktInterestedUser->m_cPktType)
{
case PktAdminMgr::PktInterestedUser::ADD_USER:
{
unsigned int* nCount = 0;
char szCountQuery[256];
_snprintf(szCountQuery, 256,
"SELECT COUNT(strAccount) FROM TblInterestedUser WHERE intUID = %d", m_MyUID);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szCountQuery))
{
if(CDBAdminTool::GetInstance().GetData(nCount))
{
if(*nCount >= 30)
{
// 관심 유저는 30명 이상 등록 불가능
ERRLOG0(g_Log, "30명 이상의 관심유저를 등록하려 시도");
return true;
}
}
else
{
ERRLOG1(g_Log, "관심유저 수 카운트 쿼리 실패: %s", szCountQuery);
return true;
}
}
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"INSERT INTO TblInterestedUser(intUID, strAccount, strReason) VALUES(%d, '%s', '%s')",
m_MyUID, lpPktInterestedUser->m_szAccount, lpPktInterestedUser->m_szReason);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "관심 유저 등록 실패: %s, err: %s",
szQuery, CDBAdminTool::GetInstance().GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_InterestedUserManage);
}
}
break;
case PktAdminMgr::PktInterestedUser::REMOVE_USER:
{
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"DELETE FROM TblInterestedUser WHERE strAccount = '%s'",
lpPktInterestedUser->m_szAccount);
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "관심 유저 삭제 실패: %s, err: %s",
szQuery, CDBAdminTool::GetInstance().GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_InterestedUserManage);
}
}
break;
case PktAdminMgr::PktInterestedUser::REQUEST_LIST:
{
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT strAccount, strReason FROM TblInterestedUser WHERE intUID = %d", m_MyUID);
ReqInterestedUserList(szQuery);
}
break;
default:
{
ERRLOG1(g_Log, "알맞은 패킷 타입이 아닙니다: Type - %d", lpPktInterestedUser->m_cPktType);
}
break;
}
return true;
}
bool CRylAdminMgrDispatch::ReqInterestedUserList(char* szQuery)
{
#pragma pack(1)
struct InterestedUserList
{
char m_szAccount[PktAdminMgr::MAX_ACCOUNT];
char m_szReason[MAX_PATH];
};
#pragma pack()
InterestedUserList GetList;
if(!CDBAdminTool::GetInstance().ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패: query-%s, err-%s",
szQuery, CDBAdminTool::GetInstance().GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_InterestedUserManage);
}
else
{
ZeroMemory(&GetList, sizeof(InterestedUserList));
while(CDBAdminTool::GetInstance().GetData(&GetList))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktInterestedUser));
if (NULL == lpBuffer) return true;
PktAdminMgr::PktInterestedUser* lpPktInterestedUser =
reinterpret_cast<PktAdminMgr::PktInterestedUser*>(lpBuffer->begin());
strncpy(lpPktInterestedUser->m_szAccount, GetList.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
strncpy(lpPktInterestedUser->m_szReason, GetList.m_szReason, MAX_PATH);
ZeroMemory(&GetList, sizeof(InterestedUserList));
if (false == PacketWrap::WrapHeader(lpBuffer, sizeof(PktAdminMgr::PktInterestedUser),
PktAdminMgr::PktCMD::PktInterestedUser, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktConnectionChk(PktBase* lpPktBase)
{
#pragma pack(1)
struct ConnectionInfo
{
char m_szAccount[PktAdminMgr::MAX_ACCOUNT];
unsigned long m_dwUID;
char m_szIP[15];
unsigned int m_dwServerGroup;
char m_szFirstLoginTime[20];
};
#pragma pack()
PktAdminMgr::PktConnectionChk* lpPktConnectionChk =
reinterpret_cast<PktAdminMgr::PktConnectionChk*>(lpPktBase);
// edith 2009.08.14 관심유저 버그수정 (ROW_Activity DB사용)
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT strClientID, UID, strIP, CAST(tinyServerID AS INT), CONVERT(VARCHAR(20), FirstLoginTime, 120) "
"FROM TblCurrentUser WHERE strClientID = '%s'",
lpPktConnectionChk->m_szAccount);
CBillingDB* lpBillingDB = CAgentServerTable::GetInstance().GetBillingDB();
if(NULL != lpBillingDB)
{
ConnectionInfo GetInfo;
if(!lpBillingDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패: query-%s, err-%s",
szQuery, lpBillingDB->GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
}
else
{
ZeroMemory(&GetInfo, sizeof(ConnectionInfo));
while(lpBillingDB->GetData(&GetInfo))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktConnectionChk));
if(0 != lpBuffer)
{
PktAdminMgr::PktConnectionChk* lpPktConnectionChk =
reinterpret_cast<PktAdminMgr::PktConnectionChk*>(lpBuffer);
strncpy(lpPktConnectionChk->m_szAccount, GetInfo.m_szAccount, PktAdminMgr::MAX_ACCOUNT);
lpPktConnectionChk->m_dwUID = GetInfo.m_dwUID;
strncpy(lpPktConnectionChk->m_szLoginIP, GetInfo.m_szIP, 15);
lpPktConnectionChk->m_nServerGroup = GetInfo.m_dwServerGroup;
strncpy(lpPktConnectionChk->m_szLoginTime, GetInfo.m_szFirstLoginTime, 20);
ZeroMemory(&GetInfo, sizeof(ConnectionInfo));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktConnectionChk),
PktAdminMgr::PktCMD::PktConnectionChk, 0, 0);
}
}
}
}
else
{
ERRLOG0(g_Log, "빌링 디비 세션 얻기 실패");
}
return true;
}
bool CRylAdminMgrDispatch::PktConnectedUserList()
{
char szAccount[PktAdminMgr::MAX_ACCOUNT];
// 관심 유저 그룹 만들기 ex) 10923, 14152, 14131, 0
CString strUIDGroup;
char szTempQuery[MAX_PATH];
_snprintf(szTempQuery, MAX_PATH,
"SELECT strAccount FROM TblInterestedUser WHERE intUID = %d", m_MyUID);
if(CDBAdminTool::GetInstance().ExecuteQuery(szTempQuery))
{
ZeroMemory(szAccount, PktAdminMgr::MAX_ACCOUNT);
while(CDBAdminTool::GetInstance().GetData(szAccount))
{
strUIDGroup.AppendFormat("'%s', ", szAccount);
ZeroMemory(szAccount, PktAdminMgr::MAX_ACCOUNT);
}
if(strUIDGroup.IsEmpty()) return true; // 관심 유저가 없는 경우
strUIDGroup.Append("'0'");
}
else
{
ERRLOG2(g_Log, "쿼리 실패: query- %s, err- %s", szTempQuery,
CDBAdminTool::GetInstance().GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
return true;
}
// edith 2009.08.14 관심유저 버그수정 (ROW_Activity DB사용)
// 접속한 관심 유저의 계정명 보내기
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT strClientID FROM TblCurrentUser WHERE strClientID IN (%s)", strUIDGroup);
CBillingDB* lpBillingDB = CAgentServerTable::GetInstance().GetBillingDB();
if(NULL != lpBillingDB)
{
if(!lpBillingDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패: query- %s, err- %s",
szQuery, lpBillingDB->GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
}
else
{
const int MAX_NAME_NUM = 300;
const int MAX_NAME_BUFFER = PktAdminMgr::MAX_ACCOUNT * MAX_NAME_NUM;
if (MAX_NAME_BUFFER < 15000)
{
CBuffer* lpBuffer =
CREATE_BUFFER(GetBufferFactory(), sizeof(PktBase) + MAX_NAME_BUFFER);
if(0 != lpBuffer)
{
int nGetRowsNum = 0;
memset(lpBuffer->wr_ptr(), 0, lpBuffer->capacity());
PktBase* lpPktBase = reinterpret_cast<PktBase*>(lpBuffer->wr_ptr());
char* szWritePos = lpBuffer->wr_ptr() + sizeof(PktBase);
int nSendCount = 0;
while(lpBillingDB->GetData((void**)szWritePos,
PktAdminMgr::MAX_ACCOUNT, MAX_NAME_NUM, &nGetRowsNum))
{
if (0 == nGetRowsNum)
{
break;
}
++nSendCount;
GetSendStream().WrapCompress(lpBuffer->wr_ptr(),
static_cast<unsigned short>(sizeof(PktBase) + sizeof(char) *
PktAdminMgr::MAX_ACCOUNT * nGetRowsNum),
PktAdminMgr::PktCMD::PktConnectedUserList, 0, 0);
}
if (0 == nSendCount)
{
GetSendStream().WrapCompress(lpBuffer->wr_ptr(),
static_cast<unsigned short>(sizeof(PktBase)),
PktAdminMgr::PktCMD::PktConnectedUserList, 0, 0);
}
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
}
}
else
{
ERRLOG0(g_Log, "빌링 디비 세션 얻기 실패");
}
return true;
}
bool CRylAdminMgrDispatch::PktDuplicatedItem(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_DuplicatedItemData
{
char m_szInsertTime[PktAdminMgr::MAX_TIME];
char m_szUpdateTime[PktAdminMgr::MAX_TIME];
unsigned long m_dwUID;
unsigned long m_dwCID;
unsigned __int64 m_dwItemUID;
char m_szCharName[PktAdminMgr::MAX_NAME];
int m_nQty;
int m_nChk;
};
#pragma pack()
bool bExistData = false;
PktAdminMgr::PktDuplicatedItem* lpPktDuplicatedItem =
reinterpret_cast<PktAdminMgr::PktDuplicatedItem*>(lpPktBase);
unsigned long dwSearchGroup = lpPktDuplicatedItem->m_dwServerGroup;
if (PktAdminMgr::PktDuplicatedItem::SEARCH == lpPktDuplicatedItem->m_cPktType)
{
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT CONVERT(VARCHAR(20), InsertTime, 120), CONVERT(VARCHAR(20), UpdateTime, 120), "
"UID, CID, ItemSerial, CharName, Qty, CAST(CheckField AS INT) FROM TblItemLog WHERE CheckField = %d",
lpPktDuplicatedItem->m_bChk ? 0 : 1);
CGameDB* lpGameDB =
CAgentServerTable::GetInstance().GetGameDB(dwSearchGroup);
if (NULL != lpGameDB)
{
if (false == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패: query-%s, err-%s",
szQuery, lpGameDB->GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
}
else
{
In_DuplicatedItemData In_Data;
ZeroMemory(&In_Data, sizeof(In_DuplicatedItemData));
while(true == lpGameDB->GetData(&In_Data))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktDuplicatedItem));
if(0 != lpBuffer)
{
PktAdminMgr::PktDuplicatedItem* lpPktDuplicatedItem =
reinterpret_cast<PktAdminMgr::PktDuplicatedItem*>(lpBuffer);
lpPktDuplicatedItem->m_cPktType = PktAdminMgr::PktDuplicatedItem::RESULT_LIST;
lpPktDuplicatedItem->m_dwServerGroup = dwSearchGroup;
strncpy(lpPktDuplicatedItem->m_szInsertTime,
In_Data.m_szInsertTime, PktAdminMgr::MAX_TIME);
strncpy(lpPktDuplicatedItem->m_szUpdateTime,
In_Data.m_szUpdateTime, PktAdminMgr::MAX_TIME);
lpPktDuplicatedItem->m_dwUID = In_Data.m_dwUID;
lpPktDuplicatedItem->m_dwCID = In_Data.m_dwCID;
lpPktDuplicatedItem->m_dwItemUID = In_Data.m_dwItemUID;
strncpy(lpPktDuplicatedItem->m_szCharName,
In_Data.m_szCharName, PktAdminMgr::MAX_NAME);
lpPktDuplicatedItem->m_nQty = In_Data.m_nQty;
lpPktDuplicatedItem->m_bChk = (1 == In_Data.m_nChk) ? true : false;
ZeroMemory(&In_Data, sizeof(In_DuplicatedItemData));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktDuplicatedItem),
PktAdminMgr::PktCMD::PktDuplicatedItem, 0, 0);
bExistData = true;
}
}
}
}
}
else if(lpPktDuplicatedItem->m_cPktType == PktAdminMgr::PktDuplicatedItem::CHK)
{
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"USP_UpdateCheckField_ItemLog %u, %u, %I64d",
lpPktDuplicatedItem->m_dwUID, lpPktDuplicatedItem->m_dwCID, lpPktDuplicatedItem->m_dwItemUID);
CGameDB* lpGameDB =
CAgentServerTable::GetInstance().GetGameDB(lpPktDuplicatedItem->m_dwServerGroup);
if (NULL != lpGameDB)
{
if (false == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "프로시저 실행 실패: query-%s, err-%s",
szQuery, lpGameDB->GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
}
else
{
SendResult(PktAdminMgr::PktResult::Success_ChkDuplicatedItem);
}
}
}
if(lpPktDuplicatedItem->m_cPktType == PktAdminMgr::PktDuplicatedItem::SEARCH)
{
if(!bExistData)
{
SendResult(PktAdminMgr::PktResult::Result_Null);
}
}
return true;
}
bool CRylAdminMgrDispatch::PktItemDistribute(PktBase* lpPktBase)
{
PktAdminMgr::PktItemDistribute* lpPktItemDistribute =
reinterpret_cast<PktAdminMgr::PktItemDistribute*>(lpPktBase);
const unsigned char MAX_USER_NUM = lpPktItemDistribute->m_cUserNum;
PktAdminMgr::DstUserInfo* lpDstUserInfo =
reinterpret_cast<PktAdminMgr::DstUserInfo*>(lpPktItemDistribute + 1);
CCharacter tempChar(lpDstUserInfo->m_dwCID, 0);
TEMPINVEN tempInvenData;
Item::CTempInvenContainer tempInven;
Item::CItem* lpInsertItem = 0;
const Item::ItemInfo* lpItemInfo = 0;
unsigned char cError = 0;
if(!tempInven.Initialize(&tempChar, Item::MAX_TEMP_INVEN_ITEM_NUM))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_CREATE_TEMPINVEN_OBJ;
ERRLOG0(g_Log, "임시 인벤 객체 초기화 실패");
}
else if(NULL == (lpItemInfo =
Item::CItemMgr::GetInstance().GetItemInfoFromItemName(
lpPktItemDistribute->m_stDistributeItem.m_szItemName)))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_GET_ITEMINFO;
ERRLOG1(g_Log, "아이템 이름으로 아이템 정보 얻기 실패. 아이템 명: %s",
lpPktItemDistribute->m_stDistributeItem.m_szItemName);
}
else
{
for(unsigned char cUserCount = 0; cUserCount < MAX_USER_NUM; ++cUserCount, ++lpDstUserInfo)
{
CGameDB* lpGameDB =
CAgentServerTable::GetInstance().GetGameDB(lpDstUserInfo->m_dwServerGroup);
if(NULL == lpGameDB)
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_GET_GAMEDB;
ERRLOG1(g_Log, "게임 디비 얻기 실패. 서버그룹: %u", lpDstUserInfo->m_dwServerGroup);
}
else
{
memset(&tempInvenData, 0, sizeof(TEMPINVEN));
if(!DBComponent::GameDB::GetTempInven(*lpGameDB, lpDstUserInfo->m_dwCID, &tempInvenData))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_GET_TEMPINVEN_OBJ;
ERRLOG3(g_Log, "임시 인벤 객체 얻기 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else if(!tempInven.SerializeIn(tempInvenData.Data, tempInvenData.dwSize))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_SERIALIZE_IN;
ERRLOG3(g_Log, "임시 인벤 시리얼라이즈 인 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else if(0 == (lpInsertItem =
Item::CItemFactory::GetInstance().CreateItem(lpItemInfo->m_usProtoTypeID)))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_CREATE_ITEM_OBJ;
ERRLOG3(g_Log, "새 아이템 객체 생성 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else
{
lpInsertItem->SetNumOrDurability(lpPktItemDistribute->m_stDistributeItem.m_cNumOrDurability);
Item::CEquipment* lpEquipment = Item::CEquipment::DowncastToEquipment(lpInsertItem);
if(NULL != lpEquipment)
{
CModifyEquipment* lpModifyEquipment = static_cast<CModifyEquipment*>(lpEquipment);
lpModifyEquipment->AdjustData(lpPktItemDistribute->m_stDistributeItem);
lpModifyEquipment->AddGemAttribute();
lpModifyEquipment->AddUpgradeAttribute();
}
memset(&tempInvenData, 0, sizeof(TEMPINVEN));
tempInvenData.dwSize = TEMPINVEN::MAX_TEMPINVEN_SIZE;
if(!tempInven.SetItem(Item::ItemPos(), lpInsertItem))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_SET_ITEM;
ERRLOG3(g_Log, "임시 인벤 객체에 아이템 셋팅 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else if(!tempInven.SerializeOut(tempInvenData.Data, tempInvenData.dwSize))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_SERIALIZE_OUT;
ERRLOG3(g_Log, "임시 인벤 시리얼라이즈 아웃 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else if(!DBComponent::GameDB::UpdateTempInven(*lpGameDB, lpDstUserInfo->m_dwCID, &tempInvenData))
{
cError = PktAdminMgr::PktItemDistributeAck::FALED_TO_UPDATE_TEMPINVEN;
ERRLOG3(g_Log, "임시 인벤 DB 업데이트 실패. UID: %u, CID: %u, 서버그룹: %u",
lpDstUserInfo->m_dwUID, lpDstUserInfo->m_dwCID, lpDstUserInfo->m_dwServerGroup);
}
else
{
cError = PktAdminMgr::PktItemDistributeAck::SUCCESS;
}
}
}
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktItemDistributeAck));
if(NULL != lpBuffer)
{
PktAdminMgr::PktItemDistributeAck* lpPktItemDistributeAck =
reinterpret_cast<PktAdminMgr::PktItemDistributeAck*>(lpBuffer);
memcpy(&lpPktItemDistributeAck->m_stUserInfo,
lpDstUserInfo, sizeof(PktAdminMgr::DstUserInfo));
lpPktItemDistributeAck->m_cResultType = cError;
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktItemDistributeAck),
PktAdminMgr::PktCMD::PktItemDistributeAck, 0, 0);
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktGuildRight(PktBase* lpPktBase)
{
PktAdminMgr::PktGuildRight* lpPktGuildRight = reinterpret_cast<PktAdminMgr::PktGuildRight*>(lpPktBase);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktGuildRight->m_dwServerGroup);
if(NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB 얻기 실패. 그룹- %d", lpPktGuildRight->m_dwServerGroup);
return true;
}
char szQuery[256] = "";
_snprintf(szQuery, 256,
"SELECT bRight FROM TblGuildInfo WHERE nGuildID = %u", lpPktGuildRight->m_dwGID);
if(false == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "길드 권한 얻어오기 실패. Err-%s. GID-%d",
lpGameDB->GetErrorString(), lpPktGuildRight->m_dwGID);
return true;
}
char szRight[Guild::MAX_RIGHT_SIZE];
memset(szRight, 0, Guild::MAX_RIGHT_SIZE);
if(true == lpGameDB->GetData((void*)szRight))
{
bool bIsReleased = true;
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktGuildRight));
PktAdminMgr::PktGuildRight* lpPktAck =
reinterpret_cast<PktAdminMgr::PktGuildRight*>(lpBuffer->begin());
lpPktAck->m_dwServerGroup = lpPktGuildRight->m_dwServerGroup;
lpPktAck->m_dwGID = lpPktGuildRight->m_dwGID;
memcpy(lpPktAck->m_aryRight, szRight, sizeof(char) * Guild::MAX_RIGHT_SIZE);
if (false == PacketWrap::WrapHeader(lpBuffer,
sizeof(PktAdminMgr::PktGuildRight), PktAdminMgr::PktCMD::PktGuildRight, 0, 0))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
else
{
if (false == GetSession().SendPending(lpBuffer))
{
ERRLOG0(g_Log, "수동으로 패킷을 릴리스합니다.");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
}
memset(szRight, 0, Guild::MAX_RIGHT_SIZE);
return true;
}
bool CRylAdminMgrDispatch::PktUnifiedCharInfo(PktBase* lpPktBase)
{
#pragma pack(1)
struct UnifiedCharInfo
{
unsigned long m_dwUID;
unsigned char m_cOldServerGroup;
unsigned long m_dwBeforeCID;
unsigned long m_dwNewCID;
char m_szBeforeCharName[PktAdminMgr::MAX_NAME];
};
#pragma pack()
PktAdminMgr::PktUnifiedCharInfo* lpPktUnifiedCharInfo =
reinterpret_cast<PktAdminMgr::PktUnifiedCharInfo*>(lpPktBase);
CAuthDB* lpAuthDB = CAgentServerTable::GetInstance().GetAuthDB();
CString strUID;
if (PktAdminMgr::PktUnifiedCharInfo::SEARCH_ACCOUNT == lpPktUnifiedCharInfo->m_cPktType)
{
if (NULL == lpAuthDB)
{
// 계정명으로 검색실패했다고 클라이언트로~
return true;
}
strUID.Format("%u", lpAuthDB->GetUIDFromAccount(lpPktUnifiedCharInfo->m_szSearchValue));
}
else if(PktAdminMgr::PktUnifiedCharInfo::SEARCH_UID == lpPktUnifiedCharInfo->m_cPktType)
{
strUID.Format("%s", lpPktUnifiedCharInfo->m_szSearchValue);
}
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT UID, OldServerGroupID, BeforeCID, NewCID, BeforeCharName "
"FROM TblUnifiedCharList WHERE UID = %s AND OldServerGroupID = %d",
strUID, lpPktUnifiedCharInfo->m_nOldServerGroup);
CGameDB* lpGameDB =
CAgentServerTable::GetInstance().GetGameDB(lpPktUnifiedCharInfo->m_dwServerGroup);
if (NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB를 얻는데 실패했습니다. 그룹-%u", lpPktUnifiedCharInfo->m_dwServerGroup);
return true;
}
if (true == lpGameDB->ExecuteQuery(szQuery))
{
UnifiedCharInfo GetInfo;
ZeroMemory(&GetInfo, sizeof(UnifiedCharInfo));
while(lpGameDB->GetData(&GetInfo))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktUnifiedCharInfo));
if(NULL != lpBuffer)
{
PktAdminMgr::PktUnifiedCharInfo* lpPktUnifiedCharInfo =
reinterpret_cast<PktAdminMgr::PktUnifiedCharInfo*>(lpBuffer);
lpPktUnifiedCharInfo->m_dwUID = GetInfo.m_dwUID;
lpPktUnifiedCharInfo->m_nOldServerGroup = GetInfo.m_cOldServerGroup;
lpPktUnifiedCharInfo->m_dwBeforeCID = GetInfo.m_dwBeforeCID;
lpPktUnifiedCharInfo->m_dwNewCID = GetInfo.m_dwNewCID;
strncpy(lpPktUnifiedCharInfo->m_szBeforeCharName,
GetInfo.m_szBeforeCharName, PktAdminMgr::MAX_NAME);
ZeroMemory(&GetInfo, sizeof(UnifiedCharInfo));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktUnifiedCharInfo),
PktAdminMgr::PktCMD::PktUnifiedCharInfo, 0, 0);
}
}
}
else
{
ERRLOG1(g_Log, "쿼리 실패. 쿼리-%s", szQuery);
return true;
}
return true;
}
bool CRylAdminMgrDispatch::PktCancelExecuteQuest(PktBase* lpPktBase)
{
PktAdminMgr::PktCancelExecuteQuest* lpPktCancelExecuteQuest =
static_cast<PktAdminMgr::PktCancelExecuteQuest*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktCancelExecuteQuest->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktCancelExecuteQuest->m_dwCID);
if(NULL == lpCharacter)
{
ERRLOG0(g_Log, "캐릭터 세션 얻기 실패");
return true;
}
if (true == lpCharacter->CancelQuest(lpPktCancelExecuteQuest->m_wQuestID, true))
{
lpCharacter->SetQuestData();
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[ExecuteQuest Cancel]\r\nQID: %u", lpPktCancelExecuteQuest->m_wQuestID);
m_DetailLog.InsertLog(m_MyLogID);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktCancelExecuteQuest));
if(NULL != lpBuffer)
{
PktAdminMgr::PktCancelExecuteQuest* lpAck =
reinterpret_cast<PktAdminMgr::PktCancelExecuteQuest*>(lpBuffer);
memcpy(lpAck, lpPktCancelExecuteQuest, sizeof(PktAdminMgr::PktCancelExecuteQuest));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktCancelExecuteQuest),
PktAdminMgr::PktCMD::PktCancelExecuteQuest, 0, 0);
}
SendResult(PktAdminMgr::PktResult::Success_DeleteQuest);
}
else
{
SendResult(PktAdminMgr::PktResult::Err_DeleteQuest);
}
return true;
}
bool CRylAdminMgrDispatch::PktDeleteHistoryQuest(PktBase* lpPktBase)
{
PktAdminMgr::PktDeleteHistoryQuest* lpPktDeleteHistoryQuest =
static_cast<PktAdminMgr::PktDeleteHistoryQuest*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktDeleteHistoryQuest->m_dwServerGroup);
if (NULL == lpAgentDispatch)
{
ERRLOG0(g_Log, "중계서버 디스패치 얻기 실패");
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktDeleteHistoryQuest->m_dwCID);
if (NULL == lpCharacter)
{
ERRLOG0(g_Log, "캐릭터 세션 얻기 실패");
return true;
}
if (true == lpCharacter->DeleteHistoryQuest(lpPktDeleteHistoryQuest->m_wQuestID))
{
lpCharacter->SetQuestData();
m_DetailLog.SetBefore("not exist contents");
m_DetailLog.SetAfter("[HistoryQuest Cancel]\r\nQID: %u", lpPktDeleteHistoryQuest->m_wQuestID);
m_DetailLog.InsertLog(m_MyLogID);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktDeleteHistoryQuest));
if (NULL != lpBuffer)
{
PktAdminMgr::PktDeleteHistoryQuest* lpAck =
reinterpret_cast<PktAdminMgr::PktDeleteHistoryQuest*>(lpBuffer);
memcpy(lpAck, lpPktDeleteHistoryQuest, sizeof(PktAdminMgr::PktDeleteHistoryQuest));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktDeleteHistoryQuest),
PktAdminMgr::PktCMD::PktDeleteHistoryQuest, 0, 0);
}
SendResult(PktAdminMgr::PktResult::Success_DeleteQuest);
}
else
{
SendResult(PktAdminMgr::PktResult::Err_DeleteQuest);
}
return true;
}
bool CRylAdminMgrDispatch::PktUnifiedGuildInfo(PktBase* lpPktBase)
{
#pragma pack(1)
struct UnifiedGuildInfo
{
unsigned long m_dwBeforeGID;
unsigned char m_cOldServerGroupID;
unsigned long m_dwNewGID;
char m_szBeforeGName[PktAdminMgr::MAX_NAME];
char m_szNewGName[PktAdminMgr::MAX_NAME];
};
#pragma pack()
PktAdminMgr::PktUnifiedGuildInfo* lpPktUnifiedGuildInfo =
reinterpret_cast<PktAdminMgr::PktUnifiedGuildInfo*>(lpPktBase);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktUnifiedGuildInfo->m_dwServerGroup);
if (NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB를 얻는데 실패했습니다. 그룹-%u", lpPktUnifiedGuildInfo->m_dwServerGroup);
return true;
}
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT BeforeGuildID, OldServerGroupID, NewGuildID, BeforeGName, NewGName "
"FROM TblUnifiedGuildList WHERE OldServerGroupID = %d",
lpPktUnifiedGuildInfo->m_nOldServerGroupID);
if (true == lpGameDB->ExecuteQuery(szQuery))
{
UnifiedGuildInfo GetInfo;
ZeroMemory(&GetInfo, sizeof(UnifiedGuildInfo));
while(true == lpGameDB->GetData(&GetInfo))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktUnifiedGuildInfo));
if(NULL != lpBuffer)
{
PktAdminMgr::PktUnifiedGuildInfo* lpPktUnifiedGuildInfo =
reinterpret_cast<PktAdminMgr::PktUnifiedGuildInfo*>(lpBuffer);
lpPktUnifiedGuildInfo->m_cPktType = PktAdminMgr::PktUnifiedGuildInfo::RESULT;
lpPktUnifiedGuildInfo->m_dwBeforeGID = GetInfo.m_dwBeforeGID;
lpPktUnifiedGuildInfo->m_nOldServerGroupID = GetInfo.m_cOldServerGroupID;
lpPktUnifiedGuildInfo->m_dwNewGID = GetInfo.m_dwNewGID;
strncpy(lpPktUnifiedGuildInfo->m_szBeforeGName,
GetInfo.m_szBeforeGName, PktAdminMgr::MAX_NAME);
strncpy(lpPktUnifiedGuildInfo->m_szNewGName,
GetInfo.m_szNewGName, PktAdminMgr::MAX_NAME);
ZeroMemory(&GetInfo, sizeof(UnifiedGuildInfo));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktUnifiedGuildInfo),
PktAdminMgr::PktCMD::PktUnifiedGuildInfo, 0, 0);
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktUserNation(PktBase* lpPktBase)
{
PktAdminMgr::PktUserNation* lpPktUserNation = reinterpret_cast<PktAdminMgr::PktUserNation*>(lpPktBase);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktUserNation->m_dwServerGroup);
if (NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB를 얻는데 실패했습니다. 그룹-%u", lpPktUserNation->m_dwServerGroup);
return true;
}
unsigned char cNation = 0;
if (true == lpGameDB->GetUserNation(
m_nAgentType, lpPktUserNation->m_dwUID, lpPktUserNation->m_dwCID, &cNation))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktUserNation));
if(NULL != lpBuffer)
{
PktAdminMgr::PktUserNation* lpPktUserNationAck =
reinterpret_cast<PktAdminMgr::PktUserNation*>(lpBuffer);
lpPktUserNationAck->m_dwRequestKey = lpPktUserNation->m_dwRequestKey;
lpPktUserNationAck->m_dwUID = lpPktUserNation->m_dwUID;
lpPktUserNationAck->m_dwCID = lpPktUserNation->m_dwCID;
lpPktUserNationAck->m_cNation = cNation;
cNation = 0;
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktUserNation),
PktAdminMgr::PktCMD::PktUserNation, 0, 0);
}
}
return true;
}
bool CRylAdminMgrDispatch::PktDetailCharInfo(PktBase* lpPktBase)
{
#pragma pack(1)
struct DetailCharInfo
{
unsigned long m_dwCID;
char m_szCharName[PktAdminMgr::MAX_CHARNAME];
unsigned short m_sClass;
unsigned long m_dwFame;
unsigned long m_dwMileage;
unsigned char m_cLevel;
unsigned long m_dwGold;
unsigned __int64 m_i64Exp;
};
#pragma pack()
PktAdminMgr::PktDetailCharInfo* lpPktDetailCharInfo =
reinterpret_cast<PktAdminMgr::PktDetailCharInfo*>(lpPktBase);
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT CID, Name, Class, Fame, Mileage, Level, Gold, Exp FROM CharInfo WHERE CID = %u",
lpPktDetailCharInfo->m_dwCID);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpPktDetailCharInfo->m_dwServerGroup);
if (NULL == lpGameDB)
{
ERRLOG1(g_Log, "게임 DB를 얻는데 실패했습니다. 그룹-%u", lpPktDetailCharInfo->m_dwServerGroup);
return true;
}
if (true == lpGameDB->ExecuteQuery(szQuery))
{
DetailCharInfo GetInfo;
ZeroMemory(&GetInfo, sizeof(DetailCharInfo));
while(true == lpGameDB->GetData(&GetInfo))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktDetailCharInfo));
if (NULL != lpBuffer)
{
PktAdminMgr::PktDetailCharInfo* lpPktDetailCharInfo =
reinterpret_cast<PktAdminMgr::PktDetailCharInfo*>(lpBuffer);
lpPktDetailCharInfo->m_dwCID = GetInfo.m_dwCID;
lpPktDetailCharInfo->m_sClass = GetInfo.m_sClass;
lpPktDetailCharInfo->m_dwFame = GetInfo.m_dwFame;
lpPktDetailCharInfo->m_dwMileage = GetInfo.m_dwMileage;
lpPktDetailCharInfo->m_cLevel = GetInfo.m_cLevel;
lpPktDetailCharInfo->m_dwGold = GetInfo.m_dwGold;
lpPktDetailCharInfo->m_i64Exp = GetInfo.m_i64Exp;
strncpy(lpPktDetailCharInfo->m_szCharName, GetInfo.m_szCharName, PktAdminMgr::MAX_CHARNAME);
ZeroMemory(&GetInfo, sizeof(DetailCharInfo));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktDetailCharInfo),
PktAdminMgr::PktCMD::PktDetailCharInfo, 0, 0);
}
}
}
return true;
}
bool CRylAdminMgrDispatch::PktShiftToUID(PktBase* lpPktBase)
{
PktAdminMgr::PktShiftToUID* lpPktShiftToUID =
reinterpret_cast<PktAdminMgr::PktShiftToUID*>(lpPktBase);
bool IsGeted = false;
unsigned long dwUID = 0;
char szAccount[PktAdminMgr::MAX_ACCOUNT] = "";
CAuthDB* lpAuthDB = CAgentServerTable::GetInstance().GetAuthDB();
if (NULL != lpAuthDB)
{
if (PktAdminMgr::PktShiftToUID::UID_TO_ACCOUNT == lpPktShiftToUID->m_cPktType)
{
IsGeted = lpAuthDB->GetAccountFromUID(lpPktShiftToUID->m_dwUID, szAccount);
}
else if (PktAdminMgr::PktShiftToUID::ACCOUNT_TO_UID == lpPktShiftToUID->m_cPktType)
{
dwUID = lpAuthDB->GetUIDFromAccount(lpPktShiftToUID->m_szAccount);
}
}
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktShiftToUID));
if (NULL != lpBuffer)
{
PktAdminMgr::PktShiftToUID* lpPktShiftToUIDAck =
reinterpret_cast<PktAdminMgr::PktShiftToUID*>(lpBuffer);
lpPktShiftToUIDAck->m_cPktType = lpPktShiftToUID->m_cPktType;
lpPktShiftToUIDAck->m_dwUID = dwUID;
if (true == IsGeted)
{
strncpy(lpPktShiftToUIDAck->m_szAccount, szAccount, PktAdminMgr::MAX_ACCOUNT);
}
else
{
strncpy(lpPktShiftToUIDAck->m_szAccount, "Not exist", PktAdminMgr::MAX_ACCOUNT);
}
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktShiftToUID),
PktAdminMgr::PktCMD::PktShiftToUID, 0, 0);
}
return true;
}
bool CRylAdminMgrDispatch::PktStoreTabEdit(PktBase* lpPktBase)
{
PktAdminMgr::PktStoreTabEdit* lpPktStoreEdit =
reinterpret_cast<PktAdminMgr::PktStoreTabEdit*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktStoreEdit->m_dwServerGroup);
if (NULL != lpAgentDispatch)
{
CModifyCharacter* lpCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktStoreEdit->m_dwCID);
if ((NULL != lpCharacter) && (lpPktStoreEdit->m_nTabNum < 5))
{
Item::CDepositContainer& DepositContainer = lpCharacter->GetDeposit();
m_DetailLog.SetBefore("[Store Tab Edit]\nBefore Tab Num: %d", DepositContainer.GetMaxTabNum());
unsigned long dwTabFlag = 0;
switch(lpPktStoreEdit->m_nTabNum)
{
case 1:
dwTabFlag =
PktDepositUpdateDB::ITEM_TAB1 | PktDepositUpdateDB::USED_DEPOSIT;
case 2:
dwTabFlag =
PktDepositUpdateDB::ITEM_TAB1 | PktDepositUpdateDB::ITEM_TAB2
| PktDepositUpdateDB::USED_DEPOSIT;
break;
case 3:
dwTabFlag =
PktDepositUpdateDB::ITEM_TAB1 | PktDepositUpdateDB::ITEM_TAB2
| PktDepositUpdateDB::ITEM_TAB3 | PktDepositUpdateDB::USED_DEPOSIT;
break;
case 4:
dwTabFlag =
PktDepositUpdateDB::ITEM_TAB1 | PktDepositUpdateDB::ITEM_TAB2
| PktDepositUpdateDB::ITEM_TAB3 | PktDepositUpdateDB::ITEM_TAB4
| PktDepositUpdateDB::USED_DEPOSIT;
break;
default:
dwTabFlag =
PktDepositUpdateDB::ITEM_TAB1 | PktDepositUpdateDB::ITEM_TAB2
| PktDepositUpdateDB::ITEM_TAB3 | PktDepositUpdateDB::ITEM_TAB4
| PktDepositUpdateDB::USED_DEPOSIT;
break;
}
DepositContainer.SetTabFlag(dwTabFlag);
m_DetailLog.SetAfter("After Tab Num: %d", lpPktStoreEdit->m_nTabNum);
m_DetailLog.InsertLog(m_MyLogID);
// 성공 결과 보내기
SendResult(PktAdminMgr::PktResult::Success_StoreTabEdit);
lpCharacter->OnChangedInfo(CModifyCharacter::ON_EXTRA);
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktStoreTabEdit));
if (NULL != lpBuffer)
{
PktAdminMgr::PktStoreTabEdit* lpAck =
reinterpret_cast<PktAdminMgr::PktStoreTabEdit*>(lpBuffer);
lpAck->m_dwRequestKey = lpPktStoreEdit->m_dwRequestKey;
lpAck->m_dwServerGroup = dwTabFlag; // Ack일때 용도 변경;
lpAck->m_dwCID = lpPktStoreEdit->m_dwCID;
lpAck->m_nTabNum = lpPktStoreEdit->m_nTabNum;
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktStoreTabEdit),
PktAdminMgr::PktCMD::PktStoreTabEdit, 0, 0);
}
}
else
{
ERRLOG2(g_Log, "캐릭터가 존재하지 않거나 잘못된 탭수입니다. CID: %u, Tab: %u",
lpPktStoreEdit->m_dwCID, lpPktStoreEdit->m_nTabNum);
}
}
return true;
}
bool CRylAdminMgrDispatch::PktAmountOfGold(PktBase* lpPktBase)
{
PktAdminMgr::PktAmountOfGold* lpPktAmountOfGold =
reinterpret_cast<PktAdminMgr::PktAmountOfGold*>(lpPktBase);
// 쿼리 시간이 너무 오래 걸려서 보류~
return true;
}
bool CRylAdminMgrDispatch::PktGMLogMsg(PktBase* lpPktBase)
{
#pragma pack(1)
struct GMLogMsgInfo
{
unsigned long m_dwLogID;
char m_szEditDate[PktAdminMgr::MAX_TIME];
char m_szLogMsg[PktAdminMgr::MAX_LOG];
char m_szAdminID[PktAdminMgr::MAX_ACCOUNT];
};
#pragma pack()
PktAdminMgr::PktGMLogMsg* lpPktGMLogMsg =
reinterpret_cast<PktAdminMgr::PktGMLogMsg*>(lpPktBase);
CDBAdminTool* lpAdminToolDB = &(CDBAdminTool::GetInstance());
if (NULL == lpAdminToolDB)
{
ERRLOG0(g_Log, "운영 DB를 얻는데 실패했습니다");
return true;
}
bool bListRefresh = false;
switch(lpPktGMLogMsg->m_cPktType)
{
case PktAdminMgr::PktGMLogMsg::LOG_CONFIRM:
{
if (true == lpAdminToolDB->IsExistLogMsg(lpPktGMLogMsg))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktGMLogMsg));
if (NULL != lpBuffer)
{
PktAdminMgr::PktGMLogMsg* lpAck =
reinterpret_cast<PktAdminMgr::PktGMLogMsg*>(lpBuffer);
lpAck->m_cPktType = PktAdminMgr::PktGMLogMsg::LOG_CONFIRM;
lpAck->m_dwUID = lpPktGMLogMsg->m_dwUID;
lpAck->m_dwCID = lpPktGMLogMsg->m_dwCID;
lpAck->m_dwServerGroup = lpPktGMLogMsg->m_dwServerGroup;
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktGMLogMsg),
PktAdminMgr::PktCMD::PktGMLogMsg, 0, 0);
}
}
}
break;
case PktAdminMgr::PktGMLogMsg::LOG_SELECT:
{
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
if (0 == lpPktGMLogMsg->m_dwCID)
{
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT LogID, CONVERT(VARCHAR(20), EditDate, 120), LogMsg, AdminID "
"FROM TblGMLogMsg WHERE UID = %u AND CID = 0", lpPktGMLogMsg->m_dwUID);
}
else
{
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT LogID, CONVERT(VARCHAR(20), EditDate, 120), LogMsg, AdminID "
"FROM TblGMLogMsg WHERE CID = %u AND ServerGroupID = %u",
lpPktGMLogMsg->m_dwCID, lpPktGMLogMsg->m_dwServerGroup);
}
if (true == lpAdminToolDB->ExecuteQuery(szQuery))
{
GMLogMsgInfo stGMLogMsgInfo;
ZeroMemory(&stGMLogMsgInfo, sizeof(GMLogMsgInfo));
while(true == lpAdminToolDB->GetData(&stGMLogMsgInfo))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktGMLogMsg));
if(NULL != lpBuffer)
{
PktAdminMgr::PktGMLogMsg* lpAck =
reinterpret_cast<PktAdminMgr::PktGMLogMsg*>(lpBuffer);
lpAck->m_dwLogID = stGMLogMsgInfo.m_dwLogID;
lpAck->m_cPktType = PktAdminMgr::PktGMLogMsg::LOG_SELECT;
lpAck->m_dwUID = lpPktGMLogMsg->m_dwUID;
lpAck->m_dwCID = lpPktGMLogMsg->m_dwCID;
lpAck->m_dwServerGroup = lpPktGMLogMsg->m_dwServerGroup;
strncpy(lpAck->m_szLogMsg, stGMLogMsgInfo.m_szLogMsg, PktAdminMgr::MAX_LOG);
strncpy(lpAck->m_szEditDate, stGMLogMsgInfo.m_szEditDate, PktAdminMgr::MAX_TIME);
strncpy(lpAck->m_szAdminID, stGMLogMsgInfo.m_szAdminID, PktAdminMgr::MAX_ACCOUNT);
ZeroMemory(&stGMLogMsgInfo, sizeof(GMLogMsgInfo));
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktGMLogMsg),
PktAdminMgr::PktCMD::PktGMLogMsg, 0, 0);
}
}
}
else
{
ERRLOG1(g_Log, "GM 로그 셀렉트 실패. 쿼리- %s", lpAdminToolDB->GetErrorString());
}
}
break;
case PktAdminMgr::PktGMLogMsg::LOG_INSERT:
{
if (true == lpAdminToolDB->InsertGMLogMsg(lpPktGMLogMsg, m_szAccount))
{
bListRefresh = true;
}
else
{
ERRLOG0(g_Log, "GM 로그 삽입 실패");
}
}
break;
case PktAdminMgr::PktGMLogMsg::LOG_UPDATE:
{
if (true == lpAdminToolDB->UpdateGMLogMsg(lpPktGMLogMsg, m_szAccount))
{
bListRefresh = true;
}
else
{
ERRLOG0(g_Log, "GM 로그 업데이트 실패");
}
}
break;
case PktAdminMgr::PktGMLogMsg::LOG_DELETE:
{
if (true == lpAdminToolDB->DeleteGMLogMsg(lpPktGMLogMsg))
{
bListRefresh = true;
}
else
{
ERRLOG0(g_Log, "GM 로그 삭제 실패");
}
}
break;
default:
break;
}
// GM 로그 리스트 갱신 (LOG_INSERT, LOG_UPDATE, LOG_DELETE일 경우 Ack)
if (true == bListRefresh)
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktGMLogMsg));
if (NULL != lpBuffer)
{
PktAdminMgr::PktGMLogMsg* lpAck =
reinterpret_cast<PktAdminMgr::PktGMLogMsg*>(lpBuffer);
lpAck->m_cPktType = PktAdminMgr::PktGMLogMsg::LOG_REFRESH;
lpAck->m_dwServerGroup = lpPktGMLogMsg->m_dwServerGroup;
lpAck->m_dwUID = lpPktGMLogMsg->m_dwUID;
lpAck->m_dwCID = lpPktGMLogMsg->m_dwCID;
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktGMLogMsg),
PktAdminMgr::PktCMD::PktGMLogMsg, 0, 0);
}
}
return true;
}
bool CRylAdminMgrDispatch::PktNameChangeCount(PktBase* lpPktBase)
{
PktAdminMgr::PktNameChangeCount* lpPktNameChangeCount =
reinterpret_cast<PktAdminMgr::PktNameChangeCount*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktNameChangeCount->m_dwServerGroup);
if(NULL == lpAgentDispatch)
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CModifyCharacter* lpModifyCharacter =
lpAgentDispatch->GetModifyCharacterMgr().GetCharacter(lpPktNameChangeCount->m_dwCID);
if(NULL == lpModifyCharacter)
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
m_DetailLog.SetBefore("[NameChange Chance]\r\nServerGroup: %u"
"\r\nCID: %u\r\nChance: %d", lpModifyCharacter->GetServerGroup(),
lpModifyCharacter->GetCID(), lpModifyCharacter->GetNameChangeChance());
lpModifyCharacter->SetNameChangeChance(lpPktNameChangeCount->m_cNameChangeCount);
lpModifyCharacter->OnChangedInfo(CModifyCharacter::MASK::ON_EXTRA);
m_DetailLog.SetAfter("Chance: %d", lpModifyCharacter->GetNameChangeCount());
m_DetailLog.InsertLog(m_MyLogID);
SendResult(PktAdminMgr::PktResult::Success_NameChangeCount);
return true;
}
bool CRylAdminMgrDispatch::PktGuildMemberEdit(PktBase* lpPktBase)
{
PktAdminMgr::PktGuildMemberEdit* lpPktGuildMemberEdit =
reinterpret_cast<PktAdminMgr::PktGuildMemberEdit*>(lpPktBase);
CRylAgentServerDispatch* lpAgentDispatch =
CAgentServerTable::GetInstance().GetDispatch(lpPktGuildMemberEdit->m_dwServerGroup);
if (NULL == lpAgentDispatch)
{
SendResult(PktAdminMgr::PktResult::Err_NotFoundAgentDispatch);
return true;
}
CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktGuildPosition));
PktGuildPosition* lpPktGuildPosition = reinterpret_cast<PktGuildPosition*>(lpBuffer->begin());
lpPktGuildPosition->m_dwGID = lpPktGuildMemberEdit->m_dwGID;
lpPktGuildPosition->m_dwCID = lpPktGuildMemberEdit->m_dwCID;
lpPktGuildPosition->m_cPosition = lpPktGuildMemberEdit->m_cPosition;
lpPktGuildPosition->m_cType = lpPktGuildMemberEdit->m_cType;
bool bIsReleased = true;
if (false == PacketWrap::WrapHeader(lpBuffer, sizeof(PktGuildPosition), CmdGuildPosition, 0, 0))
{
ERRLOG0(g_Log, "길드 멤버 관리 패킷 랩핑 실패");
bIsReleased = false;
}
else
{
if (false == lpAgentDispatch->Send(lpBuffer))
{
ERRLOG0(g_Log, "길드 멤버 관리 패킷 보내기 실패");
bIsReleased = false;
}
}
if (false == bIsReleased)
{
SAFE_RELEASE_BUFFER(lpBuffer);
}
return true;
}
// 추가 : 2005-11-17
bool CRylAdminMgrDispatch::PktSearchCharInfoTime(PktBase* lpPktBase)
{
#pragma pack(1)
struct In_DBRowData
{
char m_szCreateTime[PktAdminMgr::MAX_TIME];
char m_szUpdateTime[PktAdminMgr::MAX_TIME];
};
#pragma pack()
using namespace PktAdminMgr;
typedef PktAdminMgr::PktCharInfoTime PktSearchData;
PktSearchData* lpSearch = static_cast<PktSearchData*>(lpPktBase);
char szQuery[CDBAdminTool::MAX_QUERY_LENGTH];
ZeroMemory(szQuery, CDBAdminTool::MAX_QUERY_LENGTH);
CGameDB* lpGameDB = CAgentServerTable::GetInstance().GetGameDB(lpSearch->m_dwServerGroup);
if(NULL == lpGameDB)
{
ERRLOG0(g_Log, "게임DB 핸들 생성 실패");
SendResult(PktAdminMgr::PktResult::Err_Database);
return false;
}
// Query 생성
DWORD dwCID = 0;
if(PktAdminMgr::PktCharInfoTime::Type::SearchName == lpSearch->m_SearchType)
{
if(FALSE == lpGameDB->CharacterNameByCID(lpSearch->m_szName, &dwCID))
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
}
else
{
char szDummy[PktAdminMgr::MAX_CHARNAME];
if(FALSE == lpGameDB->CIDByCharacterName(lpSearch->m_dwCID, szDummy))
{
SendResult(PktAdminMgr::PktResult::Err_Invalid_Character);
return true;
}
dwCID = lpSearch->m_dwCID;
}
_snprintf(szQuery, CDBAdminTool::MAX_QUERY_LENGTH,
"SELECT CONVERT(VARCHAR(20), CreateTime, 120), CONVERT(VARCHAR(20), UpdateTime, 120) "
"FROM CharInfo_Time WHERE CID = %d",
dwCID);
// Process
if(FALSE == lpGameDB->ExecuteQuery(szQuery))
{
ERRLOG2(g_Log, "쿼리 실패: query-%s, err-%s",
szQuery, lpGameDB->GetErrorString());
SendResult(PktAdminMgr::PktResult::Err_Database);
return false;
}
In_DBRowData In_Data;
ZeroMemory(&In_Data, sizeof(In_DBRowData));
while(TRUE == lpGameDB->GetData(&In_Data))
{
CSendStream& SendStream = GetSendStream();
char* lpBuffer = SendStream.GetBuffer(sizeof(PktAdminMgr::PktCharInfoTimeResultAck));
if(NULL == lpBuffer)
{
ERRLOG0(g_Log, "버퍼 생성 실패");
SendResult(PktAdminMgr::PktResult::Err_Unknown);
return false;
}
PktAdminMgr::PktCharInfoTimeResultAck* lpSendBuffer =
reinterpret_cast<PktAdminMgr::PktCharInfoTimeResultAck*>(lpBuffer);
strncpy(lpSendBuffer->m_CreateTime, In_Data.m_szCreateTime, PktAdminMgr::MAX_TIME);
strncpy(lpSendBuffer->m_UpdateTime, In_Data.m_szUpdateTime, PktAdminMgr::MAX_TIME);
SendStream.WrapCrypt(sizeof(PktAdminMgr::PktCharInfoTimeResultAck),
PktAdminMgr::PktCMD::PktGetCharInfoTimeAck, 0, 0);
ZeroMemory(&In_Data, sizeof(In_DBRowData));
}
return true;
}
// 아이템 인덱스로 이름 얻기;
char* CRylAdminMgrDispatch::GetItemState(unsigned char cTake)
{
switch(cTake)
{
case TakeType::TS_INVEN: return "Inventory";
case TakeType::TS_EQUIP: return "Equip";
case TakeType::TS_DEPOSIT: return "Deposit";
case TakeType::TS_EXCHANGE: return "Exchange";
case TakeType::TS_STALL: return "Stall";
case TakeType::TS_EXTRA: return "Extra";
case TakeType::TS_TEMP: return "Temp";
case TakeType::TS_TEMPINVEN: return "TempInven";
case TakeType::TS_NONE: return "None";
}
return "Unknown";
}
// 보류 코드 -----------------------------------------------------------------------------------------------------
bool CRylAdminMgrDispatch::PktDelCharacter(PktBase* lpPktBase)
{
return true;
}
Reference in New Issue View Git Blame Copy Permalink