Restructure repository to include all source folders

Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

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

Co-Authored-By: Claude <noreply@anthropic.com>

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/ManageServerDispatch.cpp

@@ -0,0 +1,231 @@
+#include "stdafx.h"
+
+#include "ManageServerDispatch.h"
+#include "ManageToolServerDispatch.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Dispatch/SendManagePacket.h>
+#include <Network/Dispatch/MultiDispatchStorage.h>
+#include <UserManage/ToolUserManageTable.h>
+
+#include <Log/ServerLog.h>
+#include <Setup/SetupClient.h>
+
+#include <ServerManage/ManageClientManager.h>
+#include <UserManage/UserStatistics.h>
+
+enum ManageServerConst
+{
+	MANAGE_SERVER_DEFAULT_DISPATCH_NUM = 100
+};
+
+CMultiDispatch& CManageServerDispatch::GetDispatchTable()
+{
+	static CMultiDispatch multiDispatch;
+	return multiDispatch;
+}
+
+
+CManageServerDispatch::CManageServerDispatch(CSession& Session)
+:	CRylServerDispatch(Session, MANAGE_SERVER_DEFAULT_DISPATCH_NUM),
+	m_bAuthorized(false)
+{	
+	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));
+
+	DETLOG1(g_Log, "this:0x%p/CManageServerDispatch Created", this);
+}
+
+
+CManageServerDispatch::~CManageServerDispatch()
+{
+	DETLOG1(g_Log, "this:0x%p/CManageServerDispatch Destroyed", this);
+}
+
+
+void CManageServerDispatch::Connected()
+{
+	// 접속 IP를 key로 잡아서 세팅한다.
+	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();
+
+	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
+	GetDispatchTable().SetDispatch(dwDispatchID, this);
+	
+    // TODO : 서버 IP로 검색해서, RunInfo들을 전송한다.
+
+    CManageClientManager::RunTable runInfoTable;
+    CManageClientManager::GetInstance().GetRunInfoFromIP(dwDispatchID, runInfoTable);
+
+    if(!CManageClientManager::SendRunInfo(GetSession(), runInfoTable))
+    {
+        ERRLOG3(g_Log, "SS:0x%p/DP:0x%p/IP:%15s/Send runInfo failed",
+            &GetSession(), this, remoteAddr.get_addr_string());
+    }
+
+	DETLOG2(g_Log, "this:0x%p/Key:%u/CManageServerDispatch Connected", this, dwDispatchID);
+}
+
+
+
+class CSendProcessData
+{
+public:
+
+    CSendProcessData(ServerManage::ProcessStatus* lpProcessData, 
+        unsigned short usProcessDataNum)
+        :   m_lpProcessData(lpProcessData), m_usProcessDataNum(usProcessDataNum)
+    {
+
+    }
+
+    bool operator () (CManageToolServerDispatch& toolDispatch)
+    {
+        ServerManage::SendManagePacket(toolDispatch.GetSession(), ServerManage::CMD::ProcessStatus, 
+            0, 0, 0, 0, sizeof(ServerManage::ProcessStatus) * m_usProcessDataNum, 0, m_lpProcessData, 0);
+        return true;
+    }
+
+private:
+    
+    ServerManage::ProcessStatus*    m_lpProcessData;
+    unsigned short                  m_usProcessDataNum;
+};
+
+void CManageServerDispatch::Disconnected()
+{
+	// 접속 IP를 key로 잡아서 세팅한다.
+	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();
+
+	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
+	GetDispatchTable().RemoveDispatch(dwDispatchID);
+
+    CManageClientManager::RunTable runInfoTable;
+    CManageClientManager::GetInstance().GetRunInfoFromIP(dwDispatchID, runInfoTable);
+
+    CManageClientManager::RunTable::iterator pos = runInfoTable.begin();
+    CManageClientManager::RunTable::iterator end = runInfoTable.end();
+    
+    const int MAX_PROCESS_STATUS_SEND_ONCE = 
+        (PktMaxLen - sizeof(ServerManage::ManageCommand)) / sizeof(ServerManage::ProcessStatus);
+
+    ServerManage::ProcessStatus procesStatus[MAX_PROCESS_STATUS_SEND_ONCE];
+
+    unsigned short usSendProcessStatus = 0;
+
+    for(; pos != end; ++pos)
+    {
+        ServerManage::RunInfo& runInfo = pos->second;
+
+        // Default - Deactivated Process.
+        ServerManage::ProcessStatus* lpCurrentProcessStatus = procesStatus + usSendProcessStatus;
+        memset(lpCurrentProcessStatus, 0, sizeof(ServerManage::ProcessStatus));
+
+        lpCurrentProcessStatus->m_dwRunID = runInfo.m_dwRunID;
+        ++usSendProcessStatus;
+
+        if(usSendProcessStatus == MAX_PROCESS_STATUS_SEND_ONCE)
+        {
+            CToolUserManager::GetInstance().ProcessCurrentUser(
+                CSendProcessData(procesStatus, usSendProcessStatus));
+
+            usSendProcessStatus = 0;
+        }
+    }
+
+    if(0 < usSendProcessStatus)
+    {
+        CToolUserManager::GetInstance().ProcessCurrentUser(
+            CSendProcessData(procesStatus, usSendProcessStatus));
+
+        usSendProcessStatus = 0;
+    }
+
+	DETLOG2(g_Log, "this:0x%p/Key:%u/CManageServerDispatch Disconnected", this, dwDispatchID);
+}
+
+
+bool CManageServerDispatch::DispatchPacket(PktBase* lpPktBase)
+{
+	PktBase::LengthType nPacketLen = lpPktBase->GetLen();
+	
+	bool bResult = false;
+
+    switch(lpPktBase->GetCmd())
+	{
+    case ServerManage::CMD::ProcessStatus:
+        CUserStatistics::GetInstance().CheckClearUser(lpPktBase);
+        RelayPacketToManageTools(lpPktBase);
+        break;
+        
+	case ServerManage::CMD::RelayCommand:
+		RelayPacketToManageTools(lpPktBase);
+		break;
+
+	default:
+
+		{
+			in_addr addr;
+			addr.S_un.S_addr = m_UserInfo.dwIP;
+
+			ERRLOG4(g_Log, "ID:%s/Name:%s/IP:%s/Cmd:0x%02x/Undefined command.",
+				m_UserInfo.szID, m_UserInfo.szFullName, inet_ntoa(addr),
+				lpPktBase->GetCmd());
+		}
+		break;
+	}
+
+	return true;
+}
+
+
+bool CManageServerDispatch::RelayPacketToManageTools(PktBase* lpPktBase)
+{
+	unsigned char   cError = 0;
+    bool            bDoNotRelay = false;
+
+	ServerManage::ManageCommand* lpManageCommand = 
+		reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);
+
+	if(!ServerManage::CheckManagePacketLength(lpPktBase))
+	{
+		cError = ServerManage::INVALID_MANAGE_PACKET_ERROR;
+	}
+
+    if(sizeof(ServerManage::PktManagePacket) <= lpManageCommand->usDataLen)
+    {
+        ServerManage::PktManagePacket* lpPktManagePacket = 
+            reinterpret_cast<ServerManage::PktManagePacket*>(lpManageCommand + 1);
+
+        switch(lpPktManagePacket->m_dwSubCommand)
+        {
+        case ServerManage::CMD::SubCmd_ServerUserNum:
+            {
+                ServerManage::PktManageUserNum* lpPktManageUserNum = 
+                    static_cast<ServerManage::PktManageUserNum*>(lpPktManagePacket);
+
+				/*
+                DETLOG2(g_Log, "RunID:%d/PID:%d/Setting UserInfo", 
+                    lpManageCommand->dwRunID, lpPktManageUserNum->m_dwPID);
+					*/
+
+                CUserStatistics::GetInstance().SerializeIn(lpManageCommand->dwRunID, 
+                    reinterpret_cast<ServerManage::UserNumPair*>(lpPktManageUserNum + 1), 
+                    lpPktManageUserNum->m_dwUserInfoNum);
+            }
+            break;            
+        }
+    }
+
+	if(0 == cError && !bDoNotRelay)
+	{
+		CToolUserManager::GetInstance().ProcessCurrentUser(
+			ServerManage::CSendManagePacketToClient(*lpManageCommand, 
+            reinterpret_cast<char*>(lpManageCommand + 1)));
+
+        return true;
+	}
+    
+	return ServerManage::SendManagePacket(GetSession(), 
+        lpPktBase->GetCmd(), 0, 0, 0, 0, 0, 0, 0, cError);
+}
+

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/ManageServerDispatch.h

