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/Db/ManageServerDB.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "SQLite.h"
+
+#include "ManageServerDB.h"
+#include <Log/ServerLog.h>
+
+#include <cstdio>
+
+const char* CManageServerDB::GetDefaultDBFileName()
+{
+	return "./ManageServerDB.dat";
+}
+
+
+CManageServerDB& CManageServerDB::GetInstance()
+{
+	static CManageServerDB manageServerDB;
+	return manageServerDB;
+}
+
+
+CManageServerDB::CManageServerDB()
+:	m_lpSQLite(new CSQLite)
+{
+
+
+}
+
+
+CManageServerDB::~CManageServerDB()
+{
+	if(0 != m_lpSQLite)
+	{
+		delete m_lpSQLite;
+		m_lpSQLite = 0;
+	}
+}
+
+bool CManageServerDB::Initialize(const char* szDBFileName)
+{
+	if(0 == m_lpSQLite || !m_lpSQLite->Open(szDBFileName))
+	{
+		ERRLOG1(g_Log, "Cannot open database : %s", szDBFileName);
+		return false;
+	}
+
+	// Create Tables - <20>̹<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+	const int MAX_QUERY_NUM = 5;
+	const char* szCreateTableQuery[MAX_QUERY_NUM] = 
+	{
+		"CREATE TABLE TblManageToolUser (ID char(16) PRIMARY KEY, PASS char(16), "
+			"NAME char(32), IP char(16), LEVEL INTEGER)",
+
+		"CREATE TABLE TblServerInfo (IP INTEGER PRIMARY KEY, ServerName char(64))",
+		"CREATE TABLE TblRunPath (PathID INTEGER PRIMARY KEY, RunPath char(260))",
+		"CREATE TABLE TblRunOptions (OptionID INTEGER PRIMARY KEY, RunOption char(260))",
+		"CREATE TABLE TblRunInfo (RunID INTEGER PRIMARY KEY, PathID INTEGER, OptionID INTEGER, ServerIP INTEGER)"
+	};
+
+    m_lpSQLite->SetErrorLog(false);
+
+	for(int nQuery = 0; nQuery < MAX_QUERY_NUM; ++nQuery)
+	{
+        CSQLite::Dataset createUserTable(*m_lpSQLite, szCreateTableQuery[nQuery]);
+		
+		if(!createUserTable.Compile() || !createUserTable.Execute())
+		{
+			if(0 != createUserTable.GetLastError())
+			{
+				// Table create failed. if already create failed?
+				char szTableName[MAX_PATH];
+				int nLength = sscanf(createUserTable.GetLastError(), "table %s already exists", szTableName);
+				if(EOF == nLength || 0 == nLength)
+				{
+                    m_lpSQLite->SetErrorLog(true);
+					return false;
+				}
+			}
+		}
+	}
+
+    m_lpSQLite->SetErrorLog(true);
+	return true;
+}

Server/ManageTool/ManageLibrary/Db/ManageServerDB.h

@@ -0,0 +1,24 @@
+#ifndef _MANAGE_SERVER_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+#define _MANAGE_SERVER_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+
+class CSQLite;
+
+class CManageServerDB
+{
+public:
+
+	static const char* GetDefaultDBFileName();
+	static CManageServerDB& GetInstance();
+
+	bool Initialize(const char* szDBFileName = CManageServerDB::GetDefaultDBFileName());
+	CSQLite& GetSQLite() { return *m_lpSQLite; }
+	
+private:
+
+	CManageServerDB();
+	~CManageServerDB();
+
+	CSQLite* m_lpSQLite;
+};
+
+#endif

Server/ManageTool/ManageLibrary/Db/SQLite.cpp

@@ -0,0 +1,220 @@
+#include "stdafx.h"
+#include "SQLite.h"
+
+#include <cstdlib>
+#include <sqlite-library/sqlite.h>
+#include <Log/ServerLog.h>
+
+#define SAFE_FREE_SQLITE_ERRMSG(p) if(p) { sqlite_freemem(p); (p) = 0; }
+
+CSQLite::CSQLite()
+:	m_sqlDB(0), m_szErrorMsg(0), m_bLogError(true)
+{
+
+}
+
+CSQLite::~CSQLite()
+{
+	SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+	Close();
+}
+
+
+bool CSQLite::Open(const char* szDBFileName)
+{
+	char* szErrMsg = 0;
+	m_sqlDB = sqlite_open(szDBFileName, 0, &szErrMsg);
+
+	if(0 == m_sqlDB)
+	{
+        if(m_bLogError)
+        {
+            ERRLOG2(g_Log, "Can't open database : %s(%d)", 
+                szDBFileName, GetLastError());
+        }
+		
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrMsg;
+		return false;
+	}
+	
+	return true;
+}
+
+void CSQLite::Close()
+{
+	if(0 != m_sqlDB)
+	{
+		sqlite_close(m_sqlDB);
+	}
+}
+
+int CSQLite::GetLastInsertRowID()
+{
+	return sqlite_last_insert_rowid(m_sqlDB);
+}
+
+
+bool CSQLite::ExecuteQuery(const char* szQuery, QueryCallBack fnCallBack, void* callBackArg)
+{
+	char* szErrorMsg = 0;
+	int nResult = sqlite_exec(m_sqlDB, szQuery, fnCallBack, callBackArg, &szErrorMsg);
+	if(SQLITE_OK != nResult)
+	{
+        if(m_bLogError)
+        {
+		    ERRLOG2(g_Log, "Execute Query failed : %s(Query:%s)", 
+			    szErrorMsg, szQuery);
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	return true;	
+}
+
+
+
+CSQLite::Dataset::Dataset(CSQLite& sqlite, const char* szQuery)
+:	m_SQLite(sqlite), 
+	m_sqlite_vm(0),
+	m_szQuery(szQuery), 
+	m_szErrorMsg(0),
+	m_nExecuteResult(SQLITE_ROW)
+{
+	
+}
+
+
+CSQLite::Dataset::~Dataset()
+{
+	Free();
+	SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+}
+
+
+bool CSQLite::Dataset::Compile()
+{
+	Free();	
+
+	const char* szNextQuery = 0;
+	char*		szErrorMsg  = 0;
+
+	if('\0' == *m_szQuery)
+	{
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ϸ<EFBFBD><CFB7>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+		return false;
+	}
+
+	int nResult = sqlite_compile(m_SQLite.GetHandle(), m_szQuery, 
+		&szNextQuery, &m_sqlite_vm, &szErrorMsg);
+
+	if(SQLITE_OK != nResult)
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+		    ERRLOG2(g_Log, "SQLite error : compile query error - %s(%d)", 
+			    szErrorMsg, GetLastError());
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	m_szQuery = szNextQuery;
+	return true;
+}
+
+bool CSQLite::Dataset::Execute(int* nColNum_Out, 
+							   const char *** pazValue, 
+							   const char *** pazColName)
+{
+	m_nExecuteResult = sqlite_step(m_sqlite_vm, nColNum_Out, pazValue, pazColName);
+
+	if(SQLITE_ROW == m_nExecuteResult || 
+		SQLITE_DONE == m_nExecuteResult)
+	{
+		return true;
+	}
+	else
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+		    ERRLOG1(g_Log, "SQLite error : Dataset - execute error :%s", 
+			    sqlite_error_string(m_nExecuteResult));
+        }
+	}
+
+	return false;
+}
+
+
+bool CSQLite::Dataset::IsExcuteDone()
+{ 
+	return (SQLITE_ROW != m_nExecuteResult); 
+}
+
+
+void CSQLite::Dataset::Free()
+{
+	if(0 != m_sqlite_vm)
+	{
+		char* szErrorMsg = 0;
+
+		if(SQLITE_OK != sqlite_finalize(m_sqlite_vm, &szErrorMsg))
+		{
+            if(m_SQLite.IsErrorLogging())
+            {
+			    ERRLOG2(g_Log, "SQLite error : finalize error - %s(%d)", 
+				    szErrorMsg, GetLastError());
+            }
+
+			SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+			m_szErrorMsg = szErrorMsg;
+		}
+
+		m_sqlite_vm = 0;
+	}
+}
+
+
+CSQLite::Tableset::Tableset(CSQLite& sqlite, const char* szQuery)
+:	m_SQLite(sqlite), m_szQuery(szQuery), m_nRow(0), m_nCol(0), 
+	m_szResult(0), m_szErrorMsg(0)
+{
+
+
+}
+
+CSQLite::Tableset::~Tableset()
+{
+	if(0 != m_szResult)
+	{
+		sqlite_free_table(m_szResult);
+		m_szResult = 0;
+	}
+}
+
+bool CSQLite::Tableset::Execute()
+{
+	char* szErrorMsg = 0;
+
+	if(SQLITE_OK != sqlite_get_table(m_SQLite.GetHandle(), m_szQuery, 
+		&m_szResult, &m_nRow, &m_nCol, &szErrorMsg))
+	{
+        if(m_SQLite.IsErrorLogging())
+        {
+        	ERRLOG2(g_Log, "SQLite error : get_table error - %s(%d)", 
+	    		szErrorMsg, GetLastError());
+        }
+
+		SAFE_FREE_SQLITE_ERRMSG(m_szErrorMsg);
+		m_szErrorMsg = szErrorMsg;
+		return false;
+	}
+
+	return true;
+}

Server/ManageTool/ManageLibrary/Db/SQLite.h

@@ -0,0 +1,93 @@
+#ifndef _MANAGE_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+#define _MANAGE_TOOL_DB_FILE_DB_LIB_SQL_LITE_
+
+// forward decl;
+typedef struct sqlite_vm sqlite_vm;
+typedef struct sqlite sqlite;
+
+class CSQLite
+{
+public:
+
+	typedef int (*QueryCallBack)(void *callBackArg, int nColumnNum, 
+		char **szColumnValues, char **szColumnNames);
+
+	CSQLite();
+	virtual ~CSQLite();
+
+	bool Open(const char* szFileName);
+	void Close();
+
+	int GetLastInsertRowID();
+	bool ExecuteQuery(const char* szQuery, QueryCallBack callBack, void* callBackArg);
+	const char* GetLastError() const { return m_szErrorMsg; }
+
+    void SetErrorLog(bool bLogError) { m_bLogError = bLogError; }
+    bool IsErrorLogging() { return m_bLogError; }
+
+	class Dataset
+	{
+	public:
+
+		Dataset(CSQLite& sqlite, const char* szQuery);
+		~Dataset();
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؼ<EFBFBD> ó<><C3B3> <20>غ<EFBFBD><D8BA><EFBFBD> <20>Ѵ<EFBFBD>.
+		bool Compile();
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>´<EFBFBD>.
+		bool Execute(int* nColNum_Out = 0, 
+			const char ***pazValue = 0, 
+			const char *** pazColName = 0);
+		
+		bool IsExcuteDone();
+
+		const char* GetLastError() const { return m_szErrorMsg; }
+		void Free();
+
+	private:
+	    
+		CSQLite&	m_SQLite;
+		sqlite_vm*	m_sqlite_vm;
+		const char*	m_szQuery;
+		char*		m_szErrorMsg;
+		int			m_nExecuteResult;
+	};
+
+	class Tableset
+	{
+	public:
+
+		Tableset(CSQLite& sqlite, const char* szQuery);
+		~Tableset();
+
+        bool Execute();
+
+		char** GetResult() { return m_szResult; }
+		int GetMaxRow() { return m_nRow; }
+		int GetMaxCol() { return m_nCol; }
+
+		const char* GetLastError() const { return m_szErrorMsg; }
+
+	private:
+
+		CSQLite&	m_SQLite;
+		const char*	m_szQuery;
+		char**		m_szResult;
+		int			m_nRow;
+		int			m_nCol;		
+		char*		m_szErrorMsg;
+	};
+
+private:
+
+	sqlite* GetHandle() { return m_sqlDB; }
+	sqlite*	m_sqlDB;
+	char*	m_szErrorMsg;
+    bool    m_bLogError;
+
+	friend class Dataset;
+	friend class Tableset;
+};
+
+#endif

Server/ManageTool/ManageLibrary/ManageLibrary.vcproj

@@ -0,0 +1,232 @@
+<?xml version="1.0" encoding="ks_c_5601-1987"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="ManageLibrary"
+	ProjectGUID="{9E56BA4B-AEF8-4F86-9B17-50647A98AE64}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="../Library/$(ConfigurationName)"
+			IntermediateDirectory="../Intermediate/$(ProjectName)/$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="./;../;../../RylServerProject/BaseLibrary;../../RylServerProject/RylServerLibrary"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="2"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/ManageLibrary.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="../Library/$(ConfigurationName)"
+			IntermediateDirectory="../Intermediate/$(ProjectName)/$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="./;../;../../RylServerProject/BaseLibrary;../../RylServerProject/RylServerLibrary"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="2"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/ManageLibrary.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Network"
+			Filter="">
+			<Filter
+				Name="Dispatch"
+				Filter="">
+				<File
+					RelativePath=".\Network\Dispatch\SendManagePacket.cpp">
+				</File>
+				<File
+					RelativePath=".\Network\Dispatch\SendManagePacket.h">
+				</File>
+				<Filter
+					Name="ManageClient"
+					Filter="">
+					<File
+						RelativePath=".\Network\Dispatch\ManageClient\ManageClientDispatch.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageClient\ManageClientDispatch.h">
+					</File>
+				</Filter>
+				<Filter
+					Name="ManageServer"
+					Filter="">
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\ManageServerDispatch.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\ManageServerDispatch.h">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\ManageToolServerDispatch.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\ManageToolServerDispatch.h">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\ParseUserManage.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\StatServerDispatch.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\StatServerDispatch.h">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\StatServerMultiDispatch.cpp">
+					</File>
+					<File
+						RelativePath=".\Network\Dispatch\ManageServer\StatServerMultiDispatch.h">
+					</File>
+				</Filter>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="UserManage"
+			Filter="">
+			<File
+				RelativePath=".\UserManage\ToolUserManageTable.cpp">
+			</File>
+			<File
+				RelativePath=".\UserManage\ToolUserManageTable.h">
+			</File>
+			<File
+				RelativePath=".\UserManage\UserStatistics.cpp">
+			</File>
+			<File
+				RelativePath=".\UserManage\UserStatistics.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ServerManage"
+			Filter="">
+			<File
+				RelativePath=".\ServerManage\ManageClientManager.cpp">
+			</File>
+			<File
+				RelativePath=".\ServerManage\ManageClientManager.h">
+			</File>
+			<File
+				RelativePath=".\ServerManage\SendManageInfo.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="DB"
+			Filter="">
+			<File
+				RelativePath=".\Db\ManageServerDB.cpp">
+			</File>
+			<File
+				RelativePath=".\Db\ManageServerDB.h">
+			</File>
+			<File
+				RelativePath=".\Db\SQLite.cpp">
+			</File>
+			<File
+				RelativePath=".\Db\SQLite.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Setup"
+			Filter="">
+			<File
+				RelativePath=".\Setup\RylServerBindRunID.cpp">
+			</File>
+			<File
+				RelativePath=".\Setup\RylServerBindRunID.h">
+			</File>
+			<File
+				RelativePath=".\Setup\RylServerGroupSetup.cpp">
+			</File>
+			<File
+				RelativePath=".\Setup\RylServerGroupSetup.h">
+			</File>
+			<File
+				RelativePath=".\Setup\SetupClient.cpp">
+			</File>
+			<File
+				RelativePath=".\Setup\SetupClient.h">
+			</File>
+		</Filter>
+		<File
+			RelativePath=".\ReadMe.txt">
+		</File>
+		<File
+			RelativePath=".\stdafx.cpp">
+		</File>
+		<File
+			RelativePath=".\stdafx.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageClient/ManageClientDispatch.cpp

