#include "stdafx.h" #include "RYL_AdminMgrDispatch.h" #include "RYL_AgentServerDispatch.h" #include "RYL_AgentServerTable.h" #include "RYL_AdminManagerServer.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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(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(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(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(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(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(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(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(lpBuffer); char* lpCharBody = reinterpret_cast(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(lpBuffer); char* lpCharBody = reinterpret_cast(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(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(lpBuffer); char* lpCharBody = reinterpret_cast(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(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(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(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(lpPktBase); bool bIsReleased = true; CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktBeforeAfterAck)); PktAdminMgr::PktBeforeAfterAck* lpBeforeAfterAck = reinterpret_cast(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(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(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(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(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(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(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(lpBuffer->begin()); unsigned long* dwRequest = reinterpret_cast(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(lpPktBase); CDBAdminTool& DBAdminTool = CDBAdminTool::GetInstance(); bool bIsReleased = true; CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck)); PktAdminMgr::PktResultAck* lpPktResult = reinterpret_cast(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(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(lpBuffer->wr_ptr()); if(!ToolDB.GetZoneList(m_MyUID, lpPktSetZoneAck->m_ZoneBuffer)) { ERRLOG0(g_Log, "사용자의 존 리스트 정보를 가져오는데 실패했습니다."); return true; } unsigned long* dwSize = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(lpPktBase); bool bIsReleased = true; CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck)); PktAdminMgr::PktResultAck* lpResult = reinterpret_cast(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(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(lpPktBase); bool bIsReleased = true; CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(PktAdminMgr::PktResultAck)); PktAdminMgr::PktResultAck* lpResult = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(lpPktBase); CRylAgentServerDispatch* lpAgentDispatch = CAgentServerTable::GetInstance().GetDispatch((unsigned long)lpPktItemQtyControl->m_cServerGroup); bool bIsReleased = true; CBuffer* lpBuffer = CREATE_BUFFER(GetBufferFactory(), sizeof(lpPktItemQtyControl)); *reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(sizeof(PktBase) + sizeof(char) * PktAdminMgr::MAX_ACCOUNT * nGetRowsNum), PktAdminMgr::PktCMD::PktConnectedUserList, 0, 0); } if (0 == nSendCount) { GetSendStream().WrapCompress(lpBuffer->wr_ptr(), static_cast(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(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(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(lpPktBase); const unsigned char MAX_USER_NUM = lpPktItemDistribute->m_cUserNum; PktAdminMgr::DstUserInfo* lpDstUserInfo = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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; }