@@ -0,0 +1,30 @@
+#ifndef _GM_MANAGE_SERVER_DISPATCH_H_
+#define _GM_MANAGE_SERVER_DISPATCH_H_
+
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Dispatch/RylServerDispatch.h>
+#include <Network/Dispatch/MultiDispatchStorage.h>
+
+class CManageServerDispatch : public CRylServerDispatch
+{
+public:
+
+	static CMultiDispatch& GetDispatchTable();
+
+	CManageServerDispatch(CSession& Session);
+	virtual ~CManageServerDispatch();
+
+private:
+
+	virtual void Connected();
+	virtual void Disconnected();
+	
+	virtual bool DispatchPacket(PktBase* lpPktBase);
+
+	bool RelayPacketToManageTools(PktBase* lpPktBase);
+
+	ServerManage::UserInfo	m_UserInfo;
+	bool					m_bAuthorized;
+};
+
+#endif

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/ManageToolServerDispatch.cpp

@@ -0,0 +1,320 @@
+#include "stdafx.h"
+
+#include "ManageServerDispatch.h"
+#include "ManageToolServerDispatch.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/SendManagePacket.h>
+#include <Network/Dispatch/MultiDispatchStorage.h>
+
+#include <Network/Packet/ManagePacketCmd.h>
+#include <UserManage/ToolUserManageTable.h>
+#include <ServerManage/ManageClientManager.h>
+
+#include <Setup/SetupClient.h>
+#include <Log/ServerLog.h>
+#include <Network/Packet/WrapPacket.h>
+
+#include <mmsystem.h>
+
+enum ManageToolServerConst
+{
+	MANAGE_TOOL_SERVER_DEFAULT_DISPATCH_NUM = 10
+};
+
+
+CManageToolServerDispatch::CManageToolServerDispatch(CSession& Session)
+:	CRylServerDispatch(Session, MANAGE_TOOL_SERVER_DEFAULT_DISPATCH_NUM),
+	m_bAuthorized(false), m_dwLastPingRecvTime(timeGetTime())
+{	
+	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));
+
+	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Created", this);
+}
+
+
+CManageToolServerDispatch::~CManageToolServerDispatch()
+{
+	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Destroyed", this);
+}
+
+void CManageToolServerDispatch::Connected()
+{
+	// 인증 성공시 LoginTable에 삽입된다.
+	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Connected", this);
+}
+
+void CManageToolServerDispatch::Disconnected()
+{
+	if(0 != m_UserInfo.szID[0])
+	{
+        CToolUserManager::GetInstance().Logout(m_UserInfo.szID);
+	}
+
+	DETLOG1(g_Log, "this:0x%p/CManageToolServerDispatch Disconnected", this);
+}
+
+
+bool CManageToolServerDispatch::Dispatch()
+{
+    unsigned long dwCurrentTime = timeGetTime();
+
+    // 2분 동안 핑을 못받으면 접속을 끊는다.
+    if (1000 * 60 * 2 < dwCurrentTime - m_dwLastPingRecvTime)
+    {
+        INFLOG4(g_Log, "Disconnect by ping %s:%d / %u / %u ",
+            GetRemoteAddr().get_addr_string(), GetRemoteAddr().get_port_in(),
+            dwCurrentTime, m_dwLastPingRecvTime);
+
+        return false;
+    }
+
+    return CRylServerDispatch::Dispatch();
+}
+
+bool CManageToolServerDispatch::DispatchPacket(PktBase* lpPktBase)
+{
+	PktBase::LengthType nPacketLen = lpPktBase->GetLen();
+	
+	bool bResult = true;
+	const TCHAR* szErrorString = 0;
+
+    bool bSendInvalidUserPacketAck = false;
+    bool bSendInvalidManagePacketAck = false;
+
+    if (ServerManage::CMD::Ping == lpPktBase->GetCmd())
+    {
+        m_dwLastPingRecvTime = timeGetTime();
+
+        PktBase pktBase;
+        memset(&pktBase, 0, sizeof(PktBase));
+        pktBase.SetServerInfo(m_dwLastPingRecvTime);
+
+        if (PacketWrap::WrapHeader(reinterpret_cast<char*>(&pktBase), 
+            sizeof(PktBase), ServerManage::CMD::Ping, pktBase.GetState(), pktBase.GetError()))
+        {
+            GetSendStream().PutBuffer(reinterpret_cast<char*>(&pktBase), 
+                sizeof(PktBase), ServerManage::CMD::Ping);
+        }
+    }
+	else if(ServerManage::CMD::AuthUser == lpPktBase->GetCmd())
+	{
+        if(!AuthUser(lpPktBase))
+		{
+			szErrorString = "Authorize failed.";
+		}
+		else
+		{
+			m_bAuthorized = true;
+
+            // 인증이 성공하면 RunInfo를 전송한다.
+            if(!CManageClientManager::SendRunInfo(GetSession(), 
+                CManageClientManager::GetInstance().GetRunInfoTable()))
+            {
+                ERRLOG3(g_Log, "SS:0x%p/DP:0x%p/IP:%15s/Send runInfo failed",
+                    &GetSession(), this, GetSession().GetRemoteAddr().get_addr_string());
+            }
+		}
+	}
+	else if(m_bAuthorized)
+	{
+        switch(lpPktBase->GetCmd())
+		{
+        // 다음 커맨드들은, RunID가 속한 서버로 메시지를 Relay한다. 
+        // Relay하지 못한 경우는 실패를 돌려준다.
+        case ServerManage::CMD::RunProcess:
+        case ServerManage::CMD::QuitProcess:
+        case ServerManage::CMD::ForceTerminate:
+        case ServerManage::CMD::ProcessStatus:
+
+		case ServerManage::CMD::RelayCommand:
+		case ServerManage::CMD::AutoPatch:
+		case ServerManage::CMD::ChangeSetup:
+		case ServerManage::CMD::ReloadSetup:
+
+        case ServerManage::CMD::ExecuteCommand:
+
+            if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
+                (m_UserInfo.usAdminLevel == CToolUserManager::MASTER 
+                || m_UserInfo.usAdminLevel == CToolUserManager::GENERAL))
+                
+			{
+                bResult = RelayPacketToManageClient(lpPktBase);
+			}
+            else
+            {
+                bSendInvalidManagePacketAck = true;
+            }
+			break;
+		
+		case ServerManage::CMD::AddUser:
+			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
+                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
+			{ 
+				bResult = AddUser(lpPktBase);
+			} 
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+
+		case ServerManage::CMD::DelUser:			
+			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
+                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
+			{ 
+				bResult = DelUser(lpPktBase); 
+			} 
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+
+		case ServerManage::CMD::ModUser:
+			if(CToolUserManager::GetInstance().IsManageUser(m_UserInfo) && 
+                m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
+			{ 
+				bResult = ModUser(lpPktBase);
+			}
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+
+        case ServerManage::CMD::RequestPromote:
+			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER || 
+				m_UserInfo.usAdminLevel == CToolUserManager::GENERAL) 
+			{ 
+				bResult = RequestPromote(lpPktBase);
+			}
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+
+        case ServerManage::CMD::RequestUserReaction:
+			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER || 
+				m_UserInfo.usAdminLevel == CToolUserManager::GENERAL) 
+			{ 
+				bResult = ProcessUserReaction(lpPktBase);
+			}
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+
+		case ServerManage::CMD::UserList:
+			if(m_UserInfo.usAdminLevel == CToolUserManager::MASTER) 
+			{ 
+				bResult = UserList(lpPktBase); 
+			}
+            else
+            {
+                bSendInvalidUserPacketAck = true;
+            }
+			break;
+		
+		default:
+            szErrorString = "Unknown packet. Cannot process.";
+			break;
+		}
+	}
+	else
+	{
+		szErrorString = "Unauthorized user send command. Cannot process.";
+	}
+
+	if(!bResult)
+	{
+		szErrorString = "Packet process failed.";
+	}
+
+    if(bSendInvalidManagePacketAck)
+    {
+        ServerManage::SendManagePacket(GetSession(), lpPktBase->GetCmd(), 
+            0, 0, 0, 0, 0, 0, 0, ServerManage::INVALID_MANAGE_RIGHTS);
+    }
+
+    if(bSendInvalidUserPacketAck)
+    {
+        ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), 0, 0, 
+            lpPktBase->GetCmd(), ServerManage::INVALID_USERMANAGE_RIGHTS);
+    }
+
+	if(0 != szErrorString)
+	{
+		in_addr addr;
+		addr.S_un.S_addr = m_UserInfo.dwIP;
+
+        ERRLOG5(g_Log, "ID:%s/Name:%s/IP:%s/Cmd:0x%02x/%s",
+			m_UserInfo.szID, m_UserInfo.szFullName, inet_ntoa(addr),
+			lpPktBase->GetCmd(), szErrorString);
+	}
+
+	return true;
+}
+
+
+bool CManageToolServerDispatch::RelayPacketToManageClient(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::ManageCommand* lpManageCommand = 
+		reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);
+
+	if(!ServerManage::CheckManagePacketLength(lpPktBase))
+	{
+		cError = ServerManage::INVALID_MANAGE_PACKET_ERROR;
+	}
+    
+    if(CManageClientManager::MAX_RUNID == lpManageCommand->dwRunID)
+	{
+		CManageServerDispatch::GetDispatchTable().Process(
+			ServerManage::CSendManagePacketToClient(*lpManageCommand, 
+            reinterpret_cast<char*>(lpManageCommand + 1)));
+	}
+	else
+	{
+        ServerManage::RunInfo runInfo;
+
+        if(CManageClientManager::GetInstance().GetRunInfo(
+            lpManageCommand->dwRunID, runInfo))
+        {
+			GET_MULTI_DISPATCH(lpManageServerDispatch,
+				runInfo.m_dwServerIP, 
+				CManageServerDispatch, 
+				CManageServerDispatch::GetDispatchTable());
+
+			if(0 != lpManageServerDispatch)
+			{
+                DETLOG4(g_Log, "ID:%s/FullName:%s/Send Relay Packet(Cmd:%d), RunID:%u",
+                    m_UserInfo.szID, m_UserInfo.szFullName, 
+                    lpManageCommand->GetCmd(), lpManageCommand->dwRunID);
+                
+                if(!ServerManage::SendManagePacket(lpManageServerDispatch->GetSession(), 
+					lpManageCommand->GetCmd(), lpManageCommand->nMessage, 
+					lpManageCommand->wParam, lpManageCommand->lParam,
+					lpManageCommand->dwRunID, lpManageCommand->usDataLen, lpManageCommand->usFlags,
+					reinterpret_cast<char*>(lpManageCommand + 1), 0))
+				{
+					cError = ServerManage::SEND_MANAGE_COMMAND_ERROR;
+				}
+			}
+			else
+			{
+				cError = ServerManage::CANNOT_FIND_CLIENT_DISPATCH;
+			}
+        }
+        else
+        {
+            cError = ServerManage::UNKNOWN_RUN_INFO;
+        }
+	}
+
+	return ServerManage::SendManagePacket(GetSession(), 
+		lpPktBase->GetCmd(), 0, 0, 0, 0, 0, 0, 0, cError);
+}

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/ManageToolServerDispatch.h