@@ -0,0 +1,835 @@
+#include "stdafx.h"
+
+#include "ManageClientDispatch.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Setup/SetupClient.h>
+
+#include <Network/Dispatch/SingleDispatchStorage.h>
+#include <Network/Dispatch/SendManagePacket.h>
+#include <Log/ServerLog.h>
+
+#include <tlhelp32.h>
+#include <mmsystem.h>
+
+#include <string>
+#include <vector>
+
+#pragma comment(lib, "winmm.lib")
+
+/*
+// forward decl
+HANDLE GetProcessHandle(const char* szProcessFullPathName, unsigned long* lpdwPID);
+*/
+
+enum ManageClientConst
+{
+	MANAGE_CLIENT_DEFAULT_DISPATCH_NUM = 10
+};
+
+
+CManageClientDispatch::RunExtraInfo::RunExtraInfo(const ServerManage::RunInfo& runInfo, 
+                                                  HANDLE hProcess, unsigned long dwProcessID)
+:   m_RunInfo(runInfo), m_hProcess(hProcess), m_dwProcessID(dwProcessID), 
+    m_hWnd(0), m_dwCustomStatus(0), m_dwLastSetWindowHandleTime(0)
+{
+    char szCommand[MAX_PATH];
+
+    _snprintf(szCommand, MAX_PATH - 1, "%s", m_RunInfo.m_szOption);
+    szCommand[MAX_PATH - 1] = 0;
+
+    char* szData = strtok(szCommand, " \t\r\n");
+    while(0 != szData)
+    {        
+        m_CommandSet.insert(szData);
+        szData = strtok(0, " \t\r\n");
+    }
+}
+
+
+CSingleDispatch& CManageClientDispatch::GetDispatchTable()
+{
+	static CSingleDispatch singleDispatch;
+	return singleDispatch;
+}
+
+
+CManageClientDispatch::CManageClientDispatch(CSession& Session)
+:	CRylServerDispatch(Session, MANAGE_CLIENT_DEFAULT_DISPATCH_NUM),
+	m_hPatchFile(INVALID_HANDLE_VALUE),
+	m_bDoPatchNow(false)
+{	
+	TCHAR* szTempFileName = _T("./mytmp_patch.tmp");
+
+	memset(m_szTempPatchFileName, 0, sizeof(TCHAR) * MAX_PATH);
+	_tcscpy(m_szTempPatchFileName, szTempFileName);
+
+	TCHAR szFullPathModuleName[MAX_PATH];
+	
+	GetModuleFileName(NULL, szFullPathModuleName, MAX_PATH - 1);
+	szFullPathModuleName[MAX_PATH - 1] = 0;
+
+    TCHAR szDrive[MAX_PATH];
+    TCHAR szPath[MAX_PATH];
+    TCHAR szName[MAX_PATH];
+    TCHAR szExtension[MAX_PATH];
+
+    _tsplitpath(szFullPathModuleName, szDrive, szPath, szName, szExtension);
+
+	_sntprintf(m_szTempPatchFileName, MAX_PATH - 1, 
+        _T("%s\\%s\\%s"), szDrive, szPath, szTempFileName);
+	m_szTempPatchFileName[MAX_PATH - 1] = 0;
+
+	DETLOG1(g_Log, "this:0x%p/CManageClientDispatch Created", this);
+}
+
+
+CManageClientDispatch::~CManageClientDispatch()
+{
+	if(INVALID_HANDLE_VALUE != m_hPatchFile)
+	{
+        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD>. <20>ݴ´<DDB4>.
+		ERRLOG2(g_Log, "this:0x%0p/HANDLE:0x%p/PatchFile is not closed. close now", this, m_hPatchFile);
+		CloseHandle(m_hPatchFile);
+	}
+
+	DETLOG1(g_Log, "this:0x%p/CManageClientDispatch Destroyed", this);
+}
+
+
+void CManageClientDispatch::Connected()
+{
+	GetDispatchTable().SetDispatch(this);	
+	DETLOG1(g_Log, "this:0x%p/CManageClientDispatch Connected", this);
+}
+
+
+void CManageClientDispatch::Disconnected()
+{
+	GetDispatchTable().RemoveDispatch(this);
+	DETLOG1(g_Log, "this:0x%p/CManageClientDispatch Disconnected", this);
+}
+	
+
+bool CManageClientDispatch::DispatchPacket(PktBase* lpPktBase)
+{
+	PktBase::LengthType nPacketLen = lpPktBase->GetLen();
+
+	if(nPacketLen < sizeof(ServerManage::ManageCommand))
+	{
+		ERRLOG3(g_Log, "IP:%15s/PacketLen:%d/Cmd:0x%02x/Invalid packet length or command",
+			GetSession().GetRemoteAddr().get_addr_string(), lpPktBase->GetLen(), lpPktBase->GetCmd());
+	}
+	else
+	{
+		ServerManage::ManageCommand* lpManageCommand = 
+			reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);
+
+		if(nPacketLen != sizeof(ServerManage::ManageCommand) + lpManageCommand->usDataLen)
+		{
+			ERRLOG3(g_Log, "IP:%15s/PacketLen:%d/Cmd:0x%02x/Invalid packet length",
+				GetSession().GetRemoteAddr().get_addr_string(), lpPktBase->GetLen(), lpPktBase->GetCmd());
+		}
+		else
+		{
+            TCHAR* szWindowName = 0;
+            
+			char* lpData = (0 != lpManageCommand->usDataLen) ? 
+				reinterpret_cast<char*>(lpManageCommand + 1) : 0;
+
+			const TCHAR* szErrorMessage = 0;
+
+			switch(lpManageCommand->GetCmd())
+			{
+			case ServerManage::CMD::UpdateRunList:		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ش<EFBFBD>   (ManageServer -> ManageClient, ManageTool), Ack<63><6B><EFBFBD><EFBFBD>.
+                ProcessUpdateRunList(lpData, lpManageCommand->usDataLen, lpManageCommand->usFlags);
+                break;
+			
+            case ServerManage::CMD::RunProcess:			// <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.          (ManageTool   -> ManageServer -> ManageClient), Ack<63><6B> <20>ݴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+                ProcessRunServer(lpManageCommand->dwRunID);
+                break;
+			
+			case ServerManage::CMD::QuitProcess:		// <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.          (ManageTool   -> ManageServer -> ManageClient), Ack<63><6B> <20>ݴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+                ProcessQuitServer(lpManageCommand->dwRunID);
+                break;
+			
+            case ServerManage::CMD::ForceTerminate:		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.     (ManageTool   -> ManageServer -> ManageClient), Ack<63><6B> <20>ݴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+			    ProcessTerminateServer(lpManageCommand->dwRunID);
+                break;            
+
+			case ServerManage::CMD::RelayCommand:	// <20><>Ŷ Ŀ<>ǵ带 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD><EFBFBD><EFBFBD> <20>Ἥ <20>߰<EFBFBD><DFB0>ؼ<EFBFBD> <20>ѱ<EFBFBD><D1B1><EFBFBD>.
+		
+                /*
+				if(!ProcessRelayCommand(lpManageCommand->nMessage, 
+					lpManageCommand->wParam, lpManageCommand->lParam, 
+					szWindowName, lpData, lpManageCommand->usDataLen, lpManageCommand->cFlag))
+				{
+					szErrorMessage = _T("RelayCommand : RelayCommand Failed");
+				}
+                */
+				break;
+				
+			case ServerManage::CMD::AutoPatch:		// <20>ڱ<EFBFBD> <20>ڽ<EFBFBD><DABD><EFBFBD> <20><>ġ<EFBFBD>Ѵ<EFBFBD>
+				
+				if(!ProcessAutoPatch(lpData, lpManageCommand->usDataLen, lpManageCommand->usFlags))
+				{
+					szErrorMessage = _T("AutoPatch : AutoPatch packet process failed");
+				}
+				break;
+
+			case ServerManage::CMD::ChangeSetup:		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٲٰ<D9B2> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+
+                if(!ManageSetup::ClientSetup::GetInstance().SerializeIn(lpData, lpManageCommand->usDataLen))
+				{
+					szErrorMessage = _T("ChangeSetup : Change setup failed");
+				}
+				else
+				{
+                    ManageSetup::ClientSetup::GetInstance().Save();
+				}
+				break;
+
+			case ServerManage::CMD::ReloadSetup:		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ε<EFBFBD><CEB5>Ѵ<EFBFBD>.
+
+				ManageSetup::ClientSetup::GetInstance().Load();
+				break;
+
+
+            case ServerManage::CMD::ExecuteCommand:
+                ProcessExecuteConsoleCommand(lpManageCommand);
+                break;
+
+			default:
+
+				szErrorMessage = _T("Unknown message : Process failed");
+				break;
+			}
+
+			if(0 != szErrorMessage)
+			{
+				ERRLOG4(g_Log, "IP:%15s/DetailCmd:0x%02x/Error:%d/%s",
+					GetSession().GetRemoteAddr().get_addr_string(), 
+					lpPktBase->GetCmd(), GetLastError(), szErrorMessage);
+			}
+		}
+	}
+	
+	return true;
+}
+
+
+
+
+bool CManageClientDispatch::ProcessRelayCommand(unsigned int nMessage, WPARAM wParam, LPARAM lParam,
+												const char* szWindowName, const char* lpData, 
+												unsigned short usDataLen, unsigned char cFlag)
+{
+	if(0 != szWindowName)
+	{
+		HWND hWnd = FindWindow(0, szWindowName);
+		if(0 != hWnd)
+		{
+			if(0 != lpData && WM_COPYDATA == nMessage)
+			{
+                COPYDATASTRUCT copyDataStruct;
+
+				copyDataStruct.dwData = 0;
+				copyDataStruct.cbData = usDataLen;
+				copyDataStruct.lpData = (void*)lpData;
+
+				// <20>޽<EFBFBD><DEBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+				SendMessage(hWnd, nMessage, wParam, 
+					reinterpret_cast<LPARAM>(&copyDataStruct));
+			}
+			else
+			{
+				SendMessage(hWnd, nMessage, wParam, lParam);
+			}
+		}
+	}
+
+	return true;
+}
+
+
+
+bool CManageClientDispatch::ProcessAutoPatch(const char* lpData, unsigned short usDataLen, unsigned short usFlag)
+{
+	switch(usFlag)
+	{
+	case ServerManage::ManageCommand::AUTOPATCH_OPENFILE:
+
+		if(INVALID_HANDLE_VALUE != m_hPatchFile)
+		{
+			// <20><>ġ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>. <20>ݴ´<DDB4>.
+			ERRLOG2(g_Log, "this:0x%0p/HANDLE:0x%p/PatchFile is not closed. close now for create new one", 
+				this, m_hPatchFile);
+
+			CloseHandle(m_hPatchFile);
+		}
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+		m_hPatchFile = CreateFile(m_szTempPatchFileName, GENERIC_WRITE, 0, 0,
+			CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+
+		if(INVALID_HANDLE_VALUE == m_hPatchFile)
+		{
+			ERRLOG2(g_Log, "this:0x%p/Error:%d/Patch tempfile create failed", 
+				this, GetLastError());
+		}
+		break;
+
+	case ServerManage::ManageCommand::AUTOPATCH_DATA:
+
+		if(INVALID_HANDLE_VALUE != m_hPatchFile)
+		{
+			unsigned long dwWritten = 0;
+			unsigned long dwTotalWritten = 0;
+
+			while(usDataLen != dwTotalWritten)
+			{
+                if(!WriteFile(m_hPatchFile, lpData, usDataLen, &dwWritten, 0))
+				{
+					ERRLOG3(g_Log, "this:0x%p/HANDLE:0x%p/Error:%d/Patchfile write failed.",
+						this, m_hPatchFile, GetLastError());
+
+					CloseHandle(m_hPatchFile);
+					m_hPatchFile = INVALID_HANDLE_VALUE;
+
+					DeleteFile(m_szTempPatchFileName);
+					break;
+				}
+
+				dwTotalWritten += dwWritten;
+			}
+
+			if(0 == usDataLen && INVALID_HANDLE_VALUE != m_hPatchFile)
+			{
+				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>޾Ҵ<DEBE>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><>ġ<EFBFBD><C4A1> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+				m_bDoPatchNow = true;
+			}
+		}
+		else
+		{
+			ERRLOG1(g_Log, "this:0x%p/Patchfile is invalid", this);
+		}
+		break;
+	}
+
+	return true;
+}	
+
+	
+
+bool CManageClientDispatch::ProcessUpdateRunList(const char* szData, unsigned short usDataLen, 
+                                                 unsigned short usFlags)
+{
+    if(ServerManage::SEND_RUNINFO_START == usFlags)
+    {        
+        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Process<73>鿡 <20><><EFBFBD>ؼ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD><DAB5><EFBFBD> <20>ݴ´<DDB4>.
+        RunTable::iterator pos = m_RunTable.begin();
+        RunTable::iterator end = m_RunTable.end();
+
+        for(; pos != end; ++pos)
+        {
+            RunExtraInfo& runExtraInfo = pos->second;
+
+            if(0 != runExtraInfo.m_hProcess)
+            {
+                CloseHandle(runExtraInfo.m_hProcess);
+            }
+        }
+
+        m_RunTable.clear();
+    }
+    else if(ServerManage::SEND_RUNINFO_NOW == usFlags)
+    {
+        // RunTable<6C><65> <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD>, <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.    
+        const ServerManage::RunInfo* lpRunInfo    = reinterpret_cast<const ServerManage::RunInfo*>(szData);
+        const ServerManage::RunInfo* lpEndRunInfo = lpRunInfo + (usDataLen / sizeof(ServerManage::RunInfo));
+        
+        for(; lpRunInfo != lpEndRunInfo; ++lpRunInfo)
+        {
+            m_RunTable.insert(RunTable::value_type(lpRunInfo->m_dwRunID,
+                RunExtraInfo(*lpRunInfo, 0, 0)));
+        }
+    }
+    else if(ServerManage::SEND_RUNINFO_FINISH == usFlags)
+    {
+        // <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+        CheckProcessStatus();
+    }
+
+    return true;
+}
+
+bool CManageClientDispatch::ProcessRunServer(unsigned long dwRunID)
+{
+    RunTable::iterator pos = m_RunTable.find(dwRunID);
+
+    if(pos != m_RunTable.end())
+    {
+        RunExtraInfo& runExInfo = pos->second;
+
+        TCHAR szDrive[MAX_PATH];
+        TCHAR szPath[MAX_PATH];
+
+        TCHAR szDefaultPath[MAX_PATH];
+
+        _splitpath(runExInfo.m_RunInfo.m_szPath, szDrive, szPath, 0, 0);
+
+        _snprintf(szDefaultPath, MAX_PATH - 1, "%s%s", szDrive, szPath);
+        szDefaultPath[MAX_PATH - 1] = 0;
+
+		STARTUPINFO si;
+		PROCESS_INFORMATION pi;
+
+		ZeroMemory(&si, sizeof(si));
+		si.cb = sizeof(si);
+
+		ZeroMemory(&pi, sizeof(pi));
+
+		// Start the child process. 
+        
+
+/*
+		if(CreateProcess(runExInfo.m_RunInfo.m_szPath, runExInfo.m_RunInfo.m_szOption, 0, 0, 
+			FALSE, 0, 0, szDefaultPath, &si, &pi))
+*/
+        char szExecutePath[MAX_PATH * 2];
+        _snprintf(szExecutePath, MAX_PATH * 2 - 1, "\"%s\" %s", 
+            runExInfo.m_RunInfo.m_szPath, runExInfo.m_RunInfo.m_szOption);
+
+        szExecutePath[MAX_PATH * 2 - 1] = 0;
+
+		if(CreateProcess(0, szExecutePath, 0, 0, 
+            FALSE, 0, 0, szDefaultPath, &si, &pi))
+
+		{
+            runExInfo.m_hProcess    = pi.hProcess;
+            runExInfo.m_dwProcessID = pi.dwProcessId;
+
+            DETLOG4(g_Log, "Execute file success, RunID(%u), Path(%s), Option(%s), DefaultPath(%s)", 
+                runExInfo.m_RunInfo.m_dwRunID, runExInfo.m_RunInfo.m_szPath, 
+                runExInfo.m_RunInfo.m_szOption, szDefaultPath);
+        }
+        else
+        {
+            ERRLOG5(g_Log, "Cannot execute file : CreateProcess failed(%d), RunID(%u), "
+                "Path(%s), Option(%s), DefaultPath(%s)", 
+                WSAGetLastError(), runExInfo.m_RunInfo.m_dwRunID, 
+                runExInfo.m_RunInfo.m_szPath, runExInfo.m_RunInfo.m_szOption, szDefaultPath);
+        }
+    }
+    else
+    {
+        ERRLOG1(g_Log, "Cannot execute file : Unknown RunID(%d)", dwRunID);
+    }
+
+    return true;
+}
+
+bool CManageClientDispatch::ProcessQuitServer(unsigned long dwRunID)
+{
+    RunTable::iterator pos = m_RunTable.find(dwRunID);
+
+    if(pos != m_RunTable.end())
+    {
+        RunExtraInfo& runExInfo = pos->second;
+
+        if(0 != runExInfo.m_hWnd)
+        {
+            TCHAR szWindowName[MAX_PATH];
+            GetWindowText(runExInfo.m_hWnd, szWindowName, MAX_PATH - 1);
+            szWindowName[MAX_PATH - 1] = 0;
+
+            SendMessage(runExInfo.m_hWnd, WM_DESTROY, 0, 0);
+
+            DETLOG6(g_Log, "Send quit message : HANDLE(0x%p), PID(0x%08x), WindowName(%s), "
+                "RunID(%u), Path(%s), Option(%s)",
+                runExInfo.m_hProcess, runExInfo.m_dwProcessID, szWindowName,
+                runExInfo.m_RunInfo.m_dwRunID, runExInfo.m_RunInfo.m_szPath, 
+                runExInfo.m_RunInfo.m_szOption);
+        }
+        else
+        {
+            ERRLOG5(g_Log, "Cannot send quit message (Get window failed) : "
+                "HANDLE(0x%p), PID(0x%08x), RunID(%u), Path(%s), Option(%s)",
+                runExInfo.m_hProcess, runExInfo.m_dwProcessID, 
+                runExInfo.m_RunInfo.m_dwRunID, runExInfo.m_RunInfo.m_szPath, 
+                runExInfo.m_RunInfo.m_szOption);
+        }            
+    }
+
+    return true;
+}
+
+bool CManageClientDispatch::ProcessTerminateServer(unsigned long dwRunID)
+{
+    RunTable::iterator pos = m_RunTable.find(dwRunID);
+
+    if(pos != m_RunTable.end())
+    {
+        RunExtraInfo& runExInfo = pos->second;
+
+        if(0 != runExInfo.m_hProcess)
+        {
+            if(TerminateProcess(runExInfo.m_hProcess, -1))
+            {
+                DETLOG5(g_Log, "Terminate process. HANDLE(0x%p), PID(0x%08x), "
+                    "RunID(%u), Path(%s), Option(%s)",
+                    runExInfo.m_hProcess, runExInfo.m_dwProcessID, 
+                    runExInfo.m_RunInfo.m_dwRunID, runExInfo.m_RunInfo.m_szPath, 
+                    runExInfo.m_RunInfo.m_szOption);                
+            }
+            else
+            {
+                ERRLOG6(g_Log, "Cannot terminate process. Err(%d), HANDLE(0x%p), PID(0x%08x), "
+                    "RunID(%u), Path(%s), Option(%s)",
+                    GetLastError(), runExInfo.m_hProcess, runExInfo.m_dwProcessID, 
+                    runExInfo.m_RunInfo.m_dwRunID, runExInfo.m_RunInfo.m_szPath, 
+                    runExInfo.m_RunInfo.m_szOption);                
+            }
+        }
+    }
+
+    return true;
+}
+
+
+bool CManageClientDispatch::ProcessExecuteConsoleCommand(ServerManage::ManageCommand* lpManageCmd)
+{
+    RunTable::iterator pos = m_RunTable.find(lpManageCmd->dwRunID);
+
+    if(pos != m_RunTable.end())
+    {
+        RunExtraInfo& runExInfo = pos->second;
+
+        if(0 != runExInfo.m_hWnd)
+        {
+            COPYDATASTRUCT copyDataStruct;
+
+            copyDataStruct.dwData = 0;
+            copyDataStruct.cbData = lpManageCmd->GetLen();
+            copyDataStruct.lpData = lpManageCmd;
+
+            SendMessage(runExInfo.m_hWnd, WM_COPYDATA, 0, (LPARAM)&copyDataStruct);
+        }
+    }
+    
+    return true;
+}
+
+
+void CManageClientDispatch::CheckProcessStatus()
+{
+    const int MAX_PROCESS_STATUS_SEND_ONCE = 
+        (PktMaxLen - sizeof(ServerManage::ManageCommand)) / sizeof(ServerManage::ProcessStatus);
+
+    ServerManage::ProcessStatus procesStatus[MAX_PROCESS_STATUS_SEND_ONCE];
+
+    RunTable::iterator pos = m_RunTable.begin();
+    RunTable::iterator end = m_RunTable.end();
+
+    for(; pos != end; ++pos)
+    {
+        RunExtraInfo& runExtraInfo = pos->second;
+
+        // üũ<C3BC>ϰ<EFBFBD>, PID<49><44> <20>ִµ<D6B4> <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD>, <20><><EFBFBD>μ<EFBFBD><CEBC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+        if(0 != runExtraInfo.m_dwProcessID && 0 != runExtraInfo.m_hWnd
+            && 0 == runExtraInfo.m_hProcess)
+        {
+            runExtraInfo.m_hProcess = OpenProcess(PROCESS_ALL_ACCESS, 
+                FALSE, runExtraInfo.m_dwProcessID);
+        }
+    }
+
+    unsigned long dwExitCode  = 0;
+    unsigned long dwErrorCode = 0;
+    unsigned short usSendProcessStatus = 0;
+
+    pos = m_RunTable.begin();
+    end = m_RunTable.end();
+
+    for(; pos != end; ++pos)
+    {
+        RunExtraInfo& runExtraInfo = pos->second;
+
+        // Default - Deactivated Process.
+        ServerManage::ProcessStatus* lpCurrentProcessStatus = procesStatus + usSendProcessStatus;
+        memset(lpCurrentProcessStatus, 0, sizeof(ServerManage::ProcessStatus));
+
+        lpCurrentProcessStatus->m_dwRunID = runExtraInfo.m_RunInfo.m_dwRunID;
+        lpCurrentProcessStatus->m_dwStatusFlags = 0;
+        lpCurrentProcessStatus->m_dwCurrentTime = timeGetTime();
+        lpCurrentProcessStatus->m_dwCustomStatus = runExtraInfo.m_dwCustomStatus;
+        lpCurrentProcessStatus->m_dwLastSetWindowHandleTime = runExtraInfo.m_dwLastSetWindowHandleTime;
+        
+        if(0 != runExtraInfo.m_hProcess)
+        {
+            GetProcessTimes(runExtraInfo.m_hProcess,
+                &lpCurrentProcessStatus->m_CreationTIme,
+                &lpCurrentProcessStatus->m_ExitTime,
+                &lpCurrentProcessStatus->m_KernelTime,
+                &lpCurrentProcessStatus->m_UserTime);
+
+            GetProcessMemoryInfo(runExtraInfo.m_hProcess,
+                &lpCurrentProcessStatus->m_ProcessMemoryCounters,
+                sizeof(PROCESS_MEMORY_COUNTERS));
+
+            if(!GetExitCodeProcess(runExtraInfo.m_hProcess, &dwExitCode))
+            {
+                ERRLOG3(g_Log, "GetExitCodeProcess failed(%d) : RunID(%u), Path(%s)",
+                    dwErrorCode, runExtraInfo.m_RunInfo.m_dwRunID, 
+                    runExtraInfo.m_RunInfo.m_szPath);
+            }
+            else if(dwExitCode != STILL_ACTIVE)
+            {
+                DETLOG4(g_Log, "Close process handle : HANDLE(0x%p), PID(0x%08x), RunID(%u), Path(%s)",
+                    runExtraInfo.m_hProcess, runExtraInfo.m_dwProcessID, 
+                    runExtraInfo.m_RunInfo.m_dwRunID, runExtraInfo.m_RunInfo.m_szPath);
+
+                CloseHandle(runExtraInfo.m_hProcess);
+                runExtraInfo.m_hProcess     = 0;
+                runExtraInfo.m_dwProcessID  = 0;
+                runExtraInfo.m_hWnd         = 0;
+                runExtraInfo.m_dwLastSetWindowHandleTime = 0;                
+            }
+            else
+            {
+                lpCurrentProcessStatus->m_dwStatusFlags = 
+                    ServerManage::PROCESS_RUNNING;
+            }
+        }
+
+        ++usSendProcessStatus;
+
+        if(usSendProcessStatus == MAX_PROCESS_STATUS_SEND_ONCE)
+        {
+            ServerManage::SendManagePacket(GetSession(), ServerManage::CMD::ProcessStatus, 
+                0, 0, 0, 0, sizeof(ServerManage::ProcessStatus) * usSendProcessStatus, 0, procesStatus, 0);
+
+            usSendProcessStatus = 0;
+        }
+    }
+
+    if(0 < usSendProcessStatus)
+    {
+        ServerManage::SendManagePacket(GetSession(), ServerManage::CMD::ProcessStatus, 
+            0, 0, 0, 0, sizeof(ServerManage::ProcessStatus) * usSendProcessStatus, 0, procesStatus, 0);
+
+        usSendProcessStatus = 0;
+    }
+}
+
+bool CManageClientDispatch::SetAppData(unsigned long dwRunID, HWND hWnd, 
+                                       unsigned long dwPID, unsigned long dwCustomStatus)
+{
+    RunTable::iterator pos = m_RunTable.find(dwRunID);
+    RunTable::iterator end = m_RunTable.end();
+    
+    if(pos != end)
+    {
+        RunExtraInfo& runExtraInfo = pos->second;
+
+        runExtraInfo.m_dwProcessID = dwPID;
+        runExtraInfo.m_hWnd = hWnd;
+        runExtraInfo.m_dwCustomStatus = dwCustomStatus;
+        runExtraInfo.m_dwLastSetWindowHandleTime = timeGetTime();
+
+        return true;
+    }
+
+    return false;
+}
+
+
+bool CManageClientDispatch::GetRunIDFromString(const char* szAppName, const char* szCommandLine,
+                                               unsigned long& dwRunID_Out)
+{
+    char szProcessName[MAX_PATH];
+    char szProcessSnapName[MAX_PATH];
+
+    _snprintf(szProcessSnapName, MAX_PATH - 1, "%s", szAppName);
+    szProcessSnapName[MAX_PATH - 1]  = 0;
+    _strupr(szProcessSnapName);
+    
+    char szCommandLineData[MAX_PATH * 2];
+    _snprintf(szCommandLineData, MAX_PATH * 2 - 1, "%s", szCommandLine);
+    szCommandLineData[MAX_PATH * 2 - 1] = 0;
+
+    RunExtraInfo::CommandSet commandSet;
+    
+    char* szData = 0;
+
+    if('\"' == szCommandLineData[0])
+    {
+        szData = strtok(szCommandLineData, "\"");
+        szData = strtok(0, "\"");
+
+        if(0 != szData)
+        {
+            // <20><><EFBFBD>ϸ<EFBFBD><CFB8><EFBFBD> <20>и<EFBFBD><D0B8><EFBFBD> Argument<6E><74> <20>޾Ƽ<DEBE> ó<><C3B3>..
+            char szRealCommandLine[MAX_PATH];
+            _snprintf(szRealCommandLine, MAX_PATH - 1, "%s", szData);
+            szRealCommandLine[MAX_PATH - 1] = 0;
+
+            szData = strtok(szRealCommandLine, " \t\r\n");
+            while(0 != szData)
+            {        
+                commandSet.insert(szData);
+                szData = strtok(0, " \t\r\n");
+            }
+        }
+    }
+    else
+    {
+        szData = strtok(szCommandLineData, " \t\r\n");        
+
+        // ù<><C3B9>° Argument<6E><74> <20><><EFBFBD>ϸ<EFBFBD><CFB8>̹Ƿ<CCB9> <20><><EFBFBD><EFBFBD>.
+        szData = strtok(0, " \t\r\n");  
+        while(0 != szData)
+        {        
+            commandSet.insert(szData);
+            szData = strtok(0, " \t\r\n");
+        }
+    }
+
+    RunTable::iterator pos = m_RunTable.begin();
+    RunTable::iterator end = m_RunTable.end();
+    
+    for(; pos != end; ++pos)
+    {
+        RunExtraInfo& runExtraInfo = pos->second;
+        
+        _snprintf(szProcessName, MAX_PATH - 1, "%s", runExtraInfo.m_RunInfo.m_szPath);
+        szProcessName[MAX_PATH - 1]  = 0;
+        _strupr(szProcessName);
+
+        if(0 == strncmp(szProcessName, szProcessSnapName, MAX_PATH))
+        {
+            if((runExtraInfo.m_CommandSet.size() == commandSet.size()
+                && std::equal(runExtraInfo.m_CommandSet.begin(), 
+                runExtraInfo.m_CommandSet.end(), commandSet.begin())))
+            {
+                dwRunID_Out = runExtraInfo.m_RunInfo.m_dwRunID;
+                return true;
+            }            
+        }
+    }
+
+    dwRunID_Out = 0;
+    return false;
+}
+
+
+bool CManageClientDispatch::GetRunIDFromPID(unsigned long dwPID, unsigned long& dwRunID_Out)
+{
+    RunTable::iterator pos = m_RunTable.begin();
+    RunTable::iterator end = m_RunTable.end();
+
+    for(; pos != end; ++pos)
+    {
+        RunExtraInfo& runExtraInfo = pos->second;
+
+        if(runExtraInfo.m_dwProcessID == dwPID)
+        {
+            dwRunID_Out = runExtraInfo.m_RunInfo.m_dwRunID;
+            return true;
+        }
+    }
+
+    dwRunID_Out = 0;
+    return false;
+}
+
+
+
+
+/*
+HANDLE GetProcessHandle(const char* szProcessFullPathName, unsigned long* lpdwPID)
+{
+    HANDLE hProcess = INVALID_HANDLE_VALUE;
+
+    if(0 == lpdwPID)
+    {
+        return hProcess;
+    }
+
+    //  Take a snapshot of all processes in the system. 
+    HANDLE hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 
+
+    if (hProcessSnap == INVALID_HANDLE_VALUE) 
+    {
+        return hProcess;
+    }
+    
+    //  Fill in the size of the structure before using it. 
+    PROCESSENTRY32 pe32 = {0}; 
+    pe32.dwSize = sizeof(PROCESSENTRY32); 
+    
+    //  Walk the snapshot of the processes, and for each process, 
+    //  display information. 
+
+    char szProcessName[MAX_PATH];
+    char szProcessSnapName[MAX_PATH];
+
+    _snprintf(szProcessName, MAX_PATH - 1, "%s", szProcessFullPathName);
+    szProcessName[MAX_PATH - 1]  = 0;
+
+    _strupr(szProcessName);
+
+    bool bFound = false;
+
+    if (Process32First(hProcessSnap, &pe32)) 
+    { 
+        do 
+        { 
+            MODULEENTRY32 me32 = {0};
+
+            HANDLE hModuleSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pe32.th32ProcessID); 
+            if (hModuleSnap != INVALID_HANDLE_VALUE) 
+            {
+                me32.dwSize = sizeof(MODULEENTRY32);
+         
+                if (Module32First(hModuleSnap, &me32)) 
+                { 
+                    do 
+                    { 
+                        _snprintf(szProcessSnapName, MAX_PATH - 1, "%s", me32.szExePath);
+                        szProcessSnapName[MAX_PATH - 1]  = 0;
+
+                        _strupr(szProcessSnapName);
+
+                        if(0 == strcmp(szProcessName, szProcessSnapName))
+                        { 
+                            // Get the actual priority class. 
+                            hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID);
+                            if(INVALID_HANDLE_VALUE == hProcess)
+                            {
+                                ERRLOG2(g_Log, "Process open failed(%d) : %s",
+                                    GetLastError(), me32.szExePath);
+                            }
+
+                            *lpdwPID = pe32.th32ProcessID;
+                            bFound = true;
+                            break;
+                        }
+                    } 
+
+                    while (!bFound && Module32Next(hModuleSnap, &me32)); 
+                } 
+
+                CloseHandle (hModuleSnap);
+            }
+        }
+
+        while (!bFound && Process32Next(hProcessSnap, &pe32));         
+    } 
+
+    CloseHandle(hProcessSnap);
+    return hProcess;
+}
+
+*/