@@ -0,0 +1,44 @@
+#ifndef _GM_MANAGE_TOOL_SERVER_DISPATCH_H_
+#define _GM_MANAGE_TOOL_SERVER_DISPATCH_H_
+
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Dispatch/RylServerDispatch.h>
+
+// forward decl.
+class CToolUserManager;
+
+class CManageToolServerDispatch : public CRylServerDispatch
+{
+public:
+
+	CManageToolServerDispatch(CSession& Session);
+	virtual ~CManageToolServerDispatch();
+
+    const ServerManage::UserInfo& GetUserInfo() const { return m_UserInfo; }
+
+private:
+
+	virtual void Connected();
+	virtual void Disconnected();
+	
+    virtual bool Dispatch();
+	virtual bool DispatchPacket(PktBase* lpPktBase);
+	
+	bool RelayPacketToManageClient(PktBase* lpPktBase);
+
+	bool AuthUser(PktBase* lpPktBase);
+	bool AddUser(PktBase* lpPktBase);
+	bool DelUser(PktBase* lpPktBase);
+	bool ModUser(PktBase* lpPktBase);
+	
+    bool RequestPromote(PktBase* lpPktBase);
+    bool ProcessUserReaction(PktBase* lpPktBase);
+
+	bool UserList(PktBase* lpPktBase);
+
+	ServerManage::UserInfo	m_UserInfo;
+    unsigned long           m_dwLastPingRecvTime;
+	bool					m_bAuthorized;
+};
+
+#endif

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/ParseUserManage.cpp

@@ -0,0 +1,308 @@
+#include "stdafx.h"
+#include "ManageToolServerDispatch.h"
+
+#include <tchar.h>
+#include <Log/ServerLog.h>
+#include <UserManage/ToolUserManageTable.h>
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/SendManagePacket.h>
+
+
+bool CManageToolServerDispatch::AuthUser(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+	if(0 == cError)
+	{
+		m_UserInfo = *lpUserInfo;
+		m_UserInfo.dwIP = GetSession().GetRemoteAddr().get_addr_in().sin_addr.S_un.S_addr;
+
+		// 인증 성공시 LoginTable에 삽입된다.
+		cError = CToolUserManager::GetInstance().Authorize(*this, m_UserInfo);
+		if (cError != ServerManage::NO_USER_COMMAND_ERROR)
+		{
+			ERRLOG2(g_Log, "ID:%s/IP:%s/Authorize failed", 
+				m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string());
+		}
+	}
+
+    if(0 == cError)
+	{
+        DETLOG2(g_Log, "ID:%s/IP:%s/Authorize success",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string());
+
+		// 다른 유저들에게 로그인 정보를 보낸다.
+		ServerManage::SendUserInfo(GetBufferFactory(), 0, &m_UserInfo, 1, 
+			ServerManage::CMD::UserLogin, 0);
+
+        // 현재 관리자 정보를 준다.
+        ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+            &CToolUserManager::GetInstance().GetManageUser(), 1, 
+            ServerManage::CMD::ManagerInfo, 0);
+
+		// 다른 유저들의 로그인 정보를 받는다.
+		CToolUserManager::GetInstance().SendAllLoginUserInfo(GetSession());
+
+#pragma todo("서버 Setup을 준다")
+	}
+	
+	ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), &m_UserInfo, 1, 
+		ServerManage::CMD::AuthUser, cError);
+
+    return (0 == cError);
+}
+
+
+bool CManageToolServerDispatch::AddUser(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+	if(0 == cError && !CToolUserManager::GetInstance().AddUser(*lpUserInfo))
+	{
+		ERRLOG3(g_Log, "ID:%s/IP:%s/Adduser failed (ID:%s)",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+		cError = ServerManage::ADD_USER_FAILED;		
+	}
+
+	DETLOG3(g_Log, "ID:%s/IP:%s/Adduser success",
+		m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+
+	memset(lpUserInfo->szPassword, 0, ServerManage::UserInfo::PASS_LEN);
+
+	return ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), lpUserInfo, 1, 
+		ServerManage::CMD::AddUser, cError);
+}
+
+
+bool CManageToolServerDispatch::DelUser(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+	if(0 == cError && !CToolUserManager::GetInstance().DelUser(lpUserInfo->szID))
+	{
+		ERRLOG3(g_Log, "ID:%s/IP:%s/Delete user failed (ID:%s)",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+		cError = ServerManage::DELETE_USER_FAILED;
+	}
+
+	DETLOG3(g_Log, "ID:%s/IP:%s/Delete user success",
+		m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+
+	return ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), lpUserInfo, 1, 
+		ServerManage::CMD::DelUser, cError);
+}
+
+
+bool CManageToolServerDispatch::ModUser(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+	if(0 == cError && !CToolUserManager::GetInstance().ModifyUser(*lpUserInfo))
+	{
+		ERRLOG3(g_Log, "ID:%s/IP:%s/Modify user failed (ID:%s)",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+		cError = ServerManage::MODIFY_USER_FAILED;
+	}
+
+	DETLOG3(g_Log, "ID:%s/IP:%s/Modify user success",
+		m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+	
+	memset(lpUserInfo->szPassword, 0, ServerManage::UserInfo::PASS_LEN);
+
+	return ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), lpUserInfo, 1, 
+		ServerManage::CMD::ModUser, cError);
+}
+
+bool CManageToolServerDispatch::UserList(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 0))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+	if(0 == cError && !CToolUserManager::GetInstance().SendAllUserInfo(GetSession()))
+	{
+		ERRLOG2(g_Log, "ID:%s/IP:%s/Send userlist failed",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string());
+
+		cError = ServerManage::SEND_USER_LIST_FAILED;
+	}
+
+	DETLOG2(g_Log, "ID:%s/IP:%s/Send userlist success",
+		m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string());
+
+	return ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), 0, 0, 
+		ServerManage::CMD::UserList, cError);
+}
+
+
+bool CManageToolServerDispatch::RequestPromote(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+    
+	if(0 == cError)
+    {
+        const ServerManage::UserInfo& masterUser = CToolUserManager::GetInstance().GetManageUser();
+        
+        if(0 == masterUser.szID[0] || m_UserInfo.usAdminLevel == CToolUserManager::MASTER)
+        {
+            // 현재 Promote유저가 있는지 살핀다. 없거나, Master면 바로 Promote를 하고 Broadcast를 한다.
+            CToolUserManager::GetInstance().Promote(m_UserInfo);
+
+            ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+                &m_UserInfo, 1, ServerManage::CMD::ManagerInfo, 0);
+        }
+        else if(m_UserInfo.usAdminLevel == CToolUserManager::GENERAL)
+        {
+            // 현재 Promote유저가 있고, 내가 General레벨이면, 정중히 요청을 한다.
+            CManageToolServerDispatch* lpToolUserDispatch = 
+                CToolUserManager::GetInstance().GetManageUserDispatch();
+
+            ServerManage::UserInfo userInfo = m_UserInfo;
+            userInfo.usSubCommand = ServerManage::CMD::REQUEST_TAKEBACK_PROMOTE;
+
+            // 아직 연결되어 있으면 요청 패킷을 보냄.
+            if(0 == lpToolUserDispatch 
+                || !ServerManage::SendUserInfo(GetBufferFactory(), 
+                &lpToolUserDispatch->GetSession(), &userInfo, 1, 
+                ServerManage::CMD::RequestUserReaction, 0))
+            {
+                cError = ServerManage::PROMOTE_TAKEBACK_FAILED;
+            }            
+        }
+        else
+        {
+            cError = ServerManage::PROMOTE_USER_FAILED;
+        }
+    }
+
+    if(0 != cError)
+    {
+		ERRLOG3(g_Log, "ID:%s/IP:%s/Promote user failed (ID:%s)",
+			m_UserInfo.szID, GetSession().GetRemoteAddr().get_addr_string(), lpUserInfo->szID);
+	
+        ServerManage::SendUserInfo(GetBufferFactory(), &GetSession(), 0, 0, 
+            ServerManage::CMD::RequestPromote, cError);
+    }
+
+    return true;
+}
+
+
+bool CManageToolServerDispatch::ProcessUserReaction(PktBase* lpPktBase)
+{
+	unsigned char cError = 0;
+
+	ServerManage::UserCommand* lpUserCommand = 
+		reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+
+	ServerManage::UserInfo* lpUserInfo = 
+		reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(!ServerManage::CheckUserPacketLength(lpPktBase, 1))
+	{
+		cError = ServerManage::INVALID_USER_PACKET_ERROR;
+	}
+
+    CManageToolServerDispatch* lpRequestDispatch = 0;
+
+    if(0 == cError)
+    {
+        switch(lpUserInfo->usSubCommand)
+        {
+        case ServerManage::CMD::ACK_TAKEBACK_PROMOTE:
+            
+            // 처음 요청자를 찾아서 Promote 성공 패킷을 보낸다.
+            lpRequestDispatch = CToolUserManager::GetInstance().GetUserDispatch(lpUserInfo->szID);
+            if(0 != lpRequestDispatch)
+            {
+                ServerManage::UserInfo manager = lpRequestDispatch->GetUserInfo();
+
+                // Promote 처리.
+                CToolUserManager::GetInstance().Promote(manager);
+                
+                // 누가 Manager인지 만천하에 알린다.
+                ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+                    &manager, 1, ServerManage::CMD::ManagerInfo, 0);
+
+                // 본인에게 Ack.
+                ServerManage::SendUserInfo(GetBufferFactory(), &lpRequestDispatch->GetSession(), 
+					&manager, 1, ServerManage::CMD::RequestPromote, 0);
+            }
+            break;
+
+        case ServerManage::CMD::NAK_TAKEBACK_PROMOTE:
+            // 처음 요청자를 찾아서 Promote 실패 패킷을 보낸다.
+            lpRequestDispatch = CToolUserManager::GetInstance().GetUserDispatch(lpUserInfo->szID);
+            if(0 != lpRequestDispatch)
+            {
+                ServerManage::SendUserInfo(GetBufferFactory(), &lpRequestDispatch->GetSession(), 
+					&m_UserInfo, 1, ServerManage::CMD::RequestPromote, ServerManage::REJECTED_PROMOTE_USER);
+            }
+            break;
+        }
+    }   
+
+    return true;
+}

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/StatServerDispatch.cpp