Server/ManageTool/ManageLibrary/Network/Dispatch/ManageClient/ManageClientDispatch.h

@@ -0,0 +1,90 @@
+#ifndef _GM_MANAGE_CLIENT_DISPATCH_H_
+#define _GM_MANAGE_CLIENT_DISPATCH_H_
+
+#pragma warning(disable:4800)
+
+#include <map>
+#include <set>
+#include <boost/pool/pool_alloc.hpp>
+#include <Network/Dispatch/RylServerDispatch.h>
+#include <Network/Dispatch/SingleDispatchStorage.h>
+#include <Network/Packet/ManagePacketCmd.h>
+
+// CManageClientDispatch<63><68> <20><><EFBFBD><EFBFBD> Ŭ<><C5AC><EFBFBD>̾<EFBFBD>Ʈ<EFBFBD><C6AE> <20><> <20><><EFBFBD>̺귯<CCBA><EAB7AF><EFBFBD><EFBFBD> <20><>ũ<EFBFBD><C5A9>.
+#pragma comment(lib, "psapi.lib")
+
+class CManageClientDispatch : public CRylServerDispatch
+{
+public:
+
+    struct RunExtraInfo
+    {
+        typedef std::set<std::string> CommandSet;
+
+        ServerManage::RunInfo m_RunInfo;
+        HANDLE                m_hProcess;
+        HWND                  m_hWnd;
+        unsigned long         m_dwProcessID;
+        unsigned long         m_dwCustomStatus;
+        unsigned long         m_dwLastSetWindowHandleTime;
+        
+        CommandSet            m_CommandSet;
+
+        RunExtraInfo();
+        RunExtraInfo(const ServerManage::RunInfo& runInfo,
+            HANDLE hProcess, unsigned long dwProcessID);
+    };
+
+    // Key - RunID
+	typedef std::map<unsigned long, RunExtraInfo, std::less<unsigned long>, 
+		boost::pool_allocator<std::pair<unsigned long, RunExtraInfo> > > RunTable;
+
+	static CSingleDispatch& GetDispatchTable();
+
+	CManageClientDispatch(CSession& Session);
+	virtual ~CManageClientDispatch();
+
+    void CheckProcessStatus();
+
+	bool DoPatchNow() const { return m_bDoPatchNow; }
+	const TCHAR* GetTempPatchFileName() const { return m_szTempPatchFileName; }
+    
+    bool SetAppData(unsigned long dwRunID, HWND hWnd, 
+        unsigned long dwPID, unsigned long dwCustomStatus);
+
+    bool GetRunIDFromPID(unsigned long dwPID, unsigned long& dwRunID_Out);
+        
+    bool GetRunIDFromString(const char* szAppName, 
+        const char* szCommandLine, unsigned long& dwRunID_Out);
+
+    RunTable& GetRunTable() { return m_RunTable; }
+
+private:
+
+	virtual void Connected();
+	virtual void Disconnected();
+	
+	virtual bool DispatchPacket(PktBase* lpPktBase);
+
+    bool ProcessUpdateRunList(const char* szData, unsigned short usDataLen, unsigned short usFlags);
+    bool ProcessRunServer(unsigned long dwRunID);
+    bool ProcessQuitServer(unsigned long dwRunID);
+	bool ProcessTerminateServer(unsigned long dwRunID);
+    bool ProcessExecuteConsoleCommand(ServerManage::ManageCommand* lpManageCmd);
+
+	bool ProcessRelayCommand(unsigned int nMessage, WPARAM wParam, LPARAM lParam,
+		const char* szWindowName, const char* lpData, unsigned short usDataLen, unsigned char cFlag);
+
+	bool ProcessAutoPatch(const char* lpData, unsigned short usDataLen, unsigned short usFlag);
+    
+	// Member variable;
+	HANDLE	    m_hPatchFile;						// <20><>ġ <20><><EFBFBD><EFBFBD> <20>ڵ<EFBFBD>.	
+	TCHAR	    m_szTempPatchFileName[MAX_PATH];	// <20>ӽ<EFBFBD> <20><>ġ <20><><EFBFBD><EFBFBD> <20≯<EFBFBD>.
+	bool	    m_bDoPatchNow;						// <20><>ġ <20>غ<EFBFBD><D8BA><EFBFBD> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>θ<EFBFBD> <20>˾ƿ<CBBE>.    
+
+
+    RunTable    m_RunTable;
+};
+
+
+#endif

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()
+{
+	// <20><><EFBFBD><EFBFBD> IP<49><50> key<65><79> <20><><EFBFBD>Ƽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+	INET_Addr& remoteAddr = GetSession().GetRemoteAddr();
+
+	unsigned long dwDispatchID = remoteAddr.get_addr_in().sin_addr.S_un.S_addr;
+	GetDispatchTable().SetDispatch(dwDispatchID, this);
+	
+    // TODO : <20><><EFBFBD><EFBFBD> IP<49><50> <20>˻<EFBFBD><CBBB>ؼ<EFBFBD>, RunInfo<66><6F><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+
+    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()
+{
+	// <20><><EFBFBD><EFBFBD> IP<49><50> key<65><79> <20><><EFBFBD>Ƽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+	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()
+{
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> LoginTable<6C><65> <20><><EFBFBD>Եȴ<D4B5>.
+	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<><32> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>´<EFBFBD>.
+    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;
+
+            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϸ<EFBFBD> RunInfo<66><6F> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+            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())
+		{
+        // <20><><EFBFBD><EFBFBD> Ŀ<>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD>, RunID<49><44> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD><EFBFBD><EFBFBD> Relay<61>Ѵ<EFBFBD>. 
+        // Relay<61><79><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>и<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ش<EFBFBD>.
+        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;
+
+		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> LoginTable<6C><65> <20><><EFBFBD>Եȴ<D4B5>.
+		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());
+
+		// <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>鿡<EFBFBD><E9BFA1> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+		ServerManage::SendUserInfo(GetBufferFactory(), 0, &m_UserInfo, 1, 
+			ServerManage::CMD::UserLogin, 0);
+
+        // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ش<EFBFBD>.
+        ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+            &CToolUserManager::GetInstance().GetManageUser(), 1, 
+            ServerManage::CMD::ManagerInfo, 0);
+
+		// <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>α<EFBFBD><CEB1><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޴´<DEB4>.
+		CToolUserManager::GetInstance().SendAllLoginUserInfo(GetSession());
+
+#pragma todo("<22><><EFBFBD><EFBFBD> Setup<75><70> <20>ش<EFBFBD>")
+	}
+	
+	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)
+        {
+            // <20><><EFBFBD><EFBFBD> Promote<74><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD><D6B4><EFBFBD> <20><><EFBFBD>ɴ<EFBFBD>. <20><><EFBFBD>ų<EFBFBD>, Master<65><72> <20>ٷ<EFBFBD> Promote<74><65> <20>ϰ<EFBFBD> Broadcast<73><74> <20>Ѵ<EFBFBD>.
+            CToolUserManager::GetInstance().Promote(m_UserInfo);
+
+            ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+                &m_UserInfo, 1, ServerManage::CMD::ManagerInfo, 0);
+        }
+        else if(m_UserInfo.usAdminLevel == CToolUserManager::GENERAL)
+        {
+            // <20><><EFBFBD><EFBFBD> Promote<74><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ְ<EFBFBD>, <20><><EFBFBD><EFBFBD> General<61><6C><EFBFBD><EFBFBD><EFBFBD≯<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD><C3BB> <20>Ѵ<EFBFBD>.
+            CManageToolServerDispatch* lpToolUserDispatch = 
+                CToolUserManager::GetInstance().GetManageUserDispatch();
+
+            ServerManage::UserInfo userInfo = m_UserInfo;
+            userInfo.usSubCommand = ServerManage::CMD::REQUEST_TAKEBACK_PROMOTE;
+
+            // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD>.
+            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:
+            
+            // ó<><C3B3> <20><>û<EFBFBD>ڸ<EFBFBD> ã<>Ƽ<EFBFBD> Promote <20><><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+            lpRequestDispatch = CToolUserManager::GetInstance().GetUserDispatch(lpUserInfo->szID);
+            if(0 != lpRequestDispatch)
+            {
+                ServerManage::UserInfo manager = lpRequestDispatch->GetUserInfo();
+
+                // Promote ó<><C3B3>.
+                CToolUserManager::GetInstance().Promote(manager);
+                
+                // <20><><EFBFBD><EFBFBD> Manager<65><72><EFBFBD><EFBFBD> <20><>õ<EFBFBD>Ͽ<EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD>.
+                ServerManage::SendUserInfo(GetBufferFactory(), 0, 
+                    &manager, 1, ServerManage::CMD::ManagerInfo, 0);
+
+                // <20><><EFBFBD>ο<EFBFBD><CEBF><EFBFBD> Ack.
+                ServerManage::SendUserInfo(GetBufferFactory(), &lpRequestDispatch->GetSession(), 
+					&manager, 1, ServerManage::CMD::RequestPromote, 0);
+            }
+            break;
+
+        case ServerManage::CMD::NAK_TAKEBACK_PROMOTE:
+            // ó<><C3B3> <20><>û<EFBFBD>ڸ<EFBFBD> ã<>Ƽ<EFBFBD> Promote <20><><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+            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()
+{
+	// <20><><EFBFBD><EFBFBD> IP<49><50> key<65><79> <20><><EFBFBD>Ƽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+	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()
+{
+	// <20><><EFBFBD><EFBFBD> IP<49><50> key<65><79> <20><><EFBFBD>Ƽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ѵ<EFBFBD>.
+	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

Server/ManageTool/ManageLibrary/Network/Dispatch/SendManagePacket.cpp

@@ -0,0 +1,208 @@
+#include "stdafx.h"
+#include "SendManagePacket.h"
+
+#include <tchar.h>
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/Dispatch.h>
+#include <Network/Packet/WrapPacket.h>
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Stream/Buffer/Buffer.h>
+#include <Stream/Buffer/BufferFactory.h>
+#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>
+
+#include <UserManage/ToolUserManageTable.h>
+#include <Log/ServerLog.h>
+
+
+/*!
+	\brief				<09><><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD>
+	\param Session		<09><><EFBFBD><EFBFBD>
+	\param cCmd			Ŀ<>ǵ<EFBFBD>
+	\param nMessage 	<09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD> <20><>ȣ
+	\param wParam		WPARAM
+	\param lParam		LPARAM
+	\param dwRunID		RunID
+	\param usDataLen	<09><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	\param usFlags		<09>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>
+	\param lpData		<09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	\param cError		<09><><EFBFBD><EFBFBD> Ŀ<>ǵ<EFBFBD>
+	\return				<09><>Ŷ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+*/
+bool ServerManage::SendManagePacket(CSession& Session,						
+                                    unsigned char cCmd,						
+                                    unsigned int nMessage,					
+                                    WPARAM wParam,							
+                                    LPARAM lParam,							
+                                    unsigned long dwRunID,                  
+                                    unsigned short usDataLen,				
+                                    unsigned short usFlags,                 
+                                    const void* lpData,						
+                                    unsigned char cError)					
+{
+	CBuffer* lpBuffer = CREATE_BUFFER(Session.GetPolicy().GetBufferFactory(), 
+        (sizeof(ManageCommand) + usDataLen));
+
+	if(0 != lpBuffer)
+	{
+		ManageCommand* lpManageCommand = reinterpret_cast<ManageCommand*>(lpBuffer->wr_ptr());
+
+		lpManageCommand->nMessage			= nMessage;							// <20>޽<EFBFBD><DEBD><EFBFBD> <20><>ȣ
+		lpManageCommand->wParam				= wParam;							// <20>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>1
+		lpManageCommand->lParam				= lParam;							// <20>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>2
+
+		lpManageCommand->dwRunID            = dwRunID;						    // <20>޼<EFBFBD><DEBC><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> IP
+		lpManageCommand->usDataLen			= (0 != lpData) ? usDataLen : 0;	// <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+        lpManageCommand->usFlags			= usFlags;							// <20><>Ÿ Ŀ<>ǵ<EFBFBD> (<28><><EFBFBD>뿡 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٸ<EFBFBD>)
+				
+		if(0 != lpData)
+		{
+			memcpy(reinterpret_cast<char*>(lpManageCommand + 1), lpData, usDataLen);
+		}
+
+		if(PacketWrap::WrapCrypt(lpBuffer, sizeof(ManageCommand) + usDataLen, cCmd, 0, cError)
+			&& Session.SendPending(lpBuffer))
+		{
+			return true;
+		}
+
+		SAFE_RELEASE_BUFFER(lpBuffer);
+	}
+
+	return false;
+}
+
+/*!
+	\brief					<09><><EFBFBD><EFBFBD> <20><>Ŷ <20><><EFBFBD><EFBFBD>
+	\param bufferFactory	BufferFactory
+	\param lpTarget			<09><><EFBFBD><EFBFBD>. 0<≯<EFBFBD> Broadcast
+	\param lpUserInfo 		<09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>н<EFBFBD><D0BD><EFBFBD><EFBFBD>常 <20><><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
+	\param cUserInfoNum		<09><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	\param cCommand			Ŀ<>ǵ<EFBFBD>.
+	\param cError			<09><><EFBFBD><EFBFBD>.	
+	\return					<09><>Ŷ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+*/
+bool ServerManage::SendUserInfo(CBufferFactory& bufferFactory,			
+							 CSession* lpTarget,						
+							 const ServerManage::UserInfo* lpUserInfo,	
+							 unsigned char cUserInfoNum,				
+							 unsigned char cCommand,					
+							 unsigned char cError)						
+{
+	// <20>ٸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>鿡<EFBFBD><E9BFA1> <20>ڽ<EFBFBD><DABD><EFBFBD> <20>߰<EFBFBD><DFB0>Ǿ<EFBFBD><C7BE>ٴ<EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	CBuffer* lpBuffer = CREATE_BUFFER(bufferFactory,
+		sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum);
+
+	CBuffer* lpCompressedBuffer = CREATE_BUFFER(bufferFactory,
+		CMiniLZO::GetLeastCompressBuffer(sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum));
+
+	if(0 != lpBuffer && 0 != lpCompressedBuffer)
+	{
+		ServerManage::UserCommand* lpUserCommand	= reinterpret_cast<ServerManage::UserCommand*>(lpBuffer->wr_ptr());
+		ServerManage::UserInfo*	lpFirstUserInfo	= reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);	
+		ServerManage::UserInfo*	lpLastUserInfo	= lpFirstUserInfo + cUserInfoNum;
+
+		lpUserCommand->cUserInfoNum = cUserInfoNum;			
+		std::copy(lpUserInfo, lpUserInfo + cUserInfoNum, lpFirstUserInfo);
+
+		for(ServerManage::UserInfo* lpTempUserInfo = lpFirstUserInfo;
+			lpTempUserInfo != lpLastUserInfo; ++lpTempUserInfo)
+		{
+			memset(lpTempUserInfo->szPassword, 0, sizeof(ServerManage::UserInfo::PASS_LEN) * sizeof(TCHAR));
+		}
+
+		if(PacketWrap::WrapCompress(lpCompressedBuffer, lpBuffer->rd_ptr(), 
+			sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum,
+			cCommand, 0, cError))
+		{
+			if(lpTarget)
+			{
+				if(lpTarget->SendPending(lpCompressedBuffer))
+				{					
+					SAFE_RELEASE_BUFFER(lpBuffer);
+					return true;
+				}
+			}
+			else
+			{
+                CToolUserManager::GetInstance().SendToAllLoginUser(
+					lpCompressedBuffer->rd_ptr(), lpCompressedBuffer->length(), lpUserCommand->GetCmd());
+
+				SAFE_RELEASE_BUFFER(lpCompressedBuffer);
+				SAFE_RELEASE_BUFFER(lpBuffer);
+				return true;
+			}
+		}
+	}
+
+    SAFE_RELEASE_BUFFER(lpCompressedBuffer);
+	SAFE_RELEASE_BUFFER(lpBuffer);
+	return false;
+}
+
+bool ServerManage::CheckUserPacketLength(PktBase* lpPktBase, int nExpectUserInfoNum)
+{
+	PktBase::LengthType nLength = lpPktBase->GetLen();
+
+	if(nLength < sizeof(ServerManage::UserCommand))
+	{
+		return false;
+	}
+
+	ServerManage::UserCommand*  lpUserCommand   = reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
+	ServerManage::UserInfo*     lpUserInfo      = reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);
+
+	if(0 < nExpectUserInfoNum)
+	{
+		if(nExpectUserInfoNum != lpUserCommand->cUserInfoNum ||
+			nLength != sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * nExpectUserInfoNum)
+		{
+            ERRLOG2(g_Log, "Invalid packet size : userinfo num : %d, packet size : %d",
+				lpUserCommand->cUserInfoNum, nLength);
+
+			return false;
+		}
+	}
+	else if(nLength != sizeof(ServerManage::UserCommand))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+
+bool ServerManage::CheckManagePacketLength(PktBase* lpPktBase)
+{
+	unsigned short usPacketLength = lpPktBase->GetLen();
+
+	ServerManage::ManageCommand* lpManageCommand = 
+		reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);
+
+	if(usPacketLength < sizeof(ServerManage::ManageCommand) ||
+		(usPacketLength != lpManageCommand->usDataLen + sizeof(ServerManage::ManageCommand)))
+	{
+		ERRLOG2(g_Log, "Invalid packet size : DataLen : %d, Packet size : %d",
+			lpManageCommand->usDataLen, lpPktBase->GetLen());
+		return false;
+	}
+
+	return true;
+}
+
+
+ServerManage::CSendManagePacketToClient::CSendManagePacketToClient(ManageCommand& manageCommand,
+                                                                   const char* lpData)
+:	m_ManageCommand(manageCommand),
+	m_lpData(lpData)
+{
+
+}
+
+bool ServerManage::CSendManagePacketToClient::operator() (CPacketDispatch& dispatch)
+{
+	return SendManagePacket(dispatch.GetSession(), 
+		m_ManageCommand.GetCmd(), m_ManageCommand.nMessage, 
+		m_ManageCommand.wParam, m_ManageCommand.lParam,
+		m_ManageCommand.dwRunID, m_ManageCommand.usDataLen, m_ManageCommand.usFlags, 
+        m_lpData, static_cast<unsigned char>(m_ManageCommand.GetError()));
+}