@@ -0,0 +1,47 @@
+#include "stdafx.h"
+
+#include "StatServerDispatch.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Packet/ManagePacketCmd.h>
+
+#include <Log/ServerLog.h>
+
+enum StatServerConst
+{
+	STAT_SERVER_DEFAULT_DISPATCH_NUM = 10
+};
+
+
+CStatServerDispatch::CStatServerDispatch(CSession& Session)
+: CRylServerDispatch(Session, STAT_SERVER_DEFAULT_DISPATCH_NUM)
+
+{	
+	DETLOG1(g_Log, "this:0x%p/CStatServerDispatch Created", this);
+}
+
+CStatServerDispatch::~CStatServerDispatch()
+{
+	DETLOG1(g_Log, "this:0x%p/CStatServerDispatch Destroyed", this);
+}
+
+CSingleDispatch& CStatServerDispatch::GetDispatch()
+{
+	static CSingleDispatch statServerDispatch;
+	return statServerDispatch;
+}
+
+void CStatServerDispatch::Connected()
+{
+	GetDispatch().SetDispatch(this);
+}
+
+void CStatServerDispatch::Disconnected()
+{
+	GetDispatch().RemoveDispatch(this);
+}
+
+bool CStatServerDispatch::DispatchPacket(PktBase* lpPktBase)
+{
+	return true;
+}

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/StatServerDispatch.h

@@ -0,0 +1,26 @@
+#ifndef _STAT_SERVER_DISPATCH_H_
+#define _STAT_SERVER_DISPATCH_H_
+
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Dispatch/RylServerDispatch.h>
+#include <Network/Dispatch/SingleDispatchStorage.h>
+
+
+class CStatServerDispatch : public CRylServerDispatch
+{
+public:
+
+	CStatServerDispatch(CSession& Session);
+	virtual ~CStatServerDispatch();
+
+	static CSingleDispatch& GetDispatch();
+
+private:
+
+	virtual void Connected();
+	virtual void Disconnected();
+	
+	virtual bool DispatchPacket(PktBase* lpPktBase);
+};
+
+#endif

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/StatServerMultiDispatch.cpp

@@ -0,0 +1,58 @@
+#include "stdafx.h"
+#include "StatServerMultiDispatch.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/MultiDispatchStorage.h>
+
+#include <Log/ServerLog.h>
+#include <Setup/SetupClient.h>
+
+enum StatServerConst
+{
+	STAT_SERVER_DEFAULT_DISPATCH_NUM = 10
+};
+
+CMultiDispatch& CStatServerMultiDispatch::GetDispatchTable()
+{
+	static CMultiDispatch multiDispatch;
+	return multiDispatch;
+}
+
+CStatServerMultiDispatch::CStatServerMultiDispatch(CSession& Session)
+: CRylServerDispatch(Session, STAT_SERVER_DEFAULT_DISPATCH_NUM)
+{	
+	DETLOG1(g_Log, "this:0x%p/CStatServerMultiDispatch Created", this);
+}
+
+CStatServerMultiDispatch::~CStatServerMultiDispatch()
+{
+	DETLOG1(g_Log, "this:0x%p/CStatServerMultiDispatch Destroyed", this);
+}
+
+void CStatServerMultiDispatch::Connected()
+{
+	// 접속 IP를 key로 잡아서 세팅한다.
+	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();
+
+	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
+	GetDispatchTable().SetDispatch(dwDispatchID, this);
+	
+	DETLOG2(g_Log, "this:0x%p/Key:%u/CStatServerMultiDispatch Connected", this, dwDispatchID);
+}
+
+void CStatServerMultiDispatch::Disconnected()
+{
+	// 접속 IP를 key로 잡아서 삭제한다.
+	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();
+
+	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
+	GetDispatchTable().RemoveDispatch(dwDispatchID);
+
+	DETLOG2(g_Log, "this:0x%p/Key:%u/CStatServerMultiDispatch Disconnected", this, dwDispatchID);
+}
+
+
+bool CStatServerMultiDispatch::DispatchPacket(PktBase* lpPktBase)
+{
+	return true;
+}

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageServer/StatServerMultiDispatch.h

@@ -0,0 +1,25 @@
+#ifndef _STAT_SERVER_MULTI_DISPATCH_H_
+#define _STAT_SERVER_MULTI_DISPATCH_H_
+
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Dispatch/RylServerDispatch.h>
+#include <Network/Dispatch/MultiDispatchStorage.h>
+
+class CStatServerMultiDispatch : public CRylServerDispatch
+{
+public:
+
+	static CMultiDispatch& GetDispatchTable();
+
+	CStatServerMultiDispatch(CSession& Session);
+	virtual ~CStatServerMultiDispatch();
+
+private:
+
+	virtual void Connected();
+	virtual void Disconnected();
+	
+	virtual bool DispatchPacket(PktBase* lpPktBase);
+};
+
+#endif