Server/ManageTool/ManageLibrary/Network/Dispatch/SendManagePacket.h

@@ -0,0 +1,67 @@
+#ifndef _SEND_MANAGE_PACKET_H_
+#define _SEND_MANAGE_PACKET_H_
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <winsock2.h>
+#include <windows.h>
+
+
+// forward decl.
+struct PktBase;
+class CSession;
+class CBufferFactory;
+class CPacketDispatch;
+
+
+namespace ServerManage
+{
+	// forward decl.
+	struct ManageCommand;
+	struct UserInfo;
+
+	bool CheckManagePacketLength(PktBase* lpPktBase);
+	bool CheckUserPacketLength(PktBase* lpPktBase, int nExpectUserInfoNum = -1);
+
+    // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	bool SendManagePacket(
+		CSession& Session,						// <20><><EFBFBD><EFBFBD>
+		unsigned char cCmd,						// Ŀ<>ǵ<EFBFBD>
+		unsigned int nMessage,					// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>޽<EFBFBD><DEBD><EFBFBD> <20><>ȣ
+		WPARAM wParam,							// WPARAM
+		LPARAM lParam,							// LPARAM
+		unsigned long dwRunID,                  // RunID
+        unsigned short usDataLen,				// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+        unsigned short usFlags,                 // <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>
+		const void* lpData,						// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>		
+		unsigned char cError);					// <20><><EFBFBD><EFBFBD> Ŀ<>ǵ<EFBFBD>
+
+    // <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>Ŷ<EFBFBD><C5B6> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
+	bool SendUserInfo(
+		CBufferFactory& bufferFactory,				// BufferFactory
+		CSession* lpTarget,							// <20><><EFBFBD><EFBFBD>. 0<≯<EFBFBD> Broadcast
+		const ServerManage::UserInfo* lpUserInfo,	// <EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <EFBFBD>н<EFBFBD><EFBFBD><EFBFBD><EFBFBD>常 <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϰ<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
+		unsigned char cUserInfoNum,					// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+		unsigned char cCommand,						// Ŀ<>ǵ<EFBFBD>.
+		unsigned char cError);						// <20><><EFBFBD><EFBFBD>.	
+
+	class CSendManagePacketToClient
+	{
+	public:
+
+		CSendManagePacketToClient(ManageCommand& manageCommand, const char* lpData);
+				
+		bool operator() (CPacketDispatch& dispatch);		
+		bool operator() (unsigned long dwKeyType, CPacketDispatch& dispatch) 
+        { return operator() (dispatch); }
+
+	private:
+
+		ManageCommand&	m_ManageCommand;		
+		const char*		m_lpData;
+	};
+};
+
+#endif

Server/ManageTool/ManageLibrary/ReadMe.txt

@@ -0,0 +1,29 @@
+========================================================================
+    <20><><EFBFBD><EFBFBD> <20><><EFBFBD>̺귯<CCBA><EAB7AF> : ServerManagerary <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD>
+========================================================================
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><> ServerManagerary <20><><EFBFBD>̺귯<CCBA><EAB7AF> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD>. 
+<EFBFBD><EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD><CFBF><EFBFBD> ServerManagerary <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ͽ<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ԵǾ<D4B5> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
+
+
+ServerManagerary.vcproj
+    <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>縦 <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> VC++ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ<EFBFBD><C6AE> <20>⺻ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>. 
+    <20>ش<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Visual C++<2B><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ͽ<EFBFBD> 
+    <20><><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>÷<EFBFBD><C3B7><EFBFBD>, <20><><EFBFBD><EFBFBD> <20><> 
+    <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD>ɿ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ֽ<EFBFBD><D6BD>ϴ<EFBFBD>.
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+StdAfx.h <20><> StdAfx.cpp<70><70>
+    ServerManagerary.pch<63><68><EFBFBD><EFBFBD> <20≯<EFBFBD><CCB8><EFBFBD> PCH(<28≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD>) <20><><EFBFBD>ϰ<EFBFBD>
+    StdAfx.obj<62><6A><EFBFBD><EFBFBD> <20≯<EFBFBD><CCB8><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>˴ϴ<CBB4>.
+
+/////////////////////////////////////////////////////////////////////////////
+<EFBFBD><EFBFBD>Ÿ <20><><EFBFBD><EFBFBD>:
+
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>α׷<CEB1> <20><><EFBFBD><EFBFBD><EFBFBD>翡<EFBFBD><E7BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD> "TODO:" <20>ּ<EFBFBD><D6BC><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڰ<EFBFBD> <20>߰<EFBFBD><DFB0>ϰų<CFB0> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD> <20>ϴ<EFBFBD>
+<EFBFBD>ҽ<EFBFBD> <20>ڵ<EFBFBD> <20>κ<EFBFBD><CEBA><EFBFBD> <20><>Ÿ<EFBFBD><C5B8><EFBFBD>ϴ<EFBFBD>.
+
+/////////////////////////////////////////////////////////////////////////////

Server/ManageTool/ManageLibrary/ServerManage/ManageClientManager.cpp

@@ -0,0 +1,537 @@
+#include "stdafx.h"
+#include "ManageClientManager.h"
+
+#include <DB/SQLite.h>
+#include <DB/ManageServerDB.h>
+#include <Log/ServerLog.h>
+
+
+CManageClientManager& CManageClientManager::GetInstance()
+{
+	static CManageClientManager manageClientManager(CManageServerDB::GetInstance());
+	return manageClientManager;
+}
+
+
+CManageClientManager::CManageClientManager(CManageServerDB& manageServerDB)
+:	m_ManageServerDB(manageServerDB)
+{
+    ReloadRunInfo();
+}
+
+CManageClientManager::~CManageClientManager()
+{
+
+
+}
+
+// ----------------------------------------------------------------------------------------------
+// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+bool CManageClientManager::Add(InfoType eInfoType, 
+							   const ServerManage::RunInfo& runInfo, 
+							   unsigned long& dwID_Out)
+{	
+	const int MAX_QUERY_LEN = 512;
+	char szQuery[MAX_QUERY_LEN];
+	int nQueryLen = -1;
+
+	switch(eInfoType)
+	{
+	case SERVER_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"INSERT INTO TblServerInfo values(%d, '%s')",
+			runInfo.m_dwServerIP, runInfo.m_szServerName);
+		break;
+
+	case RUN_PATH_INFO:
+		
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"INSERT INTO TblRunPath values(NULL, '%s')", runInfo.m_szPath);
+		break;
+
+	case OPTION_INFO:
+
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"INSERT INTO TblRunOptions values(NULL, '%s')", runInfo.m_szOption);
+		break;
+
+    case RUN_INFO:
+
+        nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1,
+            "INSERT INTO TblRunInfo values(NULL, %d, %d, %d)",
+            runInfo.m_dwPathID, runInfo.m_dwOptionID, runInfo.m_dwServerIP);
+        break;
+
+	default:
+
+		ERRLOG1(g_Log, "Unknown InfoType : %d", eInfoType);
+		return false;
+	};
+
+	szQuery[MAX_QUERY_LEN - 1] = 0;
+	if(nQueryLen <= 0)
+	{
+		ERRLOG1(g_Log, "Make query failed : %s", szQuery);
+		return false;
+	}
+
+	CSQLite::Dataset executeQuery(m_ManageServerDB.GetSQLite(), szQuery);
+	if(!executeQuery.Compile() || !executeQuery.Execute())
+	{
+		if(0 != executeQuery.GetLastError())
+		{
+            ERRLOG2(g_Log, "Add failed : error : %s(Query:%s)", 
+				executeQuery.GetLastError(), szQuery);
+		}
+
+		return false;
+	}
+
+	dwID_Out = m_ManageServerDB.GetSQLite().GetLastInsertRowID();
+	return ReloadRunInfo();
+}
+
+bool CManageClientManager::Modify(InfoType eInfoType, const ServerManage::RunInfo& runInfo)
+{
+	const int MAX_QUERY_LEN = 512;
+	char szQuery[MAX_QUERY_LEN];
+	int nQueryLen = -1;
+
+	switch(eInfoType)
+	{
+	case SERVER_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"UPDATE TblServerInfo SET ServerName = '%s' WHERE IP = %d",
+			runInfo.m_szServerName, runInfo.m_dwServerIP);
+		break;
+
+	case RUN_PATH_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"UPDATE TblRunPath SET RunPath = '%s' WHERE PathID = %d", 
+			runInfo.m_szPath, runInfo.m_dwPathID);
+		break;
+
+	case OPTION_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"UPDATE TblRunOptions SET RunOption = '%s' WHERE OptionID = %d",
+			runInfo.m_szOption, runInfo.m_dwOptionID);
+		break;
+
+    case RUN_INFO:
+
+        nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1,
+            "UPDATE TblRunInfo SET PathID = %d, OptionID = %d, ServerIP = %d WHERE RunID = %d",
+            runInfo.m_dwPathID, runInfo.m_dwOptionID, runInfo.m_dwServerIP, runInfo.m_dwRunID);
+        break;
+
+	default:
+		ERRLOG1(g_Log, "Unknown InfoType : %d", eInfoType);
+		return false;
+	};
+
+	szQuery[MAX_QUERY_LEN - 1] = 0;
+	if(nQueryLen <= 0)
+	{
+		ERRLOG1(g_Log, "Make query failed : %s", szQuery);
+		return false;
+	}
+
+	CSQLite::Dataset executeQuery(m_ManageServerDB.GetSQLite(), szQuery);
+	if(!executeQuery.Compile() || !executeQuery.Execute())
+	{
+		if(0 != executeQuery.GetLastError())
+		{
+            ERRLOG2(g_Log, "Modify failed : error : %s(Query:%s)", 
+				executeQuery.GetLastError(), szQuery);
+		}
+
+		return false;
+	}
+
+	return ReloadRunInfo();
+}
+
+bool CManageClientManager::Remove(InfoType eInfoType, unsigned long dwID, bool bDeleteRelated)
+{
+	const int MAX_QUERY_LEN = 512;
+	char szQuery[MAX_QUERY_LEN];
+	char szDeleteRelated[MAX_QUERY_LEN];
+
+	const char* szRelatedKey = 0;
+	
+	int nQueryLen = -1;
+
+	switch(eInfoType)
+	{
+	case SERVER_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 
+			"DELETE FROM TblServerInfo WHERE IP = %d", dwID);
+		szRelatedKey = "ServerIP";
+		break;
+
+	case RUN_PATH_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 			
+			"DELETE FROM TblRunPath WHERE PathID = %d;", dwID);
+		szRelatedKey = "PathID";
+		break;
+
+	case OPTION_INFO:
+		nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1, 			
+			"DELETE FROM TblRunOptions WHERE OptionID = %d;", dwID);
+		szRelatedKey = "OptionID";
+		break;
+
+    case RUN_INFO:
+
+        nQueryLen = _snprintf(szQuery, MAX_QUERY_LEN - 1,
+            "DELETE FROM TblRunInfo WHERE RunID = %d", dwID);
+        break;
+
+	default:
+
+		ERRLOG1(g_Log, "Unknown InfoType : %d", eInfoType);
+		return false;
+	};
+
+	szQuery[MAX_QUERY_LEN - 1] = 0;
+	if(nQueryLen <= 0)
+	{
+		ERRLOG1(g_Log, "Make query failed : %s", szQuery);
+		return false;
+	}
+	else
+	{
+       	CSQLite::Dataset executeQuery(m_ManageServerDB.GetSQLite(), szQuery);
+		if(!executeQuery.Compile() || !executeQuery.Execute())
+		{
+			if(0 != executeQuery.GetLastError())
+			{
+				ERRLOG2(g_Log, "Delete failed : error : %s(Query:%s)", 
+					executeQuery.GetLastError(), szQuery);
+			}
+
+			return false;
+		}
+
+		if(bDeleteRelated && 0 != szRelatedKey)
+		{
+			nQueryLen = _snprintf(szDeleteRelated, MAX_QUERY_LEN - 1, 
+				"DELETE FROM TblRunInfo WHERE %s = %d;", szRelatedKey, dwID);
+
+			if(nQueryLen <= 0)
+			{
+				ERRLOG1(g_Log, "Make query failed : %s", szDeleteRelated);
+				return false;
+			}
+
+       		CSQLite::Dataset deleteRelatedQuery(m_ManageServerDB.GetSQLite(), szDeleteRelated);
+			if(!deleteRelatedQuery.Compile() || !deleteRelatedQuery.Execute())
+			{
+				if(0 != deleteRelatedQuery.GetLastError())
+				{
+					ERRLOG2(g_Log, "Delete related failed : error : %s(Query:%s)", 
+						deleteRelatedQuery.GetLastError(), szDeleteRelated);
+				}
+
+				return false;
+			}
+		}
+	}
+
+	return ReloadRunInfo();
+}
+
+
+
+
+
+
+
+
+int GetServerInfoCallback(void *callBackArg, int nColumnNum, 
+						  char **szColumnValues, char **szColumnNames)
+{
+	if(2 == nColumnNum)
+	{
+		CManageClientManager::RunTable& runTable = 
+			*reinterpret_cast<CManageClientManager::RunTable*>(callBackArg);
+
+		ServerManage::RunInfo runInfo;
+		memset(&runInfo, 0, sizeof(ServerManage::RunInfo));
+
+		runInfo.m_dwServerIP = atol(szColumnValues[0]);
+		_snprintf(runInfo.m_szServerName, ServerManage::RunInfo::MAX_SERVER_NAME - 1, 
+			"%s", szColumnValues[1]);
+
+		runInfo.m_szServerName[ServerManage::RunInfo::MAX_SERVER_NAME - 1] = 0;
+
+		if(!runTable.insert(CManageClientManager::RunTable::value_type(
+			runInfo.m_dwServerIP, runInfo)).second)
+		{
+			ERRLOG1(g_Log, "Insert failed. Key : %d", runInfo.m_dwServerIP);
+		}
+	}
+		
+	return 0;
+}
+
+int GetPathInfoCallback(void *callBackArg, int nColumnNum, 
+						char **szColumnValues, char **szColumnNames)
+{
+	if(2 == nColumnNum)
+	{
+		CManageClientManager::RunTable& runTable = 
+			*reinterpret_cast<CManageClientManager::RunTable*>(callBackArg);
+
+		ServerManage::RunInfo runInfo;
+		memset(&runInfo, 0, sizeof(ServerManage::RunInfo));
+
+		runInfo.m_dwPathID = atol(szColumnValues[0]);
+
+		_snprintf(runInfo.m_szPath, ServerManage::RunInfo::MAX_PATH_LEN - 1, 
+			"%s", szColumnValues[1]);
+
+		runInfo.m_szPath[ServerManage::RunInfo::MAX_PATH_LEN - 1] = 0;
+
+		if(!runTable.insert(CManageClientManager::RunTable::value_type(
+			runInfo.m_dwPathID, runInfo)).second)
+		{
+			ERRLOG1(g_Log, "Insert failed. Key : %d", runInfo.m_dwPathID);
+		}
+	}	
+	
+	return 0;
+}
+
+int GetOptionInfoCallback(void *callBackArg, int nColumnNum, 
+						  char **szColumnValues, char **szColumnNames)
+{
+	if(2 == nColumnNum)
+	{
+		CManageClientManager::RunTable& runTable = 
+			*reinterpret_cast<CManageClientManager::RunTable*>(callBackArg);
+
+		ServerManage::RunInfo runInfo;
+		memset(&runInfo, 0, sizeof(ServerManage::RunInfo));
+
+		runInfo.m_dwOptionID = atol(szColumnValues[0]);
+
+		_snprintf(runInfo.m_szOption, ServerManage::RunInfo::MAX_OPT_LEN - 1, 
+			"%s", szColumnValues[1]);
+		
+		runInfo.m_szOption[ServerManage::RunInfo::MAX_OPT_LEN - 1] = 0;
+
+		if(!runTable.insert(CManageClientManager::RunTable::value_type(
+			runInfo.m_dwOptionID, runInfo)).second)
+		{
+			ERRLOG1(g_Log, "Insert failed. Key : %d", runInfo.m_dwOptionID);
+		}
+	}	
+	
+	return 0;
+}
+
+int GetRunInfoCallback(void *callBackArg, int nColumnNum, 
+                       char **szColumnValues, char **szColumnNames)
+{
+	if(4 == nColumnNum)
+	{
+		CManageClientManager::RunTable& runTable = 
+			*reinterpret_cast<CManageClientManager::RunTable*>(callBackArg);
+
+		ServerManage::RunInfo runInfo;
+		memset(&runInfo, 0, sizeof(ServerManage::RunInfo));
+
+        runInfo.m_dwRunID       = atol(szColumnValues[0]);
+        runInfo.m_dwPathID      = atol(szColumnValues[1]);
+        runInfo.m_dwOptionID    = atol(szColumnValues[2]);
+        runInfo.m_dwServerIP    = atol(szColumnValues[3]);
+
+		if(!runTable.insert(CManageClientManager::RunTable::value_type(
+			runInfo.m_dwRunID, runInfo)).second)
+		{
+			ERRLOG1(g_Log, "Insert failed. Key : %d", runInfo.m_dwOptionID);
+		}
+	}	
+	
+	return 0;
+}
+
+
+bool CManageClientManager::Get(InfoType eInfoType, RunTable& runTable)
+{
+	runTable.clear();
+
+	const char* szQuery = 0;
+	CSQLite::QueryCallBack lpQueryCallBack = 0;
+
+	switch(eInfoType)
+	{
+	case SERVER_INFO:	
+		szQuery = "SELECT IP, ServerName FROM TblServerInfo";
+		lpQueryCallBack = GetServerInfoCallback; 
+		break;
+
+	case RUN_PATH_INFO:	
+        szQuery = "SELECT PathID, RunPath FROM TblRunPath";
+		lpQueryCallBack = GetPathInfoCallback;
+		break;
+
+	case OPTION_INFO:	
+        szQuery = "SELECT OptionID, RunOption FROM TblRunOptions";
+		lpQueryCallBack = GetOptionInfoCallback;
+		break;
+
+    case RUN_INFO:
+        szQuery = "SELECT RunID, PathID, OptionID, ServerIP FROM TblRunInfo";
+        lpQueryCallBack = GetRunInfoCallback;
+        break;
+
+	default:
+		ERRLOG1(g_Log, "Unknown InfoType : %d", eInfoType);
+		return false;
+	};
+
+	if(!m_ManageServerDB.GetSQLite().ExecuteQuery(szQuery, lpQueryCallBack, &runTable))
+	{
+		const char* szError = m_ManageServerDB.GetSQLite().GetLastError();
+		if(0 != szError)
+		{
+			ERRLOG2(g_Log, "Query failed : refresh runinfo failed : %s(Query:%s)", 
+				szError, szQuery);
+		}
+
+		return false;
+	}
+
+	return true;
+}
+
+
+
+// ----------------------------------------------------------------------------------------------
+// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+bool CManageClientManager::GetRunInfo(ServerManage::RunInfo* lpRunInfo_Out, size_t* nArrayNum_InOut)
+{
+	size_t nRunTableSize = m_RunTable.size();
+
+	if(0 != lpRunInfo_Out && 0 != nArrayNum_InOut && nRunTableSize <= *nArrayNum_InOut)
+	{
+		RunTable::iterator pos = m_RunTable.begin();
+		RunTable::iterator end = m_RunTable.end();
+
+		for(; pos != end; ++pos, ++lpRunInfo_Out)
+		{
+			*lpRunInfo_Out = pos->second;
+		}		
+
+		*nArrayNum_InOut = nRunTableSize;
+		return true;
+	}
+
+	return false;
+}
+	
+bool CManageClientManager::GetRunInfo(unsigned long dwRunID, ServerManage::RunInfo& runInfo_Out)
+{
+	RunTable::iterator pos = m_RunTable.find(dwRunID);
+	if(pos != m_RunTable.end())
+	{
+		runInfo_Out = pos->second;
+		return true;
+	}
+
+	return false;
+}
+
+bool CManageClientManager::HasRunInfo(unsigned long dwRunID)
+{
+	return m_RunTable.find(dwRunID) != m_RunTable.end();
+}
+
+void CManageClientManager::GetRunInfoFromIP(unsigned long dwServerIP, RunTable& runTable)
+{
+    RunTable::iterator pos = m_RunTable.begin();
+    RunTable::iterator end = m_RunTable.end();
+
+    for(; pos != end; ++pos)
+    {
+        RunTable::value_type& data = *pos;
+
+        if(data.second.m_dwServerIP == dwServerIP)
+        {
+            runTable.insert(data);
+        }
+    }
+}
+
+
+
+int ReloadRunInfoCallback(void *callBackArg, int nColumnNum, char **szColumnValues, char **szColumnNames)
+{
+	CManageClientManager::RunTable& runTable = 
+		*reinterpret_cast<CManageClientManager::RunTable*>(callBackArg);
+	
+	if(7 == nColumnNum)
+	{
+		ServerManage::RunInfo runInfo;
+		memset(&runInfo, 0, sizeof(ServerManage::RunInfo));
+
+		runInfo.m_dwRunID		= atol(szColumnValues[0]);
+		runInfo.m_dwServerIP	= atol(szColumnValues[1]);
+		runInfo.m_dwPathID		= atol(szColumnValues[2]);
+		runInfo.m_dwOptionID	= atol(szColumnValues[3]);
+
+		_snprintf(runInfo.m_szServerName, ServerManage::RunInfo::MAX_SERVER_NAME - 1, 
+			"%s", szColumnValues[4]);
+
+		runInfo.m_szServerName[ServerManage::RunInfo::MAX_SERVER_NAME - 1] = 0;
+
+		_snprintf(runInfo.m_szPath, ServerManage::RunInfo::MAX_PATH_LEN - 1, 
+			"%s", szColumnValues[5]);
+
+		runInfo.m_szPath[ServerManage::RunInfo::MAX_PATH_LEN - 1] = 0;
+
+		_snprintf(runInfo.m_szOption, ServerManage::RunInfo::MAX_OPT_LEN - 1, 
+			"%s", szColumnValues[6]);
+		
+		runInfo.m_szOption[ServerManage::RunInfo::MAX_OPT_LEN - 1] = 0;
+	
+		if(!runTable.insert(CManageClientManager::RunTable::value_type(
+			atol(szColumnValues[0]), runInfo)).second)
+		{
+			ERRLOG0(g_Log, "Reload failed");
+		}
+	}
+
+	return 0;
+}
+
+
+bool CManageClientManager::ReloadRunInfo()
+{
+	m_RunTable.clear();
+
+	const char* szQuery = "SELECT TblRunInfo.RunID, TblRunInfo.ServerIP, TblRunInfo.PathID, "
+        "TblRunInfo.OptionID, TblServerInfo.ServerName, TblRunPath.RunPath, TblRunOptions.RunOption "
+		"FROM TblRunInfo "
+        "LEFT OUTER JOIN TblRunPath    ON TblRunInfo.PathID   = TblRunPath.PathID "
+		"LEFT OUTER JOIN TblRunOptions ON TblRunInfo.OptionID = TblRunOptions.OptionID "
+		"LEFT OUTER JOIN TblServerInfo ON TblRunInfo.ServerIP = TblServerInfo.IP ";
+
+	if(!m_ManageServerDB.GetSQLite().ExecuteQuery(szQuery, ReloadRunInfoCallback, &m_RunTable))
+	{
+		const char* szError = m_ManageServerDB.GetSQLite().GetLastError();
+		if(0 != szError)
+		{
+			ERRLOG2(g_Log, "Query failed : refresh runinfo failed : %s(Query:%s)", 
+				szError, szQuery);
+		}
+
+		return false;
+	}
+
+	return true;
+}
+
+

Server/ManageTool/ManageLibrary/ServerManage/ManageClientManager.h

@@ -0,0 +1,84 @@
+#ifndef _CUSTOM_MANAGE_CLIENT_MANAGER_H_
+#define _CUSTOM_MANAGE_CLIENT_MANAGER_H_
+
+#pragma warning(disable:4800)
+
+#include <winsock2.h>
+#include <windows.h>
+#include <map>
+#include <boost/pool/pool_alloc.hpp>
+#include <Network/Packet/ManagePacketCmd.h>
+
+// forward decl.
+class CSession;
+class CManageServerDB;
+
+class CManageClientManager
+{
+public:
+
+	typedef std::map<unsigned long, ServerManage::RunInfo, std::less<unsigned long>, 
+		boost::pool_allocator<std::pair<unsigned long, ServerManage::RunInfo> > > RunTable;
+
+    enum
+    {
+        MAX_RUNID = 0xFFFFFFFF
+    };
+
+	enum InfoType
+	{
+		SERVER_INFO,
+        RUN_PATH_INFO,
+		OPTION_INFO,
+
+        RUN_INFO
+	};
+
+	static CManageClientManager& GetInstance();
+
+    static bool SendRunInfo(CSession& Session, const RunTable& runTable);
+
+	// ----------------------------------------------------------------------------------------------
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	bool Add(InfoType eInfoType, const ServerManage::RunInfo& runInfo, unsigned long& dwID_Out);
+	bool Modify(InfoType eInfoType, const ServerManage::RunInfo& runInfo);
+	bool Remove(InfoType eInfoType, unsigned long dwID, bool bDeleteRelated);
+	bool Get(InfoType eInfoType, RunTable& runTable);
+
+	// ----------------------------------------------------------------------------------------------
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+	bool GetRunInfo(ServerManage::RunInfo* lpRunInfo_Out, size_t* nArrayNum_InOut);
+    bool GetRunInfo(unsigned long dwRunID, ServerManage::RunInfo& runInfo_Out);
+
+	bool HasRunInfo(unsigned long dwRunID);
+
+    void GetRunInfoFromIP(unsigned long dwServerIP, RunTable& runTable);
+    const RunTable& GetRunInfoTable() const { return m_RunTable; }
+	    
+	size_t GetRunInfoNum() { return m_RunTable.size(); }
+
+	template<typename FnProcess>
+		void EnumRunInfo(FnProcess fnProcess)
+	{
+		RunTable::const_iterator pos = m_RunTable.begin();
+		RunTable::const_iterator end = m_RunTable.end();
+
+		for(;pos != end; ++pos)
+		{
+			fnProcess(pos->second);
+		}
+	}
+
+	bool ReloadRunInfo();
+
+private:
+    
+	CManageClientManager(CManageServerDB& manageServerDB);
+	~CManageClientManager();
+
+	CManageServerDB&	m_ManageServerDB;
+	RunTable			m_RunTable;
+};
+
+
+#endif

Server/ManageTool/ManageLibrary/ServerManage/SendManageInfo.cpp

@@ -0,0 +1,69 @@
+#include "stdafx.h"
+#include "ManageClientManager.h"
+
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/SendManagePacket.h>
+
+#include <Log/ServerLog.h>
+
+bool CManageClientManager::SendRunInfo(CSession& Session, const RunTable& runTable)
+{
+    if(!runTable.empty())
+    {
+        CManageClientManager::RunTable::const_iterator pos = runTable.begin();
+        CManageClientManager::RunTable::const_iterator end = runTable.end();
+
+        const int MAX_RUN_INFO = (PktMaxLen - sizeof(ServerManage::ManageCommand)) / sizeof(ServerManage::RunInfo);
+        ServerManage::RunInfo tempRunInfo[MAX_RUN_INFO];
+
+        if(!ServerManage::SendManagePacket(Session, ServerManage::CMD::UpdateRunList,
+            0, 0, 0, 0, 0, ServerManage::SEND_RUNINFO_START, 0, 0))
+        {
+            ERRLOG1(g_Log, "SS:0x%p/UpdateRunList : SendRunInfoStart packet failed", &Session);
+            return false;
+        }
+
+        int nRunInfo = 0;
+
+        for(;pos != end; ++pos)
+        {
+            tempRunInfo[nRunInfo] = pos->second;
+
+            ++nRunInfo;
+
+            if(nRunInfo == MAX_RUN_INFO)
+            {
+                if(!ServerManage::SendManagePacket(Session, 
+                    ServerManage::CMD::UpdateRunList,
+                    0, 0, 0, 0, nRunInfo * sizeof(ServerManage::RunInfo), 
+                    ServerManage::SEND_RUNINFO_NOW, tempRunInfo, 0))
+                {
+                    ERRLOG1(g_Log, "SS:0x%p/UpdateRunList : SendRunInfoNow packet failed", &Session);
+                    return false;
+                }
+
+                nRunInfo = 0;
+            }
+        }
+
+        if(0 < nRunInfo)
+        {
+            if(!ServerManage::SendManagePacket(Session, ServerManage::CMD::UpdateRunList,
+                0, 0, 0, 0, nRunInfo * sizeof(ServerManage::RunInfo), 
+                ServerManage::SEND_RUNINFO_NOW, tempRunInfo, 0))
+            {
+                ERRLOG1(g_Log, "SS:0x%p/UpdateRunList : SendRunInfoNow packet failed", &Session);
+                return false;
+            }
+        }
+
+        if(!ServerManage::SendManagePacket(Session, ServerManage::CMD::UpdateRunList,
+            0, 0, 0, 0, 0, ServerManage::SEND_RUNINFO_FINISH, 0, 0))
+        {
+            ERRLOG1(g_Log, "SS:0x%p/UpdateRunList : SendRunInfoFinish packet failed", &Session);
+            return false;
+        }
+    }
+
+    return true;
+}

Server/ManageTool/ManageLibrary/Setup/RylServerBindRunID.cpp

@@ -0,0 +1,219 @@
+#include "stdafx.h"
+#include "RylServerBindRunID.h"
+#include <Log/ServerLog.h>
+
+#include <ServerManage/ManageClientManager.h>
+
+
+CRylServerBindRunID& CRylServerBindRunID::GetInstance()
+{
+    static CRylServerBindRunID bindRunID;
+    return bindRunID;
+}
+
+
+CRylServerBindRunID::CRylServerBindRunID()
+{
+    _sntprintf(m_szDefaultSetupFileName, MAX_PATH - 1, "%s", 
+        _T("./RylSetupBindServerID.ini"));
+
+    m_szDefaultSetupFileName[MAX_PATH - 1] = 0;
+
+    Load();
+}
+
+CRylServerBindRunID::~CRylServerBindRunID()
+{
+
+
+}
+
+bool CRylServerBindRunID::SetID(unsigned long dwRunID, unsigned long dwServerID)
+{
+    std::pair<BindIDTable::iterator, bool> runIDpair = 
+        m_RunID.insert(BindIDTable::value_type(dwRunID, dwServerID));
+
+    if(runIDpair.second)
+    {
+        std::pair<BindIDTable::iterator, bool> serverIDPair = 
+            m_ServerID.insert(BindIDTable::value_type(dwServerID, dwRunID));
+
+        if(serverIDPair.second)
+        {
+            return true;
+        }
+
+        m_RunID.erase(runIDpair.first);
+    }
+
+    return false;
+}
+
+
+bool CRylServerBindRunID::RemoveFromRunID(unsigned long dwRunID)
+{
+    BindIDTable::iterator pos_runID = m_RunID.find(dwRunID);
+
+    if(pos_runID != m_RunID.end())
+    {
+        unsigned long dwServerID = pos_runID->second;
+
+        BindIDTable::iterator pos_serverID = m_ServerID.find(dwServerID);
+
+        if(pos_serverID != m_ServerID.end())
+        {
+            m_RunID.erase(pos_runID);
+            m_ServerID.erase(pos_serverID);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool CRylServerBindRunID::RemoveFromServerID(unsigned long dwServerID)
+{
+    BindIDTable::iterator pos_serverID = m_ServerID.find(dwServerID);
+
+    if(pos_serverID != m_ServerID.end())    
+    {
+        unsigned long dwRunID = pos_serverID->second;
+
+        BindIDTable::iterator pos_runID = m_RunID.find(dwRunID);
+        
+        if(pos_runID != m_RunID.end())
+        {
+            m_RunID.erase(pos_runID);
+            m_ServerID.erase(pos_serverID);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+bool CRylServerBindRunID::GetRunID(unsigned long dwServerID, unsigned long* lpdwRunID)
+{
+    BindIDTable::iterator pos = m_ServerID.find(dwServerID);
+
+    if(0 != lpdwRunID && pos != m_ServerID.end())
+    {
+        *lpdwRunID = pos->second;
+        return true;
+    }
+
+    return false;
+}
+
+bool CRylServerBindRunID::GetServerID(unsigned long dwRunID, unsigned long* lpdwServerID)
+{
+    BindIDTable::iterator pos = m_RunID.find(dwRunID);
+
+    if(0 != lpdwServerID && pos != m_RunID.end())
+    {
+        *lpdwServerID = pos->second;
+        return true;
+    }
+
+    return false;
+}
+
+void CRylServerBindRunID::SetSetupFileName(const TCHAR* szSetupFileName)
+{
+    if(0 != szSetupFileName)
+    {
+        _sntprintf(m_szDefaultSetupFileName, MAX_PATH - 1, "%s", szSetupFileName);
+        m_szDefaultSetupFileName[MAX_PATH - 1] = 0;
+    }
+}
+
+
+bool CRylServerBindRunID::Load()
+{
+    HANDLE hFile = CreateFile(m_szDefaultSetupFileName, 
+        GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+    
+    unsigned long dwWritten = 0;
+    bool bResult = false;
+
+    if(INVALID_HANDLE_VALUE != hFile)
+    {
+        size_t nBindIDNum = 0;
+
+        m_RunID.clear();
+        m_ServerID.clear();
+
+        if(ReadFile(hFile, &nBindIDNum, sizeof(size_t), &dwWritten, 0))
+        {
+            BindID bindID;
+
+            for(size_t nCount = 0; nCount < nBindIDNum; ++nCount)
+            {
+                if(ReadFile(hFile, &bindID, sizeof(BindID), &dwWritten, 0))
+                {
+					m_RunID.insert(bindID);                    
+					std::swap(bindID.first, bindID.second);
+					m_ServerID.insert(bindID);
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            if(nCount == nBindIDNum)
+            {
+                bResult = true;
+            }
+        }
+
+        CloseHandle(hFile);
+    };
+
+    return bResult;
+}
+
+
+bool CRylServerBindRunID::Save()
+{
+    HANDLE hFile = CreateFile(m_szDefaultSetupFileName, 
+        GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+    
+    unsigned long dwWritten = 0;
+    bool bResult = false;
+
+    if(INVALID_HANDLE_VALUE != hFile)
+    {
+        size_t nBindIDNum = m_RunID.size();
+
+        if(WriteFile(hFile, &nBindIDNum, sizeof(size_t), &dwWritten, 0))
+        {
+            BindIDTable::iterator pos = m_RunID.begin();
+            BindIDTable::iterator end = m_RunID.end();
+
+            BindID bindID;
+
+            for(; pos != end; ++pos)
+            {
+                bindID = *pos;
+
+                if(!WriteFile(hFile, &bindID, sizeof(BindID), &dwWritten, 0))
+                {
+                    break;
+                }
+            }
+
+            if(pos == end)
+            {
+                bResult = true;
+            }
+        }
+
+        CloseHandle(hFile);
+    };
+
+    return bResult;
+}

Server/ManageTool/ManageLibrary/Setup/RylServerBindRunID.h

@@ -0,0 +1,61 @@
+#ifndef _RYL_SERVER_BIND_RUN_ID_
+#define _RYL_SERVER_BIND_RUN_ID_
+
+#pragma warning(disable:4800)
+
+#include <map>
+#include <new>
+#include <boost/pool/pool_alloc.hpp>
+
+#include <tchar.h>
+
+class CRylServerBindRunID
+{
+public:
+
+    static CRylServerBindRunID& GetInstance();
+
+    bool SetID(unsigned long dwRunID, unsigned long dwServerID);
+    bool RemoveFromRunID(unsigned long dwRunID);
+    bool RemoveFromServerID(unsigned long dwServerID);
+
+    bool GetRunID(unsigned long dwServerID, unsigned long* lpdwRunID);
+    bool GetServerID(unsigned long dwRunID, unsigned long* lpdwServerID);
+
+    void SetSetupFileName(const TCHAR* szSetupFileName);
+
+    bool Save();
+    bool Load();
+
+    template<typename FnProcess>
+        void EnumID(FnProcess fnProcess)
+    {
+        BindIDTable::iterator pos = m_RunID.begin();
+        BindIDTable::iterator end = m_RunID.end();
+
+        for(; pos != end; ++pos)
+        {
+            // first : RunID, Second : ServerID
+            fnProcess(pos->first, pos->second);
+        }
+    }
+
+    size_t GetPairNum() const { return m_RunID.size(); }
+
+private:
+
+    typedef std::pair<unsigned long, unsigned long> BindID;
+
+    typedef std::map<unsigned long, unsigned long, std::less<unsigned long>,
+        boost::fast_pool_allocator<std::pair<unsigned long, unsigned long> > > BindIDTable;
+
+    CRylServerBindRunID();
+    ~CRylServerBindRunID();
+    
+    BindIDTable  m_RunID;     // key : RunID,     value : ServerID
+    BindIDTable  m_ServerID;  // key : ServerID,  value : RunID
+
+    TCHAR   m_szDefaultSetupFileName[MAX_PATH];
+};
+
+#endif

Server/ManageTool/ManageLibrary/Setup/RylServerGroupSetup.cpp

@@ -0,0 +1,156 @@
+#include "stdafx.h"
+#include "RylServerGroupSetup.h"
+
+
+// forward decl.
+void ReadRylServerStringValues(CRylServerGroupSetup::ServerStringMap& serverStringMap,
+                               const char* szReadSection, const char* szKey, const char* szFileName);
+
+void WriteRylServerStringValues(CRylServerGroupSetup::ServerStringMap& serverStringMap,
+                                const char* szReadSection, const char* szKey, const char* szFileName);
+
+CRylServerGroupSetup& CRylServerGroupSetup::GetInstance()
+{
+    static CRylServerGroupSetup rylServerGroupSetup;
+    return rylServerGroupSetup;
+}
+
+
+CRylServerGroupSetup::CRylServerGroupSetup()
+{
+    SetSetupFileName("./RylSetupServerGroup.ini");
+    Load();
+}
+
+CRylServerGroupSetup::~CRylServerGroupSetup()
+{
+
+}
+
+const char* CRylServerGroupSetup::GetSetupString(SetupType eSetupType, unsigned long dwKey)
+{
+    ServerStringMap::iterator pos;
+    ServerStringMap::iterator end;
+
+    switch(eSetupType)
+    {
+    case SERVER_GROUP:     pos = m_ServerGroup.find(dwKey);    end = m_ServerGroup.end();      break;
+    case SERVER_TYPE:      pos = m_ServerType.find(dwKey);     end = m_ServerType.end();       break;
+    case SERVER_ZONE:      pos = m_ServerZone.find(dwKey);     end = m_ServerZone.end();       break;
+    case SERVER_CHANNEL:   pos = m_ServerChannel.find(dwKey);  end = m_ServerChannel.end();    break;
+
+    default:
+        return 0;
+    }
+
+    return (pos != end) ? pos->second.c_str() : 0;
+}
+
+void CRylServerGroupSetup::Load(const char* szFileName)
+{   
+    m_ServerGroup.clear();
+    m_ServerType.clear();
+    m_ServerZone.clear();
+    m_ServerChannel.clear();
+
+    ReadRylServerStringValues(m_ServerGroup, "SERVER_GROUP", "SERVER_GROUP", szFileName);
+    ReadRylServerStringValues(m_ServerType, "SERVER_TYPE", "SERVER_TYPE", szFileName);
+    ReadRylServerStringValues(m_ServerZone, "GAMESERVER", "GAME_ZONE", szFileName);
+    ReadRylServerStringValues(m_ServerChannel, "GENERAL", "GAME_CHANNEL", szFileName);
+}
+
+
+void CRylServerGroupSetup::Save(const char* szFileName)
+{
+    WriteRylServerStringValues(m_ServerGroup, "SERVER_GROUP", "SERVER_GROUP", szFileName);
+    WriteRylServerStringValues(m_ServerType, "SERVER_TYPE", "SERVER_TYPE", szFileName);
+    WriteRylServerStringValues(m_ServerZone, "GAMESERVER", "GAME_ZONE", szFileName);
+    WriteRylServerStringValues(m_ServerChannel, "GENERAL", "GAME_CHANNEL", szFileName);
+}
+
+
+void CRylServerGroupSetup::SetSetupFileName(const char* szFileName)
+{
+    if(0 != szFileName)
+    {
+        _snprintf(m_szSetupFileName, MAX_PATH - 1, "%s", szFileName);
+        m_szSetupFileName[MAX_PATH - 1] = 0;
+    }    
+}
+
+unsigned long CRylServerGroupSetup::GetStringNum(SetupType eSetupType)
+{
+    switch(eSetupType)
+    {
+    case SERVER_GROUP:     return m_ServerGroup.size();
+    case SERVER_TYPE:      return m_ServerType.size();
+    case SERVER_ZONE:      return m_ServerZone.size();
+    case SERVER_CHANNEL:   return m_ServerChannel.size();
+    }
+
+    return 0;
+}
+
+void ReadRylServerStringValues(CRylServerGroupSetup::ServerStringMap& serverStringMap,
+                               const char* szReadSection, const char* szKey, const char* szFileName)
+{
+    char szNumKey[MAX_PATH];
+    char szStringKey[MAX_PATH];
+    char szStringValue[MAX_PATH];
+    
+    unsigned long dwKey = 0;
+    const unsigned long dwInvalidKey = 0xFFFFFFFF;
+    
+    _snprintf(szStringKey, MAX_PATH - 1, "%s_NUM", szKey);
+	UINT nNum = GetPrivateProfileInt(szReadSection, szStringKey, 0, szFileName);
+
+	for(UINT nIndex = 0; nIndex < nNum; ++nIndex)
+	{
+        _snprintf(szNumKey, MAX_PATH - 1, "%s_KEY%d", szKey, nIndex);
+        _snprintf(szStringKey, MAX_PATH - 1, "%s_STRING%d", szKey, nIndex);
+
+        dwKey = static_cast<unsigned long>(GetPrivateProfileInt(szReadSection,
+            szNumKey, dwInvalidKey, szFileName));
+
+        GetPrivateProfileString(szReadSection, szStringKey, "", 
+            szStringValue, MAX_PATH, szFileName);
+
+        if(dwKey != dwInvalidKey && 0 != szStringValue[0])
+        {
+            serverStringMap.insert(CRylServerGroupSetup::ServerStringMap::value_type(dwKey, szStringValue));
+        }
+	}
+}
+
+
+void WriteRylServerStringValues(CRylServerGroupSetup::ServerStringMap& serverStringMap,
+                                const char* szReadSection, const char* szKey, const char* szFileName)
+{
+    char szNumKey[MAX_PATH];
+    char szNumValue[MAX_PATH];
+
+    char szStringKey[MAX_PATH];
+    char szStringValue[MAX_PATH];
+
+    CRylServerGroupSetup::ServerStringMap::iterator pos = serverStringMap.begin();
+    CRylServerGroupSetup::ServerStringMap::iterator end = serverStringMap.end();
+
+    UINT nIndex = 0;
+    for(;pos != end; ++pos, ++nIndex)
+    {
+        CRylServerGroupSetup::ServerStringMap::value_type& value = *pos;
+
+        _snprintf(szNumKey, MAX_PATH - 1, "%s_KEY%d", szKey, nIndex);
+        _snprintf(szStringKey, MAX_PATH - 1, "%s_STRING%d", szKey, nIndex);
+
+        _snprintf(szNumValue, MAX_PATH - 1, "%d", value.first);
+
+        WritePrivateProfileString(szReadSection, szNumKey, szNumValue, szFileName);
+        WritePrivateProfileString(szReadSection, szStringKey, value.second.c_str(), szFileName);
+
+    }
+
+    _snprintf(szStringKey, MAX_PATH - 1, "%s_NUM", szKey);
+    _snprintf(szStringValue, MAX_PATH - 1, "%d", serverStringMap.size());
+    WritePrivateProfileString(szReadSection, szStringKey, szStringValue, szFileName);
+}

Server/ManageTool/ManageLibrary/Setup/RylServerGroupSetup.h

@@ -0,0 +1,77 @@
+#ifndef _RYL_SERVER_GROUP_SETUP_H_
+#define _RYL_SERVER_GROUP_SETUP_H_
+
+#pragma warning(disable:4800)
+
+#include <map>
+#include <string>
+#include <boost/pool/pool_alloc.hpp>
+
+class CRylServerGroupSetup
+{
+public:
+
+    typedef std::basic_string<char, std::char_traits<char>, boost::pool_allocator<char> >   
+        boost_string;
+    
+    typedef std::map<unsigned long, boost_string, std::less<unsigned long>, 
+        boost::pool_allocator<std::pair<unsigned long, boost_string> > >
+        ServerStringMap;
+
+    enum SetupType
+    {
+        SERVER_GROUP,
+        SERVER_TYPE,
+        SERVER_ZONE,
+        SERVER_CHANNEL
+    };
+
+    static CRylServerGroupSetup& GetInstance();
+    
+    const char* GetSetupString(SetupType eSetupType, unsigned long dwKey);
+    unsigned long GetStringNum(SetupType eSetupType);
+
+    void Load(const char* szFileName = GetInstance().GetSetupFileName());
+    void Save(const char* szFileName = GetInstance().GetSetupFileName());
+
+    void SetSetupFileName(const char* szFileName);
+    const char* GetSetupFileName() { return m_szSetupFileName; }
+
+    template<typename FnProcess>
+        void EnumSetup(SetupType eSetupType, FnProcess fnProcess)
+    {
+        ServerStringMap::iterator pos;
+        ServerStringMap::iterator end;
+
+        switch(eSetupType)
+        {
+        case SERVER_GROUP:     pos = m_ServerGroup.begin();    end = m_ServerGroup.end();      break;
+        case SERVER_TYPE:      pos = m_ServerType.begin();     end = m_ServerType.end();       break;
+        case SERVER_ZONE:      pos = m_ServerZone.begin();     end = m_ServerZone.end();       break;
+        case SERVER_CHANNEL:   pos = m_ServerChannel.begin();  end = m_ServerChannel.end();    break;
+
+        default:
+            return;
+        }
+
+        for(; pos != end; ++pos)
+        {
+            ServerStringMap::value_type& value = *pos;
+            fnProcess(value.first, value.second.c_str());
+        }
+    }
+
+private:
+
+    CRylServerGroupSetup();
+    ~CRylServerGroupSetup();
+
+    ServerStringMap     m_ServerGroup;
+    ServerStringMap     m_ServerType;
+    ServerStringMap     m_ServerZone;
+    ServerStringMap     m_ServerChannel;
+
+    char                m_szSetupFileName[MAX_PATH];
+};
+
+#endif

Server/ManageTool/ManageLibrary/Setup/SetupClient.cpp

@@ -0,0 +1,95 @@
+#include "stdafx.h"
+#include "SetupClient.h"
+
+#include <cstdio>
+#include <Utility/Setup/ServerSetup.h>
+
+ManageSetup::ClientSetup::ClientSetup()
+{
+    SetSetupFileName("./ManageSetupClient.ini");
+    Load();
+}
+
+ManageSetup::ClientSetup::~ClientSetup()
+{
+
+}
+
+ManageSetup::ClientSetup& ManageSetup::ClientSetup::GetInstance()
+{
+    static ClientSetup clientSetup;
+    return clientSetup;
+}
+    
+void ManageSetup::ClientSetup::Load(const char* szSetupFileName)
+{
+    char szIP[MAX_PATH];
+    GetPrivateProfileString("ManageClient", "ManageServerIP", 0, szIP, MAX_PATH, szSetupFileName);
+
+    UINT nPort = GetPrivateProfileInt("ManageClient", "ManageServerPort", 
+		CServerSetup::ManageServerManageClientListen, szSetupFileName);
+
+    m_ManageServerAddr.set_addr(szIP, static_cast<unsigned short>(nPort));  
+}
+
+
+void ManageSetup::ClientSetup::Save(const char* szSetupFileName)
+{
+    char szIP[MAX_PATH];
+    _snprintf(szIP, MAX_PATH - 1, "%s", m_ManageServerAddr.get_addr_string());
+    szIP[MAX_PATH - 1] = 0;
+
+    char szPort[MAX_PATH];
+    _snprintf(szPort, MAX_PATH - 1, "%d", m_ManageServerAddr.get_port_in());
+    szPort[MAX_PATH - 1] = 0;
+
+    WritePrivateProfileString("ManageClient", "ManageServerIP", szIP, szSetupFileName);
+    WritePrivateProfileString("ManageClient", "ManageServerPort", szPort, szSetupFileName);    
+}
+
+void ManageSetup::ClientSetup::SetSetupFileName(const char* szSetupFileName)
+{
+    if(0 != szSetupFileName)
+    {
+        _snprintf(m_szSetupFileName, MAX_PATH, "%s", szSetupFileName);
+        m_szSetupFileName[MAX_PATH - 1] = 0;
+    }
+}
+
+
+bool ManageSetup::ClientSetup::SerializeIn(const char* szData_In, unsigned long dwDataLen_In)
+{
+    if(dwDataLen_In == GetExpectedSerializedDataSize())
+    {
+        int nAddrSize = 0;
+
+        memcpy(&m_ManageServerAddr.get_addr(), szData_In, sizeof(sockaddr));
+        memcpy(&nAddrSize, szData_In + sizeof(sockaddr), sizeof(int));
+        
+        m_ManageServerAddr.set_size(nAddrSize);
+        return true;
+    }
+
+    return false;
+}
+
+bool ManageSetup::ClientSetup::SerializeOut(char* szData_InOut, unsigned long& dwDataLen_InOut)
+{
+    if(GetExpectedSerializedDataSize() < dwDataLen_InOut)
+    {
+        int nAddrSize = m_ManageServerAddr.get_size();
+
+        memcpy(szData_InOut, &m_ManageServerAddr.get_addr(), sizeof(sockaddr));
+        memcpy(szData_InOut + sizeof(sockaddr), &nAddrSize, sizeof(int));
+
+        dwDataLen_InOut = GetExpectedSerializedDataSize();
+        return true;
+    }
+
+    return false;
+}
+
+unsigned long ManageSetup::ClientSetup::GetExpectedSerializedDataSize()
+{
+    return static_cast<unsigned long>(sizeof(sockaddr) + sizeof(int));
+}

Server/ManageTool/ManageLibrary/Setup/SetupClient.h

@@ -0,0 +1,40 @@
+#ifndef _GM_NETWORK_MANAGE_SETUP_CLIENT_H_
+#define _GM_NETWORK_MANAGE_SETUP_CLIENT_H_
+
+#include <Network/Address/INET_Addr.h>
+
+namespace ManageSetup
+{
+
+class ClientSetup
+{
+public:
+
+    static ClientSetup& GetInstance();
+
+    bool SerializeIn(const char* szData_In, unsigned long dwDataLen_In);
+    bool SerializeOut(char* szData_InOut, unsigned long& dwDataLen_InOut);
+
+    unsigned long GetExpectedSerializedDataSize();
+    
+    void Load(const char* szSetupFileName = ClientSetup::GetInstance().GetSetupFileName());
+    void Save(const char* szSetupFileName = ClientSetup::GetInstance().GetSetupFileName());
+
+    const char* GetSetupFileName() { return m_szSetupFileName; }
+    void SetSetupFileName(const char* szSetupFileName);
+
+    INET_Addr& GetManageServerAddr() { return m_ManageServerAddr; }
+
+private:
+
+    ClientSetup();
+    ~ClientSetup();
+
+    INET_Addr   m_ManageServerAddr;
+    char        m_szSetupFileName[MAX_PATH];
+};
+
+};
+
+
+#endif

Server/ManageTool/ManageLibrary/UserManage/ToolUserManageTable.cpp

@@ -0,0 +1,543 @@
+#include "stdafx.h"
+#include "ToolUserManageTable.h"
+
+#include <tchar.h>
+#include <Log/ServerLog.h>
+
+#include <Stream/Buffer/Buffer.h>
+#include <Stream/Buffer/BufferFactory.h>
+
+#include <Network/Session/Session.h>
+#include <Network/Dispatch/SendManagePacket.h>
+#include <Network/Dispatch/ManageServer/ManageToolServerDispatch.h>
+
+#include <DB/SQLite.h>
+#include <DB/ManageServerDB.h>
+#include <Setup/RylServerGroupSetup.h>
+
+
+CToolUserManager& CToolUserManager::GetInstance()
+{
+	static CToolUserManager toolUserManager(CManageServerDB::GetInstance());
+	return toolUserManager;
+}
+
+
+inline void SetUserInfo(ServerManage::UserInfo& UserInfo_Out, 
+						const char* szID, const char* szPass,
+						const char* szFullName, const char* szIP,
+						const char* szAdminLevel)
+{
+	_snprintf(UserInfo_Out.szID, ServerManage::UserInfo::ID_LEN - 1, "%s", szID);
+	UserInfo_Out.szID[ServerManage::UserInfo::ID_LEN - 1] = 0;
+
+	_snprintf(UserInfo_Out.szPassword, ServerManage::UserInfo::PASS_LEN - 1, "%s", szPass);
+	UserInfo_Out.szPassword[ServerManage::UserInfo::PASS_LEN - 1] = 0;
+
+	_snprintf(UserInfo_Out.szFullName, ServerManage::UserInfo::NAME_LEN - 1, "%s", szFullName);
+	UserInfo_Out.szFullName[ServerManage::UserInfo::NAME_LEN - 1] = 0;
+
+	UserInfo_Out.dwIP = inet_addr(szIP);
+	UserInfo_Out.usAdminLevel = atoi(szAdminLevel);
+}
+
+
+
+CToolUserManager::ToolUser::ToolUser(CManageToolServerDispatch* lpDispatch, 
+									 ServerManage::UserInfo& userInfo)
+									 :	m_lpDispatch(lpDispatch), m_UserInfo(userInfo)
+{
+
+}
+
+CToolUserManager::ToolUser::ToolUser()
+:	m_lpDispatch(0)
+{
+	memset(&m_UserInfo, 0, sizeof(ServerManage::UserInfo));
+}
+
+
+enum ToolUserConst
+{
+	TOOLUSER_MAX_QUERY = 1024
+};
+
+
+CToolUserManager::CToolUserManager(CManageServerDB& ManageServerDB)
+:	m_ManageServerDB(ManageServerDB)
+{
+    memset(&m_ManageUser, 0, sizeof(ServerManage::UserInfo));
+}
+
+CToolUserManager::~CToolUserManager()
+{
+
+}
+
+// -------------------------------------------------------------------------
+// UserManagement
+bool CToolUserManager::AddUser(const ServerManage::UserInfo& userInfo)
+{
+	char szQuery[TOOLUSER_MAX_QUERY];
+
+	in_addr addr;
+	addr.S_un.S_addr = userInfo.dwIP;
+
+	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
+		"INSERT INTO TblManageToolUser values('%s', '%s', '%s', '%s', %d)",
+		userInfo.szID, userInfo.szPassword, userInfo.szFullName, 
+		inet_ntoa(addr), userInfo.usAdminLevel);
+
+	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;
+
+	if(0 < nQueryLen)
+	{
+		CSQLite::Dataset addUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+		if(addUserQuery.Compile() && addUserQuery.Execute())
+		{
+			return true;
+		}
+
+		ERRLOG2(g_Log, "AddUser failed - query failed : %s(Query:%s)", 
+			addUserQuery.GetLastError(), szQuery);
+	}
+	else
+	{
+		ERRLOG1(g_Log, "AddUser failed - make query failed : (Query:%s)", szQuery);
+	}	
+	
+	return false;
+}
+
+
+bool CToolUserManager::GetUserInfo(const char* szID_In, 
+								   ServerManage::UserInfo& userInfo_Out)
+{
+	char szQuery[TOOLUSER_MAX_QUERY];
+
+	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
+		"SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser WHERE ID = '%s'", szID_In);
+
+	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;
+
+	if(0 < nQueryLen)
+	{
+        CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+		int nColNum = 0;
+		const char** pazValue  = 0;
+		const char** pazColumn = 0;
+
+		if(getUserQuery.Compile() && 
+			getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
+		{	
+			if(5 == nColNum && 0 != pazValue)
+			{
+				SetUserInfo(userInfo_Out, pazValue[0], pazValue[1], 
+					pazValue[2], pazValue[3], pazValue[4]);
+				return true;
+			}
+		}
+
+		ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
+			getUserQuery.GetLastError(), szQuery);
+	}
+	else
+	{
+		ERRLOG1(g_Log, "Getuser failed - create query failed : (Query:%s)", szQuery);
+	}
+	
+	return false;
+}
+
+bool CToolUserManager::DelUser(const char* szID)
+{
+	char szQuery[TOOLUSER_MAX_QUERY];
+
+	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
+		"DELETE FROM TblManageToolUser WHERE ID = '%s'", szID);
+
+	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;
+
+	if(0 < nQueryLen)
+	{
+        CSQLite::Dataset delUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+		if(delUserQuery.Compile() && delUserQuery.Execute())
+		{
+            return true;
+		}
+
+		ERRLOG2(g_Log, "Deluser failed - query error : %s(Query:%s)", 
+			delUserQuery.GetLastError(), szQuery);
+	}
+	else
+	{
+		ERRLOG1(g_Log, "Deluser failed - create query error : %s", szQuery);
+	}
+
+	return false;
+}
+
+bool CToolUserManager::ModifyUser(const ServerManage::UserInfo& modified)
+{
+	char szQuery[TOOLUSER_MAX_QUERY];
+
+	in_addr addr;
+	addr.S_un.S_addr = modified.dwIP;
+
+	int nQueryLen = _snprintf(szQuery, TOOLUSER_MAX_QUERY - 1, 
+		"UPDATE TblManageToolUser SET PASS = '%s', NAME = '%s', IP = '%s', LEVEL = %d WHERE ID = '%s'",
+		modified.szPassword, modified.szFullName, inet_ntoa(addr),
+		modified.usAdminLevel, modified.szID);
+
+	szQuery[TOOLUSER_MAX_QUERY - 1] = 0;
+
+	if(0 < nQueryLen)
+	{
+        CSQLite::Dataset modUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+		if(modUserQuery.Compile() && modUserQuery.Execute())
+		{
+            return true;
+		}
+
+		ERRLOG2(g_Log, "Moduser failed - query error : %s(Query:%s)", 
+			modUserQuery.GetLastError(), szQuery);
+	}
+	else
+	{
+		ERRLOG1(g_Log, "Moduser failed - create query error : %s", szQuery);
+	}
+
+	return false;
+}
+
+
+bool CToolUserManager::SendAllUserInfo(CSession& Session)
+{
+    const int MAX_USER_INFO = (PktMaxLen - sizeof(ServerManage::UserCommand)) / sizeof(ServerManage::UserInfo);
+	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];
+
+	CBufferFactory& bufferFactory = Session.GetPolicy().GetBufferFactory();
+	const char* szQuery = "SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser";
+
+    CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+	if(getUserQuery.Compile())
+	{
+        int nColNum = 0;
+		const char** pazValue  = 0;
+		const char** pazColumn = 0;
+
+		int nRowCount = 0;
+
+		while(getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
+		{	
+			if(5 == nColNum && 0 != pazValue)
+			{
+				SetUserInfo(tempUserInfo[nRowCount], pazValue[0], 
+					pazValue[1], pazValue[2], pazValue[3], pazValue[4]);
+
+				memset(tempUserInfo[nRowCount].szPassword, 0, 
+					ServerManage::UserInfo::PASS_LEN);
+
+				++nRowCount;
+			}
+
+			if(nRowCount == MAX_USER_INFO)
+			{
+				ServerManage::SendUserInfo(bufferFactory, &Session, tempUserInfo, 
+					nRowCount, ServerManage::CMD::UserList, 0);
+
+                nRowCount = 0;
+			}
+
+		}
+
+		if(0 < nRowCount)
+		{
+            ServerManage::SendUserInfo(bufferFactory, &Session, tempUserInfo, 
+				nRowCount, ServerManage::CMD::UserList, 0);
+		}
+
+		if(0 != getUserQuery.GetLastError())
+		{
+			ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
+				getUserQuery.GetLastError(), szQuery);
+		}
+	}
+	else if(0 != getUserQuery.GetLastError())
+	{
+		ERRLOG2(g_Log, "Getuser failed - compile query failed : %s(Query:%s)", 
+			getUserQuery.GetLastError(), szQuery);
+	}
+
+	return true;
+}
+
+
+bool CToolUserManager::GetUserInfo(UserList& userList_Out)
+{
+	const unsigned char MAX_USER_INFO = 100;
+	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];
+	const char* szQuery = "SELECT ID, PASS, NAME, IP, LEVEL FROM TblManageToolUser";
+
+    CSQLite::Dataset getUserQuery(m_ManageServerDB.GetSQLite(), szQuery);
+
+	if(getUserQuery.Compile())
+	{
+        int nColNum = 0;
+		const char** pazValue  = 0;
+		const char** pazColumn = 0;
+
+		int nRowCount = 0;
+
+		while(getUserQuery.Execute(&nColNum, &pazValue, &pazColumn))
+		{	
+			if(5 == nColNum && 0 != pazValue)
+			{
+				SetUserInfo(tempUserInfo[nRowCount], pazValue[0], 
+                    pazValue[1], pazValue[2], pazValue[3], pazValue[4]);
+
+				++nRowCount;
+			}
+
+			if(nRowCount == MAX_USER_INFO)
+			{
+                userList_Out.insert(userList_Out.end(), tempUserInfo, tempUserInfo + nRowCount);
+                nRowCount = 0;
+			}
+		}
+
+		if(0 < nRowCount)
+		{
+            userList_Out.insert(userList_Out.end(), tempUserInfo, tempUserInfo + nRowCount);
+		}
+
+		if(0 != getUserQuery.GetLastError())
+		{
+			ERRLOG2(g_Log, "Getuser failed - query error : %s(Query:%s)", 
+				getUserQuery.GetLastError(), szQuery);
+		}
+        else
+        {
+            return true;
+        }
+	}
+	else if(0 != getUserQuery.GetLastError())
+	{
+		ERRLOG2(g_Log, "Getuser failed - compile query failed : %s(Query:%s)", 
+			getUserQuery.GetLastError(), szQuery);
+	}
+
+    return false;
+}
+
+
+
+// Login/Logout
+ServerManage::UserCommandError CToolUserManager::Authorize(CManageToolServerDispatch& dispatch, 
+														   ServerManage::UserInfo& userInfo_inout)
+{
+	ServerManage::UserInfo foundUserInfo;
+	memset(&foundUserInfo, 0, sizeof(ServerManage::UserInfo));
+
+	ServerManage::UserCommandError eUserCommandErr = ServerManage::NO_USER_COMMAND_ERROR;
+
+	int iCheck =
+		GetPrivateProfileInt("SETTING", "USER_IP_CHECK", 1, CRylServerGroupSetup::GetInstance().GetSetupFileName());
+
+	if(IsLogin(userInfo_inout.szID))
+	{
+		eUserCommandErr = ServerManage::ALREADY_LOGINED;
+	}
+	else if(!GetUserInfo(userInfo_inout.szID, foundUserInfo))
+	{
+		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_NOT_USER;
+	}
+	else if(0 != strncmp(foundUserInfo.szPassword, userInfo_inout.szPassword, 
+		ServerManage::UserInfo::PASS_LEN))
+	{
+		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_INVALID_PASSWORD;
+	}
+	else if((1 == iCheck) && (foundUserInfo.dwIP != userInfo_inout.dwIP))
+	{
+		eUserCommandErr = ServerManage::CANNOT_AUTHORIZE_INVALID_IPADDRESS;
+	}
+	else
+	{
+		// ID, Password<72><64> <20><><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>.
+		Logout(foundUserInfo.szID);
+
+		m_LoginUserList.push_back(ToolUser(&dispatch, foundUserInfo));
+		userInfo_inout = foundUserInfo;
+	}
+
+	return eUserCommandErr;
+}
+
+
+bool CToolUserManager::IsLogin(const char* szName)
+{
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	for(; pos != end; ++pos)
+	{
+		ToolUser& toolUser = *pos;
+
+		if(0 == strncmp(toolUser.m_UserInfo.szID, szName, ServerManage::UserInfo::ID_LEN))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+bool CToolUserManager::Logout(const char* szName)
+{
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	int nEraseCount = 0;
+
+	for(; pos != end;)
+	{
+		ToolUser& toolUser = *pos;
+
+		if(0 == strncmp(toolUser.m_UserInfo.szID, szName, ServerManage::UserInfo::ID_LEN))
+		{
+			// Logout info<66><6F> <20>ش<EFBFBD>.
+			ServerManage::SendUserInfo(toolUser.m_lpDispatch->GetBufferFactory(), 0, 
+				&toolUser.m_UserInfo, 1, ServerManage::CMD::UserLogout, 0);
+
+            if(IsManageUser(toolUser.m_UserInfo))
+            {
+                memset(&m_ManageUser, 0, sizeof(ServerManage::UserInfo));
+
+                ServerManage::SendUserInfo(toolUser.m_lpDispatch->GetBufferFactory(), 0, 
+                    &m_ManageUser, 1, ServerManage::CMD::ManagerInfo, 0);
+            }
+
+			pos = m_LoginUserList.erase(pos);
+			++nEraseCount;
+		}
+		else
+		{
+			++pos;
+		}
+	}
+
+	return (0 < nEraseCount);
+}
+
+
+// Send packets to all users
+bool CToolUserManager::SendToAllLoginUser(const char* szBuffer, unsigned short usBufferSize, unsigned char cCmd_In)
+{
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	for(; pos != end; ++pos)
+	{
+		ToolUser&					toolUser	= *pos;
+		CManageToolServerDispatch*	lpDispatch	= toolUser.m_lpDispatch;
+
+		if(0 != lpDispatch)
+		{						
+			lpDispatch->GetSendStream().PutBuffer(szBuffer, usBufferSize, cCmd_In);
+		}
+	}
+
+	return true;
+}
+
+
+bool CToolUserManager::SendAllLoginUserInfo(CSession& Session)
+{
+	const unsigned char MAX_USER_INFO = 100;
+	ServerManage::UserInfo tempUserInfo[MAX_USER_INFO];
+
+	CBufferFactory& bufferFactory = Session.GetPolicy().GetBufferFactory();
+
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	unsigned char cSendNum = 0;
+
+	for(; pos != end; ++pos)
+	{
+		tempUserInfo[cSendNum] = pos->m_UserInfo;
+		memset(tempUserInfo[cSendNum].szPassword, 0, ServerManage::UserInfo::PASS_LEN);
+
+		++cSendNum;
+
+		if(cSendNum == MAX_USER_INFO)
+		{
+			ServerManage::SendUserInfo(bufferFactory, &Session,
+				tempUserInfo, cSendNum, ServerManage::CMD::UserLogin, 0);
+
+			cSendNum = 0;
+		}
+	}
+
+	if(0 < cSendNum)
+	{
+		ServerManage::SendUserInfo(bufferFactory, &Session,
+			tempUserInfo, cSendNum, ServerManage::CMD::UserLogin, 0);
+	}
+
+	return true;
+}
+
+
+CManageToolServerDispatch* CToolUserManager::GetUserDispatch(unsigned long dwIP)
+{
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	for(; pos != end; ++pos)
+	{
+		ToolUser& toolUser = *pos;
+
+		if(toolUser.m_UserInfo.dwIP == dwIP)
+		{
+			return toolUser.m_lpDispatch;
+		}
+	}
+
+	return 0;
+}
+
+CManageToolServerDispatch* CToolUserManager::GetUserDispatch(const char* szID)
+{
+	CurrentUserList::iterator pos = m_LoginUserList.begin();
+	CurrentUserList::iterator end = m_LoginUserList.end();
+
+	for(; pos != end; ++pos)
+	{
+		ToolUser& toolUser = *pos;
+
+		if(0 == strncmp(toolUser.m_UserInfo.szID, szID, ServerManage::UserInfo::ID_LEN))
+		{
+			return toolUser.m_lpDispatch;
+		}
+	}
+
+	return 0;
+}
+
+
+bool CToolUserManager::IsManageUser(const ServerManage::UserInfo& UserInfo)
+{
+    if(0 == strncmp(m_ManageUser.szID, UserInfo.szID, ServerManage::UserInfo::ID_LEN))
+    {
+        return true;
+    }
+
+    return false;
+}

Server/ManageTool/ManageLibrary/UserManage/ToolUserManageTable.h

@@ -0,0 +1,91 @@
+#ifndef _GM_MANAGE_LIB_TOOL_USER_MANAGE_TABLE_H_
+#define _GM_MANAGE_LIB_TOOL_USER_MANAGE_TABLE_H_
+
+#include <list>
+#include <Network/Packet/ManagePacketCmd.h>
+
+// forward decl.
+class CManageServerDB;
+class CSession;
+class CManageToolServerDispatch;
+
+class CToolUserManager
+{
+public:
+
+    typedef std::list<ServerManage::UserInfo> UserList;
+
+	enum Level
+	{
+		MASTER		= 0,
+		GENERAL		= 1,
+		MONITORING	= 2
+	};
+
+	static CToolUserManager& GetInstance();
+
+	// UserManagement ( Use File Database )
+	bool AddUser(const ServerManage::UserInfo& userInfo);
+	bool DelUser(const char* szID);
+	bool ModifyUser(const ServerManage::UserInfo& modified);
+	bool GetUserInfo(const char* szID_In, ServerManage::UserInfo& userInfo_Out);
+    bool GetUserInfo(UserList& userList_Out);
+		
+	// Login/Logout (In Server)
+	ServerManage::UserCommandError Authorize(
+		CManageToolServerDispatch& dispatch, 
+		ServerManage::UserInfo& userInfo_inout);
+
+	bool IsLogin(const char* szName);
+	bool Logout(const char* szName);
+
+	// Send packets to all users
+	bool SendToAllLoginUser(const char* szBuffer, unsigned short usBufferSize, unsigned char cCmd_In);
+	
+	bool SendAllLoginUserInfo(CSession& Session);
+	bool SendAllUserInfo(CSession& Session);
+
+	// ProcessAll
+	template<typename FnProcess>
+		void ProcessCurrentUser(FnProcess fnProcess)
+	{
+		CurrentUserList::iterator pos = m_LoginUserList.begin();
+		CurrentUserList::iterator end = m_LoginUserList.end();
+
+		for(;pos != end; ++pos)
+		{
+			fnProcess(*pos->m_lpDispatch);
+		}
+	}
+
+	CManageToolServerDispatch* GetUserDispatch(unsigned long dwIP);
+	CManageToolServerDispatch* GetUserDispatch(const char* szID);
+
+    void Promote(const ServerManage::UserInfo& promoteUser) { m_ManageUser = promoteUser; }
+
+    bool IsManageUser(const ServerManage::UserInfo& UserInfo);
+	const ServerManage::UserInfo& GetManageUser() const { return m_ManageUser; }
+    CManageToolServerDispatch* GetManageUserDispatch()  { return GetUserDispatch(m_ManageUser.szID); }
+
+private:
+
+	CToolUserManager(CManageServerDB& ManageServerDB);
+	~CToolUserManager();
+
+	struct ToolUser
+	{
+		CManageToolServerDispatch*	m_lpDispatch;
+		ServerManage::UserInfo		m_UserInfo;
+
+		ToolUser();
+		ToolUser(CManageToolServerDispatch* lpDispatch, ServerManage::UserInfo& userInfo);		
+	};
+		
+	typedef std::list<ToolUser> CurrentUserList;
+	
+	CManageServerDB&        m_ManageServerDB;
+	CurrentUserList         m_LoginUserList;	// Logged user list;
+    ServerManage::UserInfo  m_ManageUser;		// Current master user list;	
+};
+
+#endif

Server/ManageTool/ManageLibrary/UserManage/UserStatistics.cpp

@@ -0,0 +1,492 @@
+#include "stdafx.h"
+#include "UserStatistics.h"
+
+#include <Network/Packet/WrapPacket.h>
+#include <Network/Packet/ManagePacketCmd.h>
+#include <Network/Packet/PacketStruct/ServerInfo.h>
+#include <Log/ServerLog.h>
+#include <Utility/Setup/ServerSetup.h>
+#include <Network/Dispatch/SingleDispatchStorage.h>
+#include <Network/Dispatch/ManageServer/StatServerMultiDispatch.h>
+#include <atlTime.h>
+
+
+const TCHAR* g_szAppName = _T("HANGAME_SEND_USER_INFO");
+
+
+CUserStatistics& CUserStatistics::GetInstance()
+{
+	static CUserStatistics userStatistics;
+	return userStatistics;
+}
+
+CUserStatistics::CUserStatistics()
+{
+    SetSetupFileName(_T("./RylSetupServerGroup.ini"));
+	Load();
+}
+
+CUserStatistics::~CUserStatistics()
+{
+
+}
+
+
+void CUserStatistics::SetSetupFileName(const TCHAR* szFileName)
+{
+    if(0 != szFileName)
+    {
+        _sntprintf(m_szSetupFileName, MAX_PATH - 1, "%s", szFileName);
+        m_szSetupFileName[MAX_PATH - 1] = 0;
+    }
+}
+
+bool CUserStatistics::Load()
+{
+	StatisticsLock::Syncronize sync(m_Lock);
+
+	TCHAR szKeyName[MAX_PATH];
+	TCHAR szValue[MAX_PATH];
+
+	m_ServerGroupNames.clear();
+
+	unsigned long dwMaxServerGroup = GetPrivateProfileInt(g_szAppName, "MAX_GROUP_NAME", 0, m_szSetupFileName);
+
+	for(unsigned long dwCount = 0; dwCount < dwMaxServerGroup; ++dwCount)
+	{
+		_sntprintf(szKeyName, MAX_PATH - 1, "GROUP_KEY%u", dwCount);
+		szKeyName[MAX_PATH - 1] = 0;
+
+		unsigned long dwKey = GetPrivateProfileInt(g_szAppName, szKeyName, 0xFFFFFFFF, m_szSetupFileName);
+
+        if(dwKey != 0xFFFFFFFF)
+        {
+            _sntprintf(szKeyName, MAX_PATH - 1, "GROUP_NAME%u", dwCount);
+		    szKeyName[MAX_PATH - 1] = 0;
+
+		    GetPrivateProfileString(g_szAppName, szKeyName, 0, szValue, MAX_PATH, m_szSetupFileName);
+
+            m_ServerGroupNames.insert(ServerGroupNames::value_type(dwKey, szValue));
+        }
+	}
+
+	GetPrivateProfileString(g_szAppName, "HANGAME_SERVER_DOMAIN", 0, szValue, MAX_PATH, m_szSetupFileName);
+	unsigned short usPort = static_cast<unsigned short>(
+		GetPrivateProfileInt(g_szAppName, "HANGAME_SERVER_PORT", 0, m_szSetupFileName));
+	
+	hostent* lphost = gethostbyname(szValue);
+	if (0 != lphost)
+	{	
+		for (int nCount = 0; 0 != lphost->h_addr_list[nCount]; ++nCount )
+		{
+            m_HangameAddress.push_back(
+				INET_Addr(*(in_addr*)lphost->h_addr_list[nCount], usPort));
+		}
+	}
+
+	return true;
+}
+
+void CUserStatistics::InternalSetUserNum(unsigned long dwRunID, unsigned long dwServerID, int nCurrentUserNum)
+{
+    // ServerID <20><>Ģ üũ dwServerID
+
+    SERVER_ID serverID;
+    serverID.dwID = dwServerID;
+
+    if(0 <= serverID.GetChannel() && 0 <= serverID.GetGroup() && 0 <= serverID.GetZone())
+    {
+        UserNumTable::iterator pos = m_CurrentUsers.find(dwServerID);
+        if(pos != m_CurrentUsers.end())
+        {
+            // <20><> <20><><EFBFBD><EFBFBD>
+            pos->second = nCurrentUserNum;
+        }
+        else
+        {
+            // <20><> <20><><EFBFBD><EFBFBD>        
+            pos = m_CurrentUsers.insert(pos, UserNumTable::value_type(dwServerID, nCurrentUserNum));
+            m_RunIDTable.insert(RunIDTable::value_type(dwRunID, pos));
+        }
+    }
+}
+
+int CUserStatistics::GetUserNum(unsigned long dwServerID)
+{
+	StatisticsLock::Syncronize sync(m_Lock);
+	UserNumTable::iterator find = m_CurrentUsers.find(dwServerID);
+	return (find != m_CurrentUsers.end()) ? find->second : 0;
+}
+
+int CUserStatistics::GetTotalUserNum()
+{
+    StatisticsLock::Syncronize sync(m_Lock);
+
+	UserNumTable::iterator pos = m_CurrentUsers.begin();
+	UserNumTable::iterator end = m_CurrentUsers.end();
+
+    int nTotalUser = 0;
+
+    for(; pos != end; ++pos)
+    {
+        int nCurrentUser = pos->second;
+
+        if(0 < nCurrentUser)
+        {
+            nTotalUser += pos->second;
+        }
+    }
+
+    return nTotalUser;
+}
+
+int CUserStatistics::GetGroupUserNum(char cGroupNum)
+{
+    StatisticsLock::Syncronize sync(m_Lock);
+
+	UserNumTable::iterator pos = m_CurrentUsers.begin();
+	UserNumTable::iterator end = m_CurrentUsers.end();
+
+    int nTotalUser = 0;
+
+    SERVER_ID serverID;
+
+    for(; pos != end; ++pos)
+    {
+        serverID.dwID = pos->first;
+
+        if(cGroupNum == serverID.GetGroup())
+        {
+            int nCurrentUser = pos->second;
+
+            if(0 < nCurrentUser)
+            {
+                nTotalUser += pos->second;
+            }
+        }
+    }
+
+    return nTotalUser;
+}
+
+void CUserStatistics::InternalClearRunID_UserNum(unsigned long dwRunID)
+{
+    std::pair<RunIDTable::iterator, RunIDTable::iterator>
+        resultPair = m_RunIDTable.equal_range(dwRunID);
+
+	RunIDTable::iterator pos = resultPair.first;
+
+    for(; pos != resultPair.second; ++pos)
+    {        
+		if(0 != pos->second->second)
+		{
+			pos->second->second = 0;
+		}
+    }
+}
+
+void CUserStatistics::InternalClearGroupUserNum(unsigned char cGroupNum)
+{
+	UserNumTable::iterator pos = m_CurrentUsers.begin();
+	UserNumTable::iterator end = m_CurrentUsers.end();
+
+    SERVER_ID serverID;
+
+    for(; pos != end; ++pos)
+    {
+        serverID.dwID = pos->first;
+
+        if(cGroupNum == serverID.GetGroup())
+        {
+            pos->second = 0;
+        }
+    } 
+}
+
+void CUserStatistics::SerializeIn(unsigned long dwRunID, 
+                                  ServerManage::UserNumPair* lpUserNumPair, unsigned long dwPairNum)
+{
+    if(0 != lpUserNumPair)
+    {
+        StatisticsLock::Syncronize sync(m_Lock);
+
+        ServerManage::UserNumPair* lpUserNumPairEnd = lpUserNumPair + dwPairNum;
+
+        for(; lpUserNumPair != lpUserNumPairEnd; ++lpUserNumPair)
+        {
+            InternalSetUserNum(dwRunID, lpUserNumPair->m_dwServerID, 
+                lpUserNumPair->m_nUserNum);
+        }
+    }
+}
+
+
+void CUserStatistics::SendStatisticsToHanGame()
+{
+    if(0 == GetPrivateProfileInt(g_szAppName, "SEND_HANGAME_INFO", 0, m_szSetupFileName))
+    {
+        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
+        return;
+    }
+
+	char szGameID[256];
+	GetPrivateProfileString(g_szAppName, "SEND_GAME_ID", _T("RYL"), szGameID, 256, m_szSetupFileName);
+
+	UserNumTable CurrentUsers;
+
+	{
+		StatisticsLock::Syncronize sync(m_Lock);
+		CurrentUsers = m_CurrentUsers;
+	}
+
+	const int MAX_BUFFER = 3192;
+	char szBuffer[MAX_BUFFER];
+
+	SERVER_ID	ServerID;
+	int			nUserNum = 0;
+	int			nLength  = 0;
+
+	size_t		nMaxGroupName = m_ServerGroupNames.size();
+
+	SOCKADDR_IN	ServerAddr;
+	memset(&ServerAddr, 0, sizeof(SOCKADDR_IN));
+
+	UserNumTable::iterator pos = CurrentUsers.begin();
+	UserNumTable::iterator end = CurrentUsers.end();
+
+	for(; pos != end; ++pos)
+	{
+		ServerID.dwID = pos->first;
+		nUserNum      = pos->second;
+
+        if(ServerID.GetZone() - 1 < 0 || ServerID.GetChannel() < 0)
+        {
+            
+
+        }
+        else if(0 < nUserNum)
+		{
+            ServerGroupNames::iterator pos = m_ServerGroupNames.find(ServerID.GetGroup());
+
+            if(pos != m_ServerGroupNames.end())
+            {
+                // TODO : Sparrowhawk.
+                // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ȳ<EFBFBD><C8B2>.. ù <20><><EFBFBD><EFBFBD> GrandCost<73><74> <20><> <20><>ȣ<EFBFBD><C8A3> 1<>̴<EFBFBD>.
+                // <20>׷<EFBFBD><D7B7><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><>ȣ<EFBFBD><C8A3> 0<><30><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ѵ<EFBFBD>.
+                // GetServerSession<6F><6E><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̴<EFBFBD>.
+
+                nLength = _snprintf(szBuffer, MAX_BUFFER,
+				    "GET /gamestatic/gameconn.nhn?m=gameconn&gameid=%s&servername=%s-%d-%d&conncount=%d\n\n", 
+				    szGameID,
+					pos->second.c_str(),
+				    ServerID.GetZone() - 1, 
+				    ServerID.GetChannel(), 
+				    nUserNum);
+
+			    // <20><><EFBFBD><EFBFBD>
+				AddressList::iterator pos = m_HangameAddress.begin();
+				AddressList::iterator end = m_HangameAddress.end();
+
+				bool bSucceeded = false;
+
+				for (; pos != end && !bSucceeded; ++pos)
+				{
+					INET_Addr& address = *pos;
+					
+					SOCKET hSocket = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, 0, WSA_FLAG_OVERLAPPED);
+					if (INVALID_SOCKET == hSocket)
+					{
+						ERRLOG1(g_Log, "Hangame user send failed : socket create failed - %d", WSAGetLastError());
+					}
+					else if (SOCKET_ERROR == connect(hSocket, &address.get_addr(), address.get_size()))
+					{
+						ERRLOG1(g_Log, "Hangame user send failed : connect failed - %d", WSAGetLastError());
+					}
+					else if (SOCKET_ERROR == send(hSocket, szBuffer, nLength, 0)) 
+					{
+						ERRLOG1(g_Log, "Hangame user send failed : send failed - %d", WSAGetLastError());
+					} 
+					else
+					{
+						INFLOG2(g_Log, "'%s':%d bytes send complete", szBuffer, nLength);
+						bSucceeded = true;
+					}
+
+					shutdown(hSocket, SD_SEND);
+					closesocket(hSocket);	
+				}
+            }
+		}
+	}
+}
+
+void CUserStatistics::SendStatisticsToStatServer()
+{
+	int nSendGlobal =
+		GetPrivateProfileInt("STATSERVER_INFO", "SEND_STAT_SERVER_1ST", 0, m_szSetupFileName);
+	
+	int nSendLocal =
+		GetPrivateProfileInt("STATSERVER_INFO", "SEND_STAT_SERVER_2ND", 0, m_szSetupFileName);
+	
+	int	nNation =
+		GetPrivateProfileInt("GENERAL", "NATION_INDEX", 0, m_szSetupFileName);
+
+	if((0 == nSendGlobal) && (0 == nSendLocal))
+	{
+		return;
+	}
+
+	if(UCHAR_MAX < nNation)
+	{
+		ERRLOG1(g_Log, "Nation index is invalid: NationIndex-%d", nNation);
+		return;
+	}
+
+	SERVER_ID ServerID;
+	int	nUserNum = 0;
+
+	UserNumTable CurrentUsers;
+	{
+		StatisticsLock::Syncronize sync(m_Lock);
+		CurrentUsers = m_CurrentUsers;
+	}
+
+	const int MAX_USER_STAT = 1000;
+	const int BUFFER_SIZE   = sizeof(ServerManage::PktUserStat) +
+		sizeof(ServerManage::UserStatData) * MAX_USER_STAT;
+
+	char szBuffer[BUFFER_SIZE];
+
+	ServerManage::PktUserStat* lpPktUserStat =
+		reinterpret_cast<ServerManage::PktUserStat*>(szBuffer);
+
+	ServerManage::UserStatData* lpUserStatData = 
+		reinterpret_cast<ServerManage::UserStatData*>(lpPktUserStat + 1);
+
+	unsigned short nUserStatData = 0;
+	
+	SYSTEMTIME stCurrentTime;
+	GetLocalTime(&stCurrentTime);
+
+	_snprintf(lpPktUserStat->m_szSendingTime, ServerManage::PktUserStat::MAX_DATE,
+		"%04d-%02d-%02d %02d:%02d:%02d",
+		stCurrentTime.wYear, stCurrentTime.wMonth, stCurrentTime.wDay,
+		stCurrentTime.wHour, stCurrentTime.wMinute, stCurrentTime.wSecond);
+
+	UserNumTable::iterator pos = CurrentUsers.begin();
+	UserNumTable::iterator end = CurrentUsers.end();
+
+	const int MAX_BUFFER = 256;
+	char szGlobalStatServerIP[MAX_BUFFER], szLocalStatServerIP[MAX_BUFFER];
+	
+	GetPrivateProfileString("STATSERVER_INFO", "STAT_SERVER_1ST_IP", 0,
+		szGlobalStatServerIP, MAX_BUFFER, m_szSetupFileName);
+	GetPrivateProfileString("STATSERVER_INFO", "STAT_SERVER_2ND_IP", 0,
+		szLocalStatServerIP, MAX_BUFFER, m_szSetupFileName);
+
+	GET_MULTI_DISPATCH(lpGlobalStatDispatch, inet_addr(szGlobalStatServerIP),
+		CStatServerMultiDispatch, CStatServerMultiDispatch::GetDispatchTable());
+	GET_MULTI_DISPATCH(lpLocalStatDispatch, inet_addr(szLocalStatServerIP),
+		CStatServerMultiDispatch, CStatServerMultiDispatch::GetDispatchTable());
+
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	for(; pos != end; ++pos)
+	{
+		ServerID.dwID = pos->first;
+		nUserNum      = pos->second;
+
+		if(nUserNum < 0)
+		{
+			nUserNum = 0;
+		}
+
+		if(ServerID.GetZone() - 1 < 0 || ServerID.GetChannel() < 0)
+		{
+			ERRLOG1(g_Log, "Invalid serverID: %u", ServerID.dwID);
+		}
+		else if(CServerSetup::GameServer == ServerID.GetType())
+		{
+			lpUserStatData->m_dwServerID = ServerID.dwID;
+			lpUserStatData->m_nNation    = nNation;
+			lpUserStatData->m_nUserNum   = nUserNum;
+
+			INFLOG3(g_Log, "[UserStat Sended] NationCode: %d/ServerID: 0x%08x/UserNum: %d",
+				nNation, ServerID.dwID, nUserNum);
+
+			++lpUserStatData;
+			++nUserStatData;
+		}
+	}
+
+	// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
+	if(nUserStatData == MAX_USER_STAT - 1)
+	{
+		lpPktUserStat->m_usUserStatDataNum = nUserStatData;
+	
+		if((NULL != lpGlobalStatDispatch) && (1 == nSendGlobal))
+		{
+			lpGlobalStatDispatch->GetSendStream().WrapCompress(szBuffer,
+				sizeof(ServerManage::PktUserStat) + sizeof(ServerManage::UserStatData) * nUserStatData,
+				ServerManage::CMD::UPDATE_USER_STATUS, 0, 0);
+		}
+
+		if((NULL != lpLocalStatDispatch) && (1 == nSendLocal))
+		{
+			lpLocalStatDispatch->GetSendStream().WrapCompress(szBuffer,
+				sizeof(ServerManage::PktUserStat) + sizeof(ServerManage::UserStatData) * nUserStatData,
+				ServerManage::CMD::UPDATE_USER_STATUS, 0, 0);
+		}
+
+		lpUserStatData = reinterpret_cast<ServerManage::UserStatData*>(lpPktUserStat + 1);
+		nUserStatData  = 0;				
+	}
+
+	if(0 < nUserStatData)
+	{
+		lpPktUserStat->m_usUserStatDataNum = nUserStatData;
+
+		if((NULL != lpGlobalStatDispatch) && (1 == nSendGlobal))
+		{
+			lpGlobalStatDispatch->GetSendStream().WrapCompress(szBuffer,
+				sizeof(ServerManage::PktUserStat) + sizeof(ServerManage::UserStatData) * nUserStatData,
+				ServerManage::CMD::UPDATE_USER_STATUS, 0, 0);
+		}
+
+		if((NULL != lpLocalStatDispatch) && (1 == nSendLocal))
+		{
+			lpLocalStatDispatch->GetSendStream().WrapCompress(szBuffer,
+				sizeof(ServerManage::PktUserStat) + sizeof(ServerManage::UserStatData) * nUserStatData,
+				ServerManage::CMD::UPDATE_USER_STATUS, 0, 0);
+		}
+	}
+}
+
+void CUserStatistics::CheckClearUser(PktBase* lpPktBase)
+{
+    StatisticsLock::Syncronize sync(m_Lock);
+
+    if(sizeof(ServerManage::ManageCommand) <= lpPktBase->GetLen())
+    {
+        ServerManage::ManageCommand* lpManageCommand = 
+            reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);
+
+        int nProcessStatusNum = int(lpManageCommand->usDataLen / sizeof(ServerManage::ProcessStatus));
+
+        if(sizeof(ServerManage::ManageCommand) + lpManageCommand->usDataLen == lpPktBase->GetLen()
+            && lpManageCommand->usDataLen == nProcessStatusNum * sizeof(ServerManage::ProcessStatus))
+        {
+            ServerManage::ProcessStatus* lpProcessStatus = 
+                reinterpret_cast<ServerManage::ProcessStatus*>(lpManageCommand + 1);
+
+            ServerManage::ProcessStatus* lpProcessStatusEnd = lpProcessStatus + nProcessStatusNum;
+
+            for(; lpProcessStatus != lpProcessStatusEnd; ++lpProcessStatus)
+            {
+				if(0 == (ServerManage::PROCESS_RUNNING & lpProcessStatus->m_dwStatusFlags))
+				{
+                    InternalClearRunID_UserNum(lpProcessStatus->m_dwRunID);
+				}
+			}
+        }
+    }
+}

Server/ManageTool/ManageLibrary/UserManage/UserStatistics.h

@@ -0,0 +1,96 @@
+#ifndef _MANAGE_TOOL_SERVER_USER_STATISTICS_H_
+#define _MANAGE_TOOL_SERVER_USER_STATISTICS_H_
+
+#pragma warning(disable:4800)
+
+#include <map>
+#include <vector>
+#include <string>
+#include <list>
+#include <tchar.h>
+#include <Thread/Lock.h>
+#include <Network/Address/INET_Addr.h>
+
+#include <boost/pool/pool_alloc.hpp>
+
+// forward decl.
+namespace ServerManage
+{
+    struct UserNumPair;
+}
+
+struct PktBase;
+
+
+class CUserStatistics
+{
+public:
+
+	static CUserStatistics& GetInstance();
+	
+	bool Load();
+    void SetSetupFileName(const TCHAR* szFileName);
+	
+	void SetUserNum(unsigned long dwRunID, unsigned long dwServerID, int nCurrentUserNum)
+    {
+        StatisticsLock::Syncronize sync(m_Lock);
+        InternalSetUserNum(dwRunID, dwServerID, nCurrentUserNum);
+    }
+
+	int	 GetUserNum(unsigned long dwServerID);
+    int  GetTotalUserNum();
+    int  GetGroupUserNum(char cGroupNum);
+
+    void ClearRunID_UserNum(unsigned long dwRunID)
+    {
+        StatisticsLock::Syncronize sync(m_Lock);
+        InternalClearRunID_UserNum(dwRunID);
+    }
+    void ClearGroupUserNum(unsigned char cGroupNum)
+    {
+        StatisticsLock::Syncronize sync(m_Lock);
+        InternalClearGroupUserNum(cGroupNum);
+    }
+
+    void CheckClearUser(PktBase* lpPktBase);
+
+    void SerializeIn(unsigned long dwRunID, 
+        ServerManage::UserNumPair* lpUserNumPair, unsigned long dwPairNum);
+    
+	void SendStatisticsToHanGame();
+	void SendStatisticsToStatServer();
+
+private:
+
+	CUserStatistics();
+	~CUserStatistics();
+
+	void InternalSetUserNum(unsigned long dwRunID, unsigned long dwServerID, int nCurrentUserNum);
+    void InternalClearRunID_UserNum(unsigned long dwRunID);
+    void InternalClearGroupUserNum(unsigned char cGroupNum);
+
+	typedef CCSLock	StatisticsLock;
+
+    typedef std::map<unsigned long, int, std::less<unsigned long>, 
+        boost::fast_pool_allocator<std::pair<unsigned long, int> > > UserNumTable;
+    
+    typedef std::multimap<unsigned long, UserNumTable::iterator, std::less<unsigned long>,
+        boost::fast_pool_allocator<std::pair<unsigned long, UserNumTable::iterator> > > RunIDTable;
+
+
+	typedef std::map<unsigned long, std::string>	ServerGroupNames;
+	typedef std::list<INET_Addr>					AddressList;
+
+	StatisticsLock		m_Lock;
+	CACHE_PAD(StatisticsLockPad, sizeof(StatisticsLock));
+
+	UserNumTable		m_CurrentUsers;
+    RunIDTable			m_RunIDTable;
+
+	ServerGroupNames	m_ServerGroupNames;
+	AddressList			m_HangameAddress;
+	
+    TCHAR				m_szSetupFileName[MAX_PATH];
+};
+
+#endif

Server/ManageTool/ManageLibrary/stdafx.cpp

@@ -0,0 +1,8 @@
+// stdafx.cpp : ǥ<><C7A5> <20><><EFBFBD><EFBFBD> <20><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20>ҽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
+// ServerManagerary.pch<63><68> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>˴ϴ<CBB4>.
+// stdafx.obj<62><6A><EFBFBD><EFBFBD> <20≯<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ե˴ϴ<CBB4>.
+
+#include "stdafx.h"
+
+// TODO: <20>ʿ<EFBFBD><CABF><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+// <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ƴ<EFBFBD> STDAFX.H<><48><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.

Server/ManageTool/ManageLibrary/stdafx.h

@@ -0,0 +1,12 @@
+// stdafx.h : <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD>
+// ǥ<><C7A5> <20>ý<EFBFBD><C3BD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 
+// <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Դϴ<D4B4>.
+//
+
+#pragma once
+
+
+#define WIN32_LEAN_AND_MEAN		// <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Windows <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.
+
+// TODO: <20><><EFBFBD>α׷<CEB1><D7B7><EFBFBD> <20>ʿ<EFBFBD><CABF><EFBFBD> <20>߰<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>⿡<EFBFBD><E2BFA1> <20><><EFBFBD><EFBFBD><EFBFBD>մϴ<D5B4>.
+#include <Utility/Debug/DebugMacros.h>