DragonNest/Server/ServiceManager/ServiceManager.cpp

#include "stdafx.h"
#include "ServiceServer.h"
#include "ServiceManager.h"
#include "DNConfig.h"
#include "Log.h"
#include "IniFile.h"
#include "StringUtil.h"
#include "SpinBuffer.h"
#include "csvreader.h"
#if defined (_SERVICEMANAGER_EX)
#include "ServiceManagerEx.h"
#endif // #if defined (_SERVICEMANAGER_EX)

#if defined(_KRAZ)
#include "DNActozShield.h"
#endif	// #if defined(_KRAZ)

extern CLog g_ExceptionReportLog;
extern CLog s_ExcuteLog;

#if defined( _SERVICEMANAGER_EX )
extern CLog g_FileLog;
#endif

static TCHAR * pOffLine = { _T("Offline") };
static TCHAR * pOnline = { _T("Online") };
static TCHAR * pCreate = { _T("Create") };
static TCHAR * pTerminated = { _T("Terminated") };

static TCHAR * pBlack = { _T("Black") };
static TCHAR * pGreen = { _T("Green") };
static TCHAR * pYellow = { _T("Yellow") };
static TCHAR * pRed = { _T("Red") };
static TCHAR * pDefault = { _T("Default") };

const TCHAR * ConvertState(int nState)
{
	switch (nState)
	{
	case _SERVICE_STATE_OFFLINE: return pOffLine;
		case _SERVICE_STATE_CREATE: return pCreate;
		case _SERVICE_STATE_ONLINE: return pOnline;
		case _SERVICE_STATE_TERMINATED: return pTerminated;

		default: return pDefault;
	}
	return NULL;
};

extern TServiceManagerConfig g_Config;
CServiceManager * g_pServiceManager = NULL;


#if defined (_SERVICEMANAGER_EX)
CServiceManager::CServiceManager(CServiceManagerExApp* pApp)
: m_pApp(pApp)
#else
CServiceManager::CServiceManager()
#endif // #if defined (_SERVICEMANAGER_EX)
{
	memset(m_szProcess, 0, sizeof(m_szProcess));
	m_UrlUpdater.UpdaterInit(g_Config.wszPatchBaseURL, g_Config.wszPatchURL);

	if (CDataManager::GetInstance()->LoadUser() == false)
	{
		g_Log.Log(LogType::_FILELOG, L"MonitorUser.xml LoadFail\n");
	}

	if (CDataManager::GetInstance()->LoadStruct() == false)
	{
		_ASSERT_EXPR(0, L"[CServiceManager] CDataManager::GetInstance()->LoadStruct() == false");
		return;
	}
	else
	{
		std::vector <int> vSIDList;
		CDataManager::GetInstance()->GetCommandList(&vSIDList);
		for (int i = 0; i < (int)vSIDList.size(); i++)
		{
			const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand(vSIDList[i]);
			if (MakeServiceList(pExe->nSID, pExe->nAssignedLauncherID, pExe->wszType) == false)
				_ASSERT_EXPR(0, L"[CServiceManager] MakeServiceList(pExe->nSID, pExe->nAssignedLauncherID, pExe->wszType) == false");
		}
	}

	MakeWorldList();

	char szNotice[256];
	WideCharToMultiByte(CP_ACP, 0, g_Config.wszNoticePath, -1, szNotice, 256, NULL, NULL);
	if (_access(szNotice, 0) != -1)
		m_ReservedNotice.LoadNotice(szNotice);

	std::string strCmd;
	strCmd = g_Config.szVersion;
	ToLowerA(strCmd);

	std::vector<std::string> tokens;
	TokenizeA(strCmd, tokens, ".");

	m_nMajorVersion = atoi(tokens[0].c_str());
	m_nMinorVersion = atoi(tokens[1].c_str());

	m_nPatchID = 0;
	m_nContainerVersion = 0;
	m_bCloseService = false;
	m_nTerminateDBTick = 0;

	m_bHttpSendFail = false;
	m_nHttpFailTick = 0;
	m_pStoredPacketBuffer = new (std::nothrow) CRawSpinBuffer( 1, 1024*1024*10 );
	m_nRunBatchID = 0;
	m_nStopBatchID = 0;

	m_CmdTable.lpFarmUpdate = CServiceManager::UpdateFarm;

	for (int i=0; i<SERVERTYPE_MAX; i++)
	{
		m_nLastMonitorReportedTick[i] = 0;
		m_vServerDelayMIDs[i].clear();
	}

#if defined(_KRAZ)
	g_pActozShield = new CDNActozShield;
	if (g_pActozShield)
		g_pActozShield->Init();
#endif	// #if defined(_KRAZ)
}

CServiceManager::~CServiceManager()
{
	ScopeLock <CSyncLock> sync(m_Sync);
	for (std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		SAFE_DELETE((*ii).second);
	m_LauncherSessionList.clear();

	for (std::map <UINT, CServiceSession*>::iterator ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		SAFE_DELETE((*ii).second);
	m_ServiceSessionList.clear();

	for (std::map <int, sServiceState*>::iterator ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
		SAFE_DELETE((*ii).second);
	m_ServiceList.clear();

	for (std::vector <CPatcherSession*>::iterator ii = m_vPatcherSessionList.begin(); ii != m_vPatcherSessionList.end(); ii++)
		SAFE_DELETE((*ii));
	m_vPatcherSessionList.clear();
	m_PatcherSessionList.clear();
	delete m_pStoredPacketBuffer;

#if defined(_KRAZ)
	SAFE_DELETE(g_pActozShield);
#endif	// #if defined(_KRAZ)
}

void CServiceManager::MakeRandomException()
{
	return;//rlkt_test

	switch (rand()%4)
	{
	case 0:
		{
			SendExceptionReport(1004, _EXCEPTIONTYPE_ROOMCRASH, NULL);
			break;
		}
	case 1:
		{
			SendExceptionReport(1004, _EXCEPTIONTYPE_SESSIONCRASH, NULL);
			break;
		}
	case 2:
		{
			SendExceptionReport(1004, _EXCEPTIONTYPE_ROOMDESTRUCTOR, NULL);
			break;
		}
	case 3:
		{
			SendExceptionReport(1000, _EXCEPTIONTYPE_DBMW_DELAYED, "DataBase MiddleWare Delayed Over 60Second");
			break;
		}
	}
}

void CServiceManager::IdleProcess()
{
	if (m_ServiceCloser.IdleProcess())
	{
		TerminateServiceAll();
		return;
	}

	m_ReservedNotice.IdleProcess();
	
	ScopeLock <CSyncLock> sync(m_Sync);

	ULONG nCurTick = timeGetTime();

	static int nCount = 0;
	if (nCount%12 == 0)
	{
		std::map <int, sServiceState*>::iterator ServiceItor;
		for (ServiceItor = m_ServiceList.begin(); ServiceItor != m_ServiceList.end(); ServiceItor++)
			SendPacketToGsm(_T("msg=PInfo,%d,%s"), (*ServiceItor).second->nSID, ConvertState((*ServiceItor).second->nState));
	}
	nCount++;

	std::map <int, sServiceState*>::iterator ServiceItor;
	for (ServiceItor = m_ServiceList.begin(); ServiceItor != m_ServiceList.end(); ServiceItor++)
	{
		if ((*ServiceItor).second->nState == _SERVICE_STATE_CREATE)
		{
			if ((*ServiceItor).second->nCreateTime > 0 && (*ServiceItor).second->nCreateTime + (5 * 60 * 1000) < nCurTick)
			{
				std::map <UINT, CServiceSession*>::iterator ii2;
				for (ii2 = m_ServiceSessionList.begin(); ii2 != m_ServiceSessionList.end(); ii2++)
				{
					if ((*ServiceItor).first == (*ii2).second->GetMID())
					{
						(*ii2).second->DetachConnection(L"CreateOverTime");
						break;
					}
				}
			}
		}
	}
	

	std::vector <int> vList;
	std::map <UINT, CServiceSession*>::iterator sessionitor;
	for (sessionitor = m_ServiceSessionList.begin(); sessionitor != m_ServiceSessionList.end(); sessionitor++)
	{
		if ((*sessionitor).second->IsCompleteConnected(nCurTick) == false)
		{
			(*sessionitor).second->DetachConnection(L"IncompleteConnect");
			continue;
		}
	}

	for (sessionitor = m_ServiceSessionList.begin(); sessionitor != m_ServiceSessionList.end(); sessionitor++)
	{
		if ((*sessionitor).second->GetType() == MANAGED_TYPE_VILLAGE)
		{
			int nServiceRet = (*sessionitor).second->IdleProcess(nCurTick);
			if (nServiceRet != SERVICEPROCESS_NONE)
			{
				vList.push_back((*sessionitor).second->GetMID());
				g_Log.Log(LogType::_ERROR, L"VillageServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());
				g_ExceptionReportLog.Log(LogType::_FILELOG, L"VillageServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());
			}
		}
		else if ((*sessionitor).second->GetType() == MANAGED_TYPE_GAME)
		{
			int nServiceRet = (*sessionitor).second->IdleProcess(nCurTick);
			if (nServiceRet == SERVICEPROCESS_NONE)
			{
			}
			else if (nServiceRet == SERVICEPROCESS_FAULTSAFE)
			{
				vList.push_back((*sessionitor).second->GetMID());
				g_Log.Log(LogType::_ERROR, L"GameServer FaultSafe SID[%d]\n", (*sessionitor).second->GetMID());
			}
			else if ((*sessionitor).second->GetLastReportTime() > 0 && (*sessionitor).second->GetLastReportTime() + (120 * 1000) < nCurTick)
			{
				if ((*sessionitor).second->GetLastDelayedTime() <= 0 || (*sessionitor).second->GetLastDelayedTime() + (120 * 1000) < nCurTick)
				{
					(*sessionitor).second->SetLastDelayedTime(timeGetTime());
					g_Log.Log(LogType::_ERROR, L"GameServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());
					g_ExceptionReportLog.Log(LogType::_FILELOG, L"GameServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());
				}

				if ((*sessionitor).second->GetLastReportTime() + (3 * 60 * 1000) < nCurTick)
					vList.push_back((*sessionitor).second->GetMID());
			}
		}
		else if ((*sessionitor).second->GetType() == MANAGED_TYPE_LOGIN)
		{
			(*sessionitor).second->IdleProcess(nCurTick);
			if ((*sessionitor).second->GetLastReportTime() > 0 && (*sessionitor).second->GetLastReportTime() + (120 * 1000) < nCurTick)
			{
				
				g_Log.Log(LogType::_ERROR, L"LoginServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());
				g_ExceptionReportLog.Log(LogType::_FILELOG, L"LoginServer Report Delayed Over120 Second SID[%d]\n", (*sessionitor).second->GetMID());

				(*sessionitor).second->SetLastDelayedTime(timeGetTime());
				if ((*sessionitor).second->GetLastDelayedTime() <= 0)
					MakeDumEach((*sessionitor).second->GetMID());

				else if ((*sessionitor).second->GetLastDelayedTime() + (2 * 60 * 1000) < nCurTick)
				{
					vList.push_back((*sessionitor).second->GetMID());
				}

			}
		}
	}

	for (int i = 0; i < (int)vList.size(); i++)
	{
		bool bterminateFalg = TerminateServiceEachForceAsync(vList[i]);
		if (bterminateFalg == false)
		{
			g_Log.Log(LogType::_FILELOG, L"Already Req Terminate [SID%d]\n", vList[i]);
			std::map <UINT, CServiceSession*>::iterator sitor;
			for (sitor = m_ServiceSessionList.begin(); sitor != m_ServiceSessionList.end(); sitor++)
			{
				if ((*sitor).second->GetMID() == vList[i])
				{
					g_Log.Log(LogType::_FILELOG, L"Detach Connection [SID%d]\n", (*sitor).second->GetMID());
					(*sitor).second->DetachConnection(L"TerminateForce FaultSafe");
					break;
				}
			}
		}
	}

	if (m_CloseServieList.size() > 0)
	{
		std::vector <_CLOSESERVICE>::iterator ii;
		for (ii = m_CloseServieList.begin(); ii != m_CloseServieList.end(); )
		{
			_CLOSESERVICE close = (*ii);
			if ((close.nTerminateTick > 0 && close.nTerminateTick + (_CLOSE_REPORTED_SERVICE_WAITING_TIME) < nCurTick) ||
				(close.nInsertTick + (_CLOSE_SERVICE_WAITING_TIME) < nCurTick))
			{
				std::map <int, sServiceState*>::iterator ih = m_ServiceList.find(close.nMID);
				if (ih != m_ServiceList.end())
				{
					sServiceState * pService = (*ih).second;
					std::map <UINT, CLauncherSession*>::iterator ij = m_LauncherSessionList.find(pService->nManagedLauncherID);
					if (ij != m_LauncherSessionList.end())
						(*ij).second->SendTerminateProcess(pService->nSID);
				}
				ii = m_CloseServieList.erase(ii);
			}
			else
				ii++;
		}

		if (m_CloseServieList.empty())
		{
			g_Log.Log(LogType::_FILELOG, L"AllService Close After Terminate Process OK\n");
			if (m_bCloseService)
			{
				g_Log.Log(LogType::_FILELOG, L"Terminate Process After DBServerClose Start\n");
				m_bCloseService = false;
				if (m_nTerminateDBTick <= 0)
					m_nTerminateDBTick = timeGetTime() + 10 * 1000;
			}
		}
	}

	if (m_nTerminateDBTick > 0 && m_nTerminateDBTick > nCurTick)
	{		
		TerminateServiceDB(NULL, true);
		m_nTerminateDBTick = 0;
		g_Log.Log(LogType::_FILELOG, L"Terminate Process After DBServerClose End\n");
		SendPacketToGsm(_T("msg=ServiceClose"));
	}

	std::map <UINT, CLauncherSession*>::iterator netItor;
	for (netItor = m_LauncherSessionList.begin(); netItor != m_LauncherSessionList.end(); netItor++)
	{
		if ((*netItor).second->GetPingTick() <= 0)
		{
			if ((*netItor).second->GetCreateTick() + (60 * 1000) < nCurTick)
			{
				StopEachLauncherAsync((*netItor).second->GetSessionID());
				break;
			}
			continue;
		}
		
		ULONG nGap = 0;
		if (nCurTick > (*netItor).second->GetPingTick())
			nGap = nCurTick - (*netItor).second->GetPingTick();
		else if (nCurTick < (*netItor).second->GetPingTick())
			nGap = (*netItor).second->GetPingTick() - nCurTick;
		
		if (nGap > (20 * 60 * 1000))
		{
			g_Log.Log(LogType::_ERROR, L"PingDelay [GAP:%d][Cur:%d][Ping:%d]\n", nGap, nCurTick, (*netItor).second->GetPingTick());
			(*netItor).second->DetachConnection(L"PingDelay");
		}
	}

	std::map <int, ULONG>::iterator testItor;
	if (m_LaunchetTestList.size() > 0)
	{
		for (testItor = m_LaunchetTestList.begin(); testItor != m_LaunchetTestList.end(); )
		{
			if (nCurTick > (*testItor).second + (30 * 1000))
			{
				g_Log.Log(LogType::_ERROR, L"NetLauncher ping return delayed [NID:%d]\n", (*testItor).first);
				testItor = m_LaunchetTestList.erase(testItor);
			}
			else
				testItor++;
		}
	}
	for (int i=0; i<SERVERTYPE_MAX; i++)
	{
		if (nCurTick > m_nLastMonitorReportedTick[i] + 3000)
		{
			ReportToMonitorServerDelay(i);
			m_nLastMonitorReportedTick[i] = nCurTick;
		}
	}
}

void CServiceManager::SyncTaskProcess()
{
	ScopeSpinBufferSwitch Scope( m_pStoredPacketBuffer );

	char * pBuffer = Scope.pGetBuffer();
	UINT uiSize	= Scope.uiGetSize();

	while(uiSize)
	{
		_SYNCGSMTASK * pTask = (_SYNCGSMTASK*)pBuffer;

		if (m_HttpUpdater.QueryPost(g_Config.wszGSMIP, NULL, NULL, g_Config.wszGSMCodePage, pTask->szMsg, pTask->nSize - sizeof(short)) == false)
		{
			m_bHttpSendFail = true;
			m_nHttpFailTick = timeGetTime();

			g_Log.Log(LogType::_FILELOG, L"GSM Send Error %S\n", pTask->szMsg);
		}

		uiSize -= pTask->nSize;
		pBuffer += pTask->nSize;
	}
}

CLauncherSession * CServiceManager::AddLauncherSession(const char * pIP, unsigned short nPort)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	int nID = CDataManager::GetInstance()->VerifyNetLauncher(_inet_addr(pIP));
	if (nID > 0)
	{
		if (m_LauncherSessionList.find(nID) != m_LauncherSessionList.end())
			return NULL;

		CLauncherSession * pSession = new CLauncherSession();
		pSession->SetSessionID(nID);
		pSession->SetIp(pIP);
		m_LauncherSessionList[nID] = pSession;

#if defined (_SERVICEMANAGER_EX)
		g_FileLog.Log(LogType::_FILELOG, "Connected NetLauncher IP[%s] Port[%d]\n", pIP, nPort);
#else
		printf("Connected NetLauncher IP[%s] Port[%d]\n", pIP, nPort);
#endif // #if defined (_SERVICEMANAGER_EX)
		SendPacketToGsm(_T("msg=NInfo,%d,Online"), pSession->GetSessionID());

		if (CDataManager::GetInstance()->GetLauncherCount() == (int)m_LauncherSessionList.size())
			g_Log.Log(LogType::_FILELOG, L"All Launcher Connected\n");

		return pSession;
	}
#if defined (_SERVICEMANAGER_EX)
	g_Log.Log(LogType::_NORMAL, "Connect Failed NetLauncher IP[%s] Port[%d]\n", pIP, nPort);
#else
	printf("Connect Failed NetLauncher IP[%s] Port[%d]\n", pIP, nPort);
#endif // #if defined (_SERVICEMANAGER_EX)
	return NULL;
}

CServiceSession * CServiceManager::AddServiceSession(const char * pIP, unsigned short nPort)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	int nID = CDataManager::GetInstance()->VerifyNetLauncher(_inet_addr(pIP));
	if (nID <= 0)		//<2F><><EFBFBD><EFBFBD><EFBFBD>ǰ<EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD>ǿ<EFBFBD><C7BF><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>常 <20>޽<EFBFBD><DEBD>ϴ<EFBFBD>.
		return NULL;	
	
	CServiceSession * pSession = new CServiceSession;
	if (pSession)
	{
		static int s_nID = 0;
		_ASSERT(m_ServiceSessionList.find(s_nID) == m_ServiceSessionList.end());
		pSession->SetSessionID(s_nID);
		pSession->SetIp(pIP);
		m_ServiceSessionList[s_nID] = pSession;
		s_nID++;
	}
	return pSession;
}

CPatcherSession * CServiceManager::AddPatcherSession(const char * pIP, unsigned short nPort)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (VerifyPatcher(pIP) == false) return NULL;

	int nID = CDataManager::GetInstance()->VerifyNetLauncher(_inet_addr(pIP));
	if (nID > 0)
	{
		if (m_PatcherSessionList.find(nID) != m_PatcherSessionList.end())
			return NULL;

		CPatcherSession * pSession = new CPatcherSession;
		if (!pSession) return NULL;

		pSession->SetSessionID(nID);
		pSession->SetIp(pIP);

		m_vPatcherSessionList.push_back(pSession);
		pSession->SetPatcherServiceID(nID);
		m_PatcherSessionList[nID] = pSession;

#if defined (_SERVICEMANAGER_EX)
		g_FileLog.Log(LogType::_FILELOG, "Connect NetLauncherPatcher Service IP[%s] Port[%d]\n", pIP, nPort);
#else
		printf("Connect NetLauncherPatcher Service IP[%s] Port[%d]\n", pIP, nPort);
#endif // #if defined (_SERVICEMANAGER_EX)

		if (CDataManager::GetInstance()->GetLauncherCount() == (int)m_PatcherSessionList.size())
			g_Log.Log(LogType::_FILELOG, L"All ESM Connected\n");
		return pSession;
	}
	//printf("Connect Failed UnManaged NetLauncherPatcher Service IP[%s] Port[%d]\n", pIP, nPort);
	return NULL;
}

CMonitorSession * CServiceManager::AddMonitorSession(const char * pIP, unsigned short nPort)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	CMonitorSession * pSession = new CMonitorSession;
	if (!pSession) return NULL;

	static int nMonitorID = 1;
	pSession->SetSessionID(nMonitorID++);
	pSession->SetIp(pIP);

	m_MonitorSessionList.push_back(pSession);

#if defined (_SERVICEMANAGER_EX)
	g_Log.Log(LogType::_NORMAL, "Connect MonitorSession IP[%s] Port[%d]\n", pIP, nPort);
#else
	printf("Connect MonitorSession IP[%s] Port[%d]\n", pIP, nPort);
#endif // #if defined (_SERVICEMANAGER_EX)
	return pSession;
}

bool CServiceManager::DelConnection(CConnection * pCon, eConnectionKey eConType)
{
	ScopeLock <CSyncLock> Lock(m_Sync);
	if (eConType == CONNECTIONKEY_LAUNCHER)
	{
		std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.find(pCon->GetSessionID());
		if (ii != m_LauncherSessionList.end())
		{
			CLauncherSession * pSession = (*ii).second;
			int nID = (*ii).second->GetSessionID();
			//DeleteManagedService(nID);
			m_LauncherSessionList.erase(ii);
			
			g_Log.Log(LogType::_NORMAL, L"NetLauncher DisConnected NID:[%d] IP:[%S]\n", nID, pCon->GetIp());
			m_PatchWatcher.DelWatchContent(nID);

			if (m_LauncherSessionList.size() <=0)
			{
				g_Log.Log(LogType::_FILELOG, L"All Launcher Disconnet\n");

				if (m_LivePatcher.IsStarted())
				{
					m_LivePatcher.CancelPatch();
					g_Log.Log(LogType::_ERROR, L"LivePatchFailed\n");
				}
			}

			return true;
		}
		_DANGER_POINT();
	}
	else if (eConType == CONNECTIONKEY_SERVICEMANAGER)
	{
		std::map <UINT, CServiceSession*>::iterator ii = m_ServiceSessionList.find(pCon->GetSessionID());
		if (ii != m_ServiceSessionList.end())
		{
			CServiceSession * pSession = (*ii).second;
			int nSID = 0;
			sServiceState * pState = GetServiceStateByServiceSession((*ii).second->GetSessionID());
			if (pState)
			{
				pState->Init();
				nSID = pState->nSID;
			}
			else  //pState<74><65> ã<><C3A3> <20><> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD> <20>ʴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ų<EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>Ų <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>. <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>α׳<CEB1><D7B3><EFBFBD>
				g_Log.Log(LogType::_FILELOG, L"[Session:%d, MID %d] DelConnection Failed\n",  pSession->GetSessionID(), pSession->GetMID());			

			if (m_AutoRestartList.size() > 0)
			{
				std::vector <int>::iterator ir;
				for (ir = m_AutoRestartList.begin(); ir != m_AutoRestartList.end(); )
				{
					if ((*ir) == nSID)
					{
						StartServiceEachAsync(nSID);
						ir = m_AutoRestartList.erase(ir);
					}
					else
						ir++;
				}
			}

			m_ServiceSessionList.erase(ii);
			SendPacketToGsm(_T("msg=PInfo,%d,Offline"), nSID);
			
			if (m_LivePatcher.IsStarted())
			{
				m_LivePatcher.CancelPatch();
				g_Log.Log(LogType::_ERROR, L"LivePatchFailed!!!!!!!!!!! Check Service!!!!!!\n");
			}

			if (m_ServiceSessionList.empty())
				g_Log.Log(LogType::_FILELOG, L"All Service Closed\n");

			return true;
		}
		_DANGER_POINT();
	}
	else if (eConType == CONNECTIONKEY_SERVICEPATCHER)
	{
		std::vector <CPatcherSession*>::iterator ii;
		for (ii = m_vPatcherSessionList.begin(); ii != m_vPatcherSessionList.end(); ii++)
		{
			if (pCon->GetSessionID() == (*ii)->GetSessionID())
			{
				std::map <UINT, CPatcherSession*>::iterator ih = m_PatcherSessionList.find((*ii)->GetPSID());
				if (ih != m_PatcherSessionList.end())
				{
					m_vPatcherSessionList.erase(ii);
					m_PatcherSessionList.erase(ih);
					return true;
				}
				return true;
			}
		}
		_DANGER_POINT();
	}
	else if (eConType == CONNECTIONKEY_SERVERMONITOR)
	{
		std::vector <CMonitorSession*>::iterator ii;
		for (ii = m_MonitorSessionList.begin(); ii != m_MonitorSessionList.end(); ii++)
		{
			if (pCon->GetSessionID() == (*ii)->GetSessionID())
			{
				m_MonitorSessionList.erase(ii);
				g_Log.Log(LogType::_NORMAL, L"ServiceMonitor Disconnected IP:[%S]\n", pCon->GetIp());
				return true;
			}
		}
	}
	return false;
}

void CServiceManager::ParseCommand(const char* pCmd, char* pRet)
{
	int nRet = g_pServiceManager->Parse(pCmd, pRet);
	if (nRet != 0)
		g_Log.Log(LogType::_ERROR, L"%s", nRet == -1 ? L"Argument Insufficiency\n" : L"Unkown Message\n");
	else if (strlen(pCmd) > 0)
		g_Log.Log(LogType::_NORMAL, L"ConsoleCmd [%S]\n", pCmd);
}

int CServiceManager::Parse(const char * pCmd, char * pRet)
{
	WCHAR wszTemp[2048];
	MultiByteToWideChar(CP_ACP, 0, pCmd, -1, wszTemp, 2048);

	std::wstring strCmd;
	strCmd = wszTemp;

	std::vector<std::wstring> wtokens;
	TokenizeW(strCmd, wtokens, L"|");

	std::vector<std::string> tokens;
	char szTemp[2048];
	for (int i = 0; i < (int)wtokens.size(); i++)
	{
		WideCharToMultiByte(CP_ACP, 0, wtokens[i].c_str(), -1, szTemp, 2048, NULL, NULL);
		std::string strTemp = szTemp;
		tokens.push_back(strTemp);
	}

	if (tokens.size() > 0)
	{
		if (!stricmp(tokens[0].c_str(), "makeselfdump"))
		{
			if (g_pServiceServer)
				g_pServiceServer->StoreMiniDump();
		}
		else if (!stricmp(tokens[0].c_str(), "testgsm"))
		{
			std::wstring wstrTemp;
			ToWideString(tokens[1], wstrTemp);

			g_pServiceManager->SendPacketToGsm(const_cast<TCHAR*>(wstrTemp.c_str()));
		}
		else if (!stricmp(tokens[0].c_str(), "reload"))
		{
			if (ReLoadStruct())
				SendUpdateNotice(SERVERMONITOR_UPDATENOTICE_SERVERINFO);
		}
		else if (!stricmp(tokens[0].c_str(),  "reloaduser")) ReLoadUser();
		else if (!stricmp(tokens[0].c_str(),  "resetclose")) ResetCloseService();
		else if (!stricmp(tokens[0].c_str(),  "start")) StartServiceAll(pRet);
		else if (!stricmp(tokens[0].c_str(),  "starteach"))
		{
			if (tokens.size() < 2)
				return -1;

			bool bForcePatch = false;
			if (tokens.size() > 2)
				bForcePatch = tokens[2] == "true" ? true : false;
			StartServiceEach(atoi(tokens[1].c_str()), bForcePatch, pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "starteachbylauncher"))
		{
			if (tokens.size() < 2)
				return -1;

			StartServiceEachbyLauncher(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopforce")) TerminateServiceForce(pRet);
		else if (!stricmp(tokens[0].c_str(),  "stopforceeach"))
		{
			if (tokens.size() <= 1)
				return -1;

			TerminateServiceEachForce(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopforceeachbylauncher"))
		{
			if (tokens.size() <= 1)
				return -1;

			TerminateServiceForceEachbyLauncher(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopall"))
		{
			if (tokens.size() <= 1)
				TerminateServiceAll(pRet);
			else
				TerminateServiceAll(pRet, atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "cancelstop")) CancelTerminateProcess();
		else if (!stricmp(tokens[0].c_str(),  "stopdb")) TerminateServiceDB(pRet);
		else if (!stricmp(tokens[0].c_str(),  "stopeach"))
		{
			if (tokens.size() <= 1)
				return -1;	

			TerminateServiceEach(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopeachbylauncher"))
		{
			if (tokens.size() <= 1)
				return -1;

			TerminateServiceEachbyLauncher(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchurl"))
		{
			if (tokens.size() <= 1)
				return -1;

			PatchUpdateUrl(tokens[1].c_str(), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchstruct")) PatchStruct(pRet);
		else if (!stricmp(tokens[0].c_str(),  "patchinfo"))
		{
			if (tokens.size() < 2)
				PatchInfo(0, pRet);
			else
				PatchInfo(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchsystem"))
		{
			if (tokens.size() < 2)
				PatchSystem(0, pRet);
			else
				PatchSystem(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchconfig"))
		{
			if (tokens.size() < 2)
				PatchConfig(0, pRet);
			else
				PatchConfig(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchexe"))
		{
			if (tokens.size() < 2)
				PatchExe(0, pRet);
			else
				PatchExe(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchfull"))
		{
			if (tokens.size() < 2)
				PatchFull(0, pRet);
			else
				PatchFull(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchapply")) PatchApply(pRet);
		else if (!stricmp(tokens[0].c_str(),  "infocopy"))
		{
			if (tokens.size() < 2)
				InfoCopy(0, pRet);
			else
				InfoCopy(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patch"))
		{
			if (tokens.size() <= 1)
				return -1;

			Patch(tokens[1].c_str(), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchdyncode")) PatchDyncode();
		//<2F>۾<EFBFBD> <20><>ü<EFBFBD><C3BC> ext<78><74>ġ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ϴ<EFBFBD> <20>߱<EFBFBD><DFB1><EFBFBD><EFBFBD><EFBFBD> ij<><C4B3><EFBFBD><EFBFBD>ġ<EFBFBD><C4A1> <20≯<EFBFBD><CCB8><EFBFBD> <20><><EFBFBD>߿<EFBFBD> <20>ʿ<EFBFBD><CABF><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Ǯ<> <20><><EFBFBD><EFBFBD>
		else if (!stricmp(tokens[0].c_str(), "patchcash")) PatchExt();
		else if (!stricmp(tokens[0].c_str(), "cancelpatchcash")) CancelExtPatch();
		else if (!stricmp(tokens[0].c_str(), "filelist"))
		{
			if (tokens.size() <= 1)
				return -1;

			RecvFileList(tokens[1].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "notice"))
		{
			if (tokens.size() <= 3)
				return -1;

			NoticeWorld(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), tokens[3].c_str());
		}
		else if (!stricmp(tokens[0].c_str(), "noticeall"))
		{
			if (tokens.size() <= 2)
				return -1;

			NoticeWholeWorld(atoi(tokens[1].c_str()), tokens[2].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "noticechannel"))
		{
			if (tokens.size() <= 4)
				return -1;

			NoticeChannel(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), atoi(tokens[3].c_str()), tokens[4].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "noticeserver"))
		{
			if (tokens.size() <= 4)
				return -1;

			NoticeServer(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), atoi(tokens[3].c_str()), tokens[4].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "noticezone"))
		{
			if (tokens.size() <= 4)
				return -1;

			NoticeZone(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), atoi(tokens[3].c_str()), tokens[4].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "cancelnotice"))
		{
			if (tokens.size() < 2)
				return -1;

			NoticeCancel(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "worldmaxuser"))
		{
			if (tokens.size() < 3)
				return -1;

			WorldMaxuserControl(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "channelcontrol"))
		{
			if (tokens.size() < 4)
				return -1;
			int nChannelPopulation = tokens.size() == 5 ? atoi(tokens[4].c_str()) : -1;
			bool bIsOpen = !stricmp(tokens[3].c_str(), "true");
			ChannelControl(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), bIsOpen, nChannelPopulation);
		}
		else if (!stricmp(tokens[0].c_str(),  "populationcontrol"))
		{
			if (tokens.size() <= 3)
				return -1;
			PopulationControl(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), tokens[3] == "true" ? true : false);
		}
		else if (!stricmp(tokens[0].c_str(),  "affinitycontrol"))
		{
			if (tokens.size() <= 3)
				return -1;
			GameAffinityControl(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), atoi(tokens[3].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "eventupdate")) EventUpdate();
		else if (!stricmp(tokens[0].c_str(), "configupdate")) SimpleConfigUpdate();
		else if (!stricmp(tokens[0].c_str(),  "makedumpall")) MakeDumpAll();
		else if (!stricmp(tokens[0].c_str(),  "makedumpeach"))
		{
			if (tokens.size() <= 1)
				return -1;
			MakeDumEach(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "reservenotice"))
		{
			if (tokens.size() <= 1)
				return -1;
			ReserveNoticeUpdate(tokens[1].c_str(), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "userban"))
		{
			if (tokens.size() <= 1)
				return -1;
			UserBanbyCharacterName(tokens[1].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "userbanid"))
		{
			if (tokens.size() <= 1)
				return -1;
			UserBanbyAccountDBID(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "restraint"))
		{
			if (tokens.size() <= 1)
				return -1;
			UserRestraint(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "startlauncher")) StartLauncher(pRet);
		else if (!stricmp(tokens[0].c_str(),  "stoplauncher")) StopLauncher(pRet);
		else if (!stricmp(tokens[0].c_str(),  "starteachlauncher"))
		{
			if (tokens.size() < 2)
				return -1;

			StartEachLauncher(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopeachlauncher"))
		{
			if (tokens.size() < 2)
				return -1;

			StopEachLauncher(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "patchlauncher")) PatchNetLauncher(pRet);
		else if (!stricmp(tokens[0].c_str(),  "patchlaunchereach"))
		{
			if (tokens.size() < 2)
				return -1;

			PatchNetLauncherEach(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "checkpatch")) CheckPatch();
		else if (!stricmp(tokens[0].c_str(),  "clearpatch")) Clearpatch();
		else if (!stricmp(tokens[0].c_str(),  "checklauncher"))
		{
			if (tokens.size() < 2)
				CheckNetLauncher();
			else
				CheckNetLauncher(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "testlauncher"))
		{
			TestLauncher(0);
		}
		else if (!stricmp(tokens[0].c_str(),  "checktestlauncher")) CheckTestLauncher();
                else if (!stricmp(tokens[0].c_str(),  "reloaddyncode")) ReloadDyncode();
		else if (!stricmp(tokens[0].c_str(),  "checkalivelauncher")) CheckAliveNetLauncher();
		else if (!stricmp(tokens[0].c_str(),  "selectjoin"))
		{
			if (tokens.size() < 4)
				return -1;
			
			std::wstring szWStr;
			ToWideString(tokens[3], szWStr);

			SelectJoin(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), szWStr.c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "clearselectjoin"))
		{
			if (tokens.size() < 2)
				return -1;

			ClearSelectJoin(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "updatesale")) UpdateSaleData();
		else if (!stricmp(tokens[0].c_str(),  "patchbatch"))
		{
			if (tokens.size() < 2)
				PatchBatch(0, pRet);
			else
				PatchBatch(atoi(tokens[1].c_str()), pRet);
		}	
		else if (!stricmp(tokens[0].c_str(),  "runbatch"))  RunBatch(0, pRet);
		else if (!stricmp(tokens[0].c_str(),  "runbatcheach"))
		{
			if (tokens.size() <= 1)
				return -1;

			RunBatch(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "stopbatch"))  
		{
			if (tokens.size() < 2)
				StopBatch(0, pRet);
			else
				StopBatch(atoi(tokens[1].c_str()), pRet);
		}
		else if (!stricmp(tokens[0].c_str(),  "checkbatch"))
		{
			if (tokens.size() < 2)
				CheckBatch();
			else
				CheckBatch(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "userbanfile"))
		{
			if (tokens.size() < 2)
				return -1;

			UpdateBanFile(tokens[1].c_str());
		}
		else if (!stricmp(tokens[0].c_str(),  "farmupdate"))
		{
			if (pRet == NULL)
			ReqUpdateFarm();
		}
		else if (!stricmp(tokens[0].c_str(), "farmupdated"))
		{
		}
		else if (!stricmp(tokens[0].c_str(), "farmstart"))
		{
			StartFarm();
		}
		else if (!stricmp(tokens[0].c_str(),  "guildwarupdate"))
		{
			UpdateGuildWarSchedule();
		}
		else if (!stricmp(tokens[0].c_str(),  "createdb"))
		{
			if (tokens.size() < 2)
				return -1;
			else
				SendCreatEachDB(atoi(tokens[1].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(), "reloadguildwar"))
		{
			if (tokens.size() >= 2)
				SendReloadGuildwar(atoi(tokens[1].c_str()));
			else
				SendReloadGuildwar(0);
		}
		else if (!stricmp(tokens[0].c_str(), "changelimitmax"))
		{
			if (tokens.size() < 3)
				return -1;

			SendChangeLimiteItemMax(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()));
		}
		else if (!stricmp(tokens[0].c_str(),  "refreshguildware"))
		{
			if (tokens.size() < 2)
				return -1;
			else
				SendUpdateGuildWare(atoi(tokens[1].c_str()));
		}		
		else if (!stricmp(tokens[0].c_str(),  "patchesm"))
			PatchESM(0, pRet);
		else if (!stricmp(tokens[0].c_str(), "startesm"))
			StartESM();
		else if (!stricmp(tokens[0].c_str(), "stopesm"))
			StopESM();
		else if (!stricmp(tokens[0].c_str(),  "updateworldpvproom"))
		{			
			SendUpdateWorldPvPRoom();
		}		
		else if (!stricmp(tokens[0].c_str(),  "creategambleroom"))
		{			
			if (tokens.size() < 4)
				return -1;
			
			SendCreateGambleRoom(atoi(tokens[1].c_str()), atoi(tokens[2].c_str()), atoi(tokens[3].c_str()), atoi(tokens[4].c_str()) );			
		}
		else if (!stricmp(tokens[0].c_str(),  "stopgambleroom"))
		{	
			SendStopGambleRoom();
		}
		else if (!stricmp(tokens[0].c_str(),  "delgambleroom"))
		{	
			SendDelGambleRoom();
		}
		else if (!stricmp(tokens[0].c_str(),  "updatedwcstatus"))
		{
			SendUpdateDWCStatus();
		}
		else
			return -2;
		return 0;
	}
	return 0;
}

bool CServiceManager::ReLoadStruct()
{
	ScopeLock <CSyncLock> sync(m_Sync);	

	if (CDataManager::GetInstance()->LoadStruct() == false)
	{
		g_Log.Log(LogType::_FILELOG, L"DataLoad Failed\n");
		return false;
	}
	else
	{
		ClearList();
		std::vector <int> vSIDList;
		CDataManager::GetInstance()->GetCommandList(&vSIDList);
		for (int i = 0; i < (int)vSIDList.size(); i++)
		{
			const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand(vSIDList[i]);
			if (pExe)
			{
				CServiceSession * pServiceSession = NULL;
				std::map <UINT, CServiceSession*>::iterator sessionitor;
				for (sessionitor = m_ServiceSessionList.begin(); sessionitor != m_ServiceSessionList.end(); sessionitor++)
				{
					if ((*sessionitor).second->GetMID() == pExe->nSID)
						pServiceSession = (*sessionitor).second;
				}

				if (MakeServiceList(pExe->nSID, pExe->nAssignedLauncherID, pExe->wszType, pServiceSession == NULL ? false : true) == false)
					_ASSERT_EXPR(0, L"[ReLoadStruct] Fail MakeServiceList");
			}
		}

		MakeWorldList();

		std::map <UINT, CLauncherSession*>::iterator ii;
		for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		{
			std::vector <TServerExcuteData> vExeList;
			CDataManager::GetInstance()->GetExeCommandList((*ii).second->GetSessionID(), &vExeList);
			bool bOther = CDataManager::GetInstance()->IsNeedOtherExcutePath((*ii).second->GetSessionID());
			(*ii).second->SendManagingExeItem(&vExeList, bOther);

			std::list <char> lList;
			CDataManager::GetInstance()->GetAssingedPatchTypeList((*ii).second->GetSessionID(), &lList);
			(*ii).second->SendConnectedResult(&lList, g_Config.wszPatchBaseURL, g_Config.wszPatchURL);
		}

		std::map <UINT, CPatcherSession*>::iterator ih;
		for (ih = m_PatcherSessionList.begin(); ih != m_PatcherSessionList.end(); ih++)
			(*ih).second->SendConnectedResult(g_Config.wszPatchBaseURL, g_Config.wszPatchURL);		

		g_Log.Log(LogType::_FILELOG, L"ReDataLoad OK\n");
		m_nContainerVersion++;
	}
	return true;
}

bool CServiceManager::ReLoadUser()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (CDataManager::GetInstance()->LoadUser())
		return true;

	g_Log.Log(LogType::_ERROR, L"MonitorUser.xml Load Failed\n");
	return false;
}

int CServiceManager::CheckMonitorLogin(const char * pID, const char * pPass, int & nMonitorLevel, TP_SMVERSION Version)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (GET_SM_VERSION() != Version) return ERROR_SM_LOGINFAIL_VERSIONUNMATCHED;

	bool bDuplicate = false;
	int nTempMonitorLevel = SERVERMONITOR_LEVEL_NONE;
	nMonitorLevel = SERVERMONITOR_LEVEL_NONE;

	bool bRet = CDataManager::GetInstance()->CheckMonitorUser(pID, pPass, nTempMonitorLevel, bDuplicate);
	if (bRet && bDuplicate == false)		//<2F>ߺ<EFBFBD><DFBA>α<EFBFBD><CEB1><EFBFBD> <20>Ұ<EFBFBD><D2B0><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE>
	{
		if (strcmp("eyeadmin", pID))
		{
			std::vector <CMonitorSession*>::iterator ii;
			for (ii = m_MonitorSessionList.begin(); ii != m_MonitorSessionList.end(); ii++)
			{
				if (!strcmp((*ii)->GetMonitorID(), "eyeadmin")) continue;
				if ((*ii)->GetMonitorLevel() == nTempMonitorLevel)
					return ERROR_SM_LOGINFAIL_LEVEL_DUPLICATED;
			}
		}
	}
	nMonitorLevel = nTempMonitorLevel;
	return bRet == true ? ERROR_NONE : ERROR_SM_LOGINFAIL;
}

void CServiceManager::CalcPageSize(int &nFirst, int &nLast, BYTE cOffSet, BYTE cPageNum, int nMaxSize, int nWholeCount)
{
	int nLastPageNum = nWholeCount/((cOffSet <= 0 || cOffSet > nMaxSize) ? nMaxSize : cOffSet);
	cPageNum = nLastPageNum < cPageNum ? nLastPageNum : cPageNum;

	nFirst = cPageNum * cOffSet;
	nLast = nFirst + cOffSet;
}

void CServiceManager::SendExceptionReport(int nSID, int nExceptionType, const char * pDetail)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	ReportToMonitorServiceState(nSID, _SERVICE_STATE_ONLINE, nExceptionType, pDetail);
	SendPacketToGsm(_T("msg=pInfo,%d,Exception,%d"), nSID, nExceptionType);
}

void CServiceManager::SendUpdateNotice(int nNotice)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::vector <CMonitorSession*>::iterator im;
	for (im = m_MonitorSessionList.begin(); im != m_MonitorSessionList.end(); im++)
		(*im)->SendUpdateNotice(nNotice);
}

int CServiceManager::GetMeritList(int nContainerVersion, int nLastRecvID, BYTE & cIsLast, short & cCount, sMonitorChannelMeritInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;
	nWholeCount = (int)m_ChannelMerit.size();
	if (nWholeCount <= 0) return 0;
	if (GetContainerVersion() != nContainerVersion) return nWholeCount;

	std::map <int, TMeritInfo>::iterator ii;
	//ii = nLastRecvID <= 0 ? m_ChannelMerit.begin() : m_ChannelMerit.find(nLastRecvID);
	if (nLastRecvID <= 0)
		ii = m_ChannelMerit.begin();
	else
	{
		ii = m_ChannelMerit.find(nLastRecvID);
		if (ii == m_ChannelMerit.end()) return nWholeCount;
		ii++;
	}
	if (ii == m_ChannelMerit.end()) return nWholeCount;

	for (cCount = 0; ii != m_ChannelMerit.end(); ii++, cCount++)
	{
		if (cCount >= _MERITSEND_CALCSIZE || cCount >= nDestCountMax) break;
		TMeritInfo * pMeritInfo = &(*ii).second;
		pInfo[cCount].nID = pMeritInfo->nID;
		pInfo[cCount].nMeritType = pMeritInfo->nMeritType;
		pInfo[cCount].nExtendValue = pMeritInfo->nExtendValue;
		pInfo[cCount].nMinLevel = pMeritInfo->nMinLevel;
		pInfo[cCount].nMaxLevel = pMeritInfo->nMaxLevel;
	}

	cIsLast = m_ChannelMerit.end() == ii ? 1 : 0;

	return nWholeCount;
}

int CServiceManager::GetNetLauncherList(int nContainerVersion, int nLastRecvLauncherID, BYTE & cIsLast, short & cCount, sMonitorNetLauncherInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;
	std::map <int, TNetLauncherInfo> vList;
	std::map <int, TNetLauncherInfo>::iterator ii;
	CDataManager::GetInstance()->GetLauncherIds(&vList);
	
	nWholeCount = (int)vList.size();
	if (nWholeCount <= 0) return 0;
	if (GetContainerVersion() != nContainerVersion) return nWholeCount;

	//ii = nLastRecvLauncherID <= 0 ? vList.begin() : vList.find(nLastRecvLauncherID);
	if (nLastRecvLauncherID <= 0)
		ii = vList.begin();
	else
	{
		ii = vList.find(nLastRecvLauncherID);
		if (ii == vList.end()) return nWholeCount;
		ii++;
	}
	if (ii == vList.end()) return nWholeCount;

	for (cCount = 0; ii != vList.end(); ii++, cCount++)
	{
		if (cCount > _NETLAUNCHER_CALCSIZE || cCount >= nDestCountMax) break;
		TNetLauncherInfo * pNLInfo = &(*ii).second;
		pInfo[cCount].nID = pNLInfo->nNID;
		STRCPYW(pInfo[cCount].wszIP, IPLENMAX, pNLInfo->wszIP);
		STRCPYW(pInfo[cCount].wszPublicIP, IPLENMAX, pNLInfo->wszPublicIP);
	}

	cIsLast = vList.end() == ii ? 1 : 0;

	return nWholeCount;
}

int CServiceManager::GetServerList(int nContainerVersion, int nLastRecvSID, BYTE & cIsLast, short & cCount, sMonitorServerInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	nWholeCount = (int)m_ServiceList.size();
	if (nWholeCount <= 0) return 0;
	if (GetContainerVersion() != nContainerVersion) return nWholeCount;

	std::map <int, sServiceState*>::iterator ii;
	//ii = nLastRecvSID <= 0 ? m_ServiceList.begin() : m_ServiceList.find(nLastRecvSID);
	if (nLastRecvSID <= 0)
		ii = m_ServiceList.begin();
	else
	{
		ii = m_ServiceList.find(nLastRecvSID);
		if (ii == m_ServiceList.end()) return nWholeCount;
		ii++;
	}
	if (ii == m_ServiceList.end()) return nWholeCount;

	for (cCount = 0; ii != m_ServiceList.end(); ii++, cCount++)
	{
		if (cCount >= _SERVERINFO_CALCSIZE || cCount >= nDestCountMax) break;

		pInfo[cCount].nSID = (*ii).second->nSID;
		pInfo[cCount].nManagedLauncherID = (*ii).second->nManagedLauncherID;
		pInfo[cCount].nServerState = (*ii).second->nState;
		WideCharToMultiByte(CP_ACP, 0, (*ii).second->szType, -1, pInfo[cCount].szType, NAMELENMAX, NULL, NULL);
		pInfo[cCount].nServerType = GetServerType((*ii).second->szType);
		STRCPYA(pInfo[cCount].szResourceRevision, 32, (*ii).second->szResource);
		STRCPYA(pInfo[cCount].szExeVersion, SERVERVERSIONMAX, (*ii).second->szVersion);
		memcpy(pInfo[cCount].cWorldIDs, (*ii).second->cWorldIDs, sizeof(pInfo[cCount].cWorldIDs));
	}

	cIsLast = m_ServiceList.end() == ii ? 1 : 0;

	return nWholeCount;
}

int CServiceManager::GetChannelList(int nContainerVersion, INT64 nLastRecvCHID, BYTE & cIsLast, short & cCount, sMonitorChannelInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	nWholeCount = (int)m_ChannelList.size();
	if (nWholeCount <= 0) return 0;
	if (GetContainerVersion() != nContainerVersion) return nWholeCount;

	std::map <INT64, tMonitorChannelInfo>::iterator ii;
	//ii = nLastRecvCHID <= 0 ? m_ChannelList.begin() : m_ChannelList.find(nLastRecvCHID);
	if (nLastRecvCHID <= 0)
		ii = m_ChannelList.begin();
	else
	{
		ii = m_ChannelList.find(nLastRecvCHID);
		if (ii == m_ChannelList.end()) return nWholeCount;
		ii++;
	}
	if (ii == m_ChannelList.end()) return nWholeCount;

	for (cCount = 0; ii != m_ChannelList.end(); ii++, cCount++)
	{
		if (cCount >= _CHANNEL_CALCSIZE || cCount >= nDestCountMax) break;

		tMonitorChannelInfo * pChInfo = &(*ii).second;
		pInfo[cCount].nSID = pChInfo->nManagedID;
		pInfo[cCount].nWorldID = pChInfo->nWorldID;
		pInfo[cCount].nChannelID = pChInfo->Info.nChannelID;
		pInfo[cCount].nMapIdx = pChInfo->Info.nMapIdx;
		pInfo[cCount].nMaxUserCount = pChInfo->Info.nMaxUserCount;
		pInfo[cCount].nChannelAttribute = pChInfo->Info.nChannelAttribute;
		CDataManager::GetInstance()->GetChannelMapName(pChInfo->Info.nMapIdx, pInfo[cCount].wszMapName);
	}

	cIsLast = m_ChannelList.end() == ii ? 1 : 0;

	return nWholeCount;
}

bool CServiceManager::GetMangedIDList(std::vector <int> &vList)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		int nMID = (*ii).second->GetMID();
		vList.push_back(nMID);
	}
	return true;
}

int CServiceManager::GetWorldInfo(int nContainerVersion, BYTE & cCount, sMonitorWorldInfo * pInfo)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sMonitorWorldInfo>::iterator ii;
	for (ii = m_WorldInfo.begin(); ii != m_WorldInfo.end(); ii++)
		memcpy(&pInfo[cCount++], &(*ii).second, sizeof(sMonitorWorldInfo));

	return (int)m_WorldInfo.size();
}

int CServiceManager::GetLoginUpdateList(int nLastRecvLoginSID, BYTE & cIsLast, short & nCount, sUserCountInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	std::map <UINT, int> TempSIDList;
	std::map <UINT, int>::iterator ii;
	
	nWholeCount = GetServiceCount(MANAGED_TYPE_LOGIN, &TempSIDList);
	if (nWholeCount <= 0) return 0;

	//ii = nLastRecvLoginSID <= 0 ? TempSIDList.begin() : TempSIDList.find(nLastRecvLoginSID);
	if (nLastRecvLoginSID <= 0)
		ii = TempSIDList.begin();
	else
	{
		ii = TempSIDList.find(nLastRecvLoginSID);
		if (ii == TempSIDList.end()) return nWholeCount;
		ii++;
	}
	if (ii == TempSIDList.end()) return nWholeCount;
	
	std::map <UINT, CServiceSession*>::iterator ih;
	for (int i = 0; ii != TempSIDList.end(); ii++, i++)
	{
		if (nCount >= _LOGINUPDATE_CALCSIZE || nCount >= nDestCountMax) break;

		for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
		{
			if ((*ih).second->GetMID() == (*ii).first)
			{
				pInfo[nCount].nSID = (*ih).second->GetMID();
				pInfo[nCount].nUserCount = (*ih).second->m_nLoginUserCount;
				nCount++;
			}
		}
	}

	cIsLast = TempSIDList.end() == ii ? 1 : 0;

	return nWholeCount;
}

int CServiceManager::GetVillageUpdateList(INT64 nLastRecvCHID, BYTE & cIsLast, BYTE & cCount, sChannelUpdateInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	nWholeCount = (int)m_ChannelList.size();
	if (nWholeCount <= 0) return 0;

	std::map <INT64, tMonitorChannelInfo>::iterator ii;
	//ii = nLastRecvCHID <= 0 ? m_ChannelList.begin() : m_ChannelList.find(nLastRecvCHID);
	if (nLastRecvCHID <= 0)
		ii = m_ChannelList.begin();
	else
	{
		ii = m_ChannelList.find(nLastRecvCHID);
		if (ii == m_ChannelList.end()) return nWholeCount;
		ii++;
	}
	if (ii == m_ChannelList.end()) return nWholeCount;

	for (cCount = 0; ii != m_ChannelList.end(); ii++, cCount++)
	{
		if (cCount >= _VILLAGEUPDATE_CALCSIZE || cCount >= nDestCountMax) break;

		tMonitorChannelInfo * pChInfo = &(*ii).second;
		pInfo[cCount].nSID = pChInfo->nManagedID;
		pInfo[cCount].bShow = pChInfo->Info.bShow;
		pInfo[cCount].bVisibility = pChInfo->Info.bVisibility;
		pInfo[cCount].nChannelID = pChInfo->Info.nChannelID;
		pInfo[cCount].nChannelUserCount = pChInfo->Info.nCurrentUserCount;
		pInfo[cCount].nLimitLevel = pChInfo->Info.nLimitLevel;
		pInfo[cCount].nMeritBonusID = pChInfo->Info.nMeritBonusID;
		pInfo[cCount].nServerID = pChInfo->Info.nServerID;
		pInfo[cCount].cThreadID = pChInfo->Info.cThreadID;
	}

	cIsLast = m_ChannelList.end() == ii ? 1 : 0;

	return nWholeCount;
}


int CServiceManager::GetGameUpdateList(int nLastRecvGameSID, BYTE & cIsLast, short & nCount, sGameUserInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	std::map <UINT, int> TempSIDList;
	std::map <UINT, int>::iterator ii;
	
	nWholeCount = GetServiceCount(MANAGED_TYPE_GAME, &TempSIDList);
	if (nWholeCount <= 0) return 0;

	//ii = nLastRecvGameSID <= 0 ? TempSIDList.begin() : TempSIDList.find(nLastRecvGameSID);
	if (nLastRecvGameSID <= 0)
		ii = TempSIDList.begin();
	else
	{
		ii = TempSIDList.find(nLastRecvGameSID);
		if (ii == TempSIDList.end()) return nWholeCount;
		ii++;
	}
	if (ii == TempSIDList.end()) return nWholeCount;
	
	std::map <UINT, CServiceSession*>::iterator ih;
	for (int i = 0; ii != TempSIDList.end(); ii++, i++)
	{
		if (nCount >= _GAMEUPDATE_CALCSIZE || nCount >= nDestCountMax) break;

		for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
		{
			if ((*ih).second->GetMID() == (*ii).first)
			{
				pInfo[nCount].nSID = (*ih).second->GetMID();
				pInfo[nCount].nUserCount = (*ih).second->m_nGameUserCount;
				pInfo[nCount].cIsOpened = (*ih).second->m_bZeroPopulation == true ? false : true;
				pInfo[nCount].nRoomCount = (*ih).second->m_nGameRoomCount;
				pInfo[nCount].nTotalRoomCount = (*ih).second->m_nTotalRoomCount;
				nCount++;
			}
		}
	}

	cIsLast = TempSIDList.end() == ii ? 1 : 0;

	return nWholeCount;
}


void CServiceManager::GetFarmUpdateList(short nFarmCount, short & nCount, TFarmStatus * pInfo, int nDestCountMax)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	bool bAddFarm = false;
	nCount = 0;

	for (int i=0; i<WORLDCOUNTMAX; i++)
	{
		std::map <int, std::vector<TFarmStatus>>::iterator managed_itor;
		for (managed_itor = m_FarmStatus[i].begin(); managed_itor != m_FarmStatus[i].end(); managed_itor++)
		{
			std::vector<TFarmStatus>::iterator farm_itor = managed_itor->second.begin();
			for (; farm_itor != managed_itor->second.end(); farm_itor++)
			{
				TFarmStatus& pStatus = *farm_itor;
			
				nFarmCount--;

				if (pStatus.nFarmDBID > 0 && nFarmCount < 0)
				{
					if (nCount >= _FARMUPDATE_CALCSIZE || nCount >= nDestCountMax) break;

					pInfo[nCount].bActivate = pStatus.bActivate;
					pInfo[nCount].nFarmDBID = pStatus.nFarmDBID;
					pInfo[nCount].nManagedID = pStatus.nManagedID;
					pInfo[nCount].nFarmCurUserCount = pStatus.nFarmCurUserCount;
					nCount++;
				}
			}
		}
	}
}


int CServiceManager::GetServerStateList(int nLastRecvSID, BYTE & cIsLast, short & nCount, sServerStateInfo * pInfo, int nDestCountMax)
{
	int nWholeCount;
	ScopeLock <CSyncLock> sync(m_Sync);

	cIsLast = 1;

	nWholeCount = (int)m_ServiceList.size();

	std::map <int, sServiceState*>::iterator ii;
	//ii = nLastRecvSID <= 0 ? m_ServiceList.begin() : m_ServiceList.find(nLastRecvSID);
	if (nLastRecvSID <= 0)
		ii = m_ServiceList.begin();
	else
	{
		ii = m_ServiceList.find(nLastRecvSID);
		if (ii == m_ServiceList.end()) return 0;
		ii++;
	}
	if (ii == m_ServiceList.end()) return 0;

	for (int i = 0; ii != m_ServiceList.end(); ii++, i++)
	{
		if (nCount >= _SERVERSTATE_CALCSIZE || nCount >= nDestCountMax) break;

		pInfo[nCount].nServerState = (*ii).second->nState;
		pInfo[nCount].nSID = (*ii).second->nSID;

		nCount++;
	}

	cIsLast = m_ServiceList.end() == ii ? 1 : 0;

	return nWholeCount;
}

#include "GsmCmdProcess.h"
int CServiceManager::StartServiceAll(char * pMsg)
{
	if (IsCloseService(0))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		if (pMsg) strcpy(pMsg, "Terminate Process Busy");
		return ERROR_SM_TERMINATE_BUSY;
	}

	//Start Service Batch Flow
	ScopeLock <CSyncLock> sync(m_Sync);

	if (m_LauncherSessionList.size() != CDataManager::GetInstance()->GetLauncherCnt())
	{
		std::vector <TNetLauncherInfo> vList;
		CDataManager::GetInstance()->GetLauncherIds(&vList);

		std::map <UINT, CLauncherSession*>::iterator itorlauncher;
		for (itorlauncher = m_LauncherSessionList.begin(); itorlauncher != m_LauncherSessionList.end(); itorlauncher++)
		{
			std::vector <TNetLauncherInfo>::iterator itorv;
			for (itorv = vList.begin(); itorv != vList.end(); )
			{
				if ((*itorv).nNID == (*itorlauncher).second->GetSessionID())
					itorv = vList.erase(itorv);
				else
					itorv++;
			}
		}

		for (int i = 0; i < (int)vList.size(); i++)
			g_Log.Log(LogType::_FILELOG, L"Launcher Connection Insufficiency NID[%d] NIP[%s]\n", vList[i].nNID, vList[i].wszIP);
		if (pMsg) strcpy(pMsg, "StartServiceAll Failed Launcher Connection Insufficiency");
		return ERROR_SM_NETLAUNCHER_INSUFFISIENCY;
	}

	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
		(*ih).second->SendInfoCopy(CDataManager::GetInstance()->IsNeedOtherExcutePath((*ih).first));

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if ((*ii).second->nState == _SERVICE_STATE_OFFLINE || (*ii).second->nState == _SERVICE_STATE_TERMINATED)
		{
			const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand((*ii).second->nSID);
			if (pExe)
				ExcuteProcess(pExe);
			else
			{
				g_Log.Log(LogType::_FILELOG, L"StartServiceAll Failed SID[%d]\n", (*ii).second->nSID);
				if (pMsg) strcpy(pMsg, "StartServiceAll Failed");
			}
		}
	}

	g_Log.Log(LogType::_FILELOG, L"StartServiceAll OK\n");
	if (pMsg) strcpy(pMsg, "StartServiceAll OK");
	return ERROR_NONE;
}

int CServiceManager::StartServiceEach(int nSID, bool bForcePatch, char * pMsg)
{
	if (IsCloseService(nSID))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		if (pMsg) strcpy(pMsg, "Terminate Process Busy");
		return ERROR_SM_TERMINATE_BUSY;
	}

	ScopeLock <CSyncLock> sync(m_Sync);
	
	bool bRet = false;
	const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand(nSID);
	if (pExe)
		bRet = ExcuteProcess(pExe, bForcePatch);

	if (bRet)
	{
		g_Log.Log(LogType::_FILELOG, L"StartServiceEach OK\n");
		if (pMsg) strcpy(pMsg, "StartServiceEach OK");
		return ERROR_NONE;
	}
	else
	{
		g_Log.Log(LogType::_FILELOG, L"StartServiceEach Failed\n");
		if (pMsg) strcpy(pMsg, "StartServiceEach Failed");
		return ERROR_SM_STARTEACH_FAILED;
	}
	return ERROR_NONE;
}

int CServiceManager::StartServiceEachbyLauncher(int nNID, char * pMsg)
{
	CLauncherSession * pSession = NULL;

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
	{
		if ((*ih).second->GetSessionID() == nNID)
		{
			pSession = (*ih).second;
			break;
		}
	}

	if (pSession == NULL)
	{
		g_Log.Log(LogType::_FILELOG, L"NetLauncher not Found\n");
		if (pMsg) strcpy(pMsg, "NetLauncher not Found");
		return ERROR_SM_SELECTED_NETLAUNCHER_NOTFOUND;
	}

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand((*ii).second->nSID);
		if (pExe)
		{
			if (pExe->nAssignedLauncherID == nNID)
				ExcuteProcess(pExe);
		}
	}
	return ERROR_NONE;
}

void CServiceManager::ResetCloseService(char * pMsg)
{
	m_Sync.Lock();

	std::vector <_CLOSESERVICE>::iterator ii;
	for (ii = m_CloseServieList.begin(); ii != m_CloseServieList.end(); )
		ii = m_CloseServieList.erase(ii);
	m_CloseServieList.clear();

	m_Sync.UnLock();
}


int CServiceManager::TerminateServiceForce(char * pMsg)
{
	m_Sync.Lock();

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		std::map <UINT, CLauncherSession*>::iterator ih;
		for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
			(*ih).second->SendTerminateProcess((*ii).second->nSID);
	}

	m_Sync.UnLock();

	EjectForce();
	g_Log.Log(LogType::_FILELOG, L"All Service Terminated Force\n");
	if (pMsg) strcpy(pMsg, "TerminateServiceAll Force Ok");
	m_bCloseService = false;

	SendPacketToGsm(_T("msg=Farm,0"));
	return ERROR_NONE;
}

int CServiceManager::TerminateServiceEachForce(int nSID, char * pMsg)
{
	/*if (IsService(nSID) == false)
		return ERROR_SM_TERMINATE_SERVICE_NOTFOUND;*/

	m_Sync.Lock();	

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		(*ii).second->SendTerminateProcess(nSID);	

	m_Sync.UnLock();
	g_Log.Log(LogType::_FILELOG, L"TerminateServiceEach Force Ok\n");
	if (pMsg) strcpy(pMsg, "TerminateServiceEach Force Ok");
	return ERROR_NONE;
}

bool CServiceManager::TerminateServiceEachForceAsync(int nSID)
{
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		(*ii).second->SendTerminateProcess(nSID, true);

	std::vector <int>::iterator itor;
	for (itor = m_AutoRestartList.begin(); itor != m_AutoRestartList.end(); itor++)
	{
		if ((*itor) == nSID)
			break;
	}

	g_Log.Log(LogType::_FILELOG, L"TerminateServiceEach Force Ok\n");

	if (itor == m_AutoRestartList.end())
	{
		m_AutoRestartList.push_back(nSID);
		return true;
	}
	return false;
}

void CServiceManager::StartServiceEachAsync(int nSID)
{
	//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>
	if (IsCloseService(nSID))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		return;
	}
	
	bool bRet = false;
	const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand(nSID);
	if (pExe)
		bRet = ExcuteProcess(pExe, false);

	if (bRet)
		g_Log.Log(LogType::_FILELOG, L"StartServiceEach OK\n");
	else
		g_Log.Log(LogType::_FILELOG, L"StartServiceEach Failed\n");
}

int CServiceManager::TerminateServiceAll(char * pMsg, int nAfterClose)
{
	if (IsCloseService(0))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		if (pMsg) strcpy(pMsg, "Terminate Process Busy");
		return ERROR_SM_TERMINATE_BUSY;
	}

	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"There Is No TerminateSessions\n");
		if (pMsg) strcpy(pMsg, "There Is No TerminateSessions");
		return ERROR_SM_NETLAUNCHER_NOTFOUND;
	}

	SendPacketToGsm(_T("msg=Farm,0"));

	if (nAfterClose > 0)
	{
		__time64_t _tCloseTime;
		if (m_ServiceCloser.IsClosing(_tCloseTime) == false)
		{
			if (m_ServiceCloser.ServiceClose(nAfterClose))
				g_Log.Log(LogType::_NORMAL, L"Service Will Close [Min:%d] Later\n", nAfterClose);
		}
		else
			g_Log.Log(LogType::_ERROR, L"Error TerminateProcess Already On\n");
	}
	else
	{
		{
			ScopeLock <CSyncLock> Lock(m_Sync);

			std::map <int, sServiceState*>::iterator ii;
			for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
			{
				if (wcscmp((*ii).second->szType, L"DB") && wcscmp((*ii).second->szType, L"Log") 
					&& wcscmp((*ii).second->szType, L"Village") && wcscmp((*ii).second->szType, L"Game") && wcscmp((*ii).second->szType, L"Master") \
					&& wcscmp((*ii).second->szType, L"Login"))
				{
					std::map <UINT, CLauncherSession*>::iterator ih;
					for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
						(*ih).second->SendTerminateProcess((*ii).second->nSID);
				}
			}

			std::map <UINT, CServiceSession*>::iterator ih;
			for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
			{
				if ((*ih).second->GetType() == MANAGED_TYPE_VILLAGE || (*ih).second->GetType() == MANAGED_TYPE_GAME || (*ih).second->GetType() == MANAGED_TYPE_LOGIN)
				{
					(*ih).second->SendCloseService();

					_CLOSESERVICE close;
					memset(&close, 0, sizeof(close));

					close.nMID = (*ih).second->GetMID();
					close.nInsertTick = timeGetTime();

					m_CloseServieList.push_back(close);
				}
			}
		}

		EjectServiceAll();
		g_Log.Log(LogType::_FILELOG, L"All Service Terminated (without db, village, game)\n");
		if (pMsg) strcpy(pMsg, "TerminateServiceAll (without dbvillage, game) Ok");
		m_bCloseService = true;
	}

	return ERROR_NONE;
}

int CServiceManager::TerminateServiceDB(char * pMsg, bool bWithOutLock)
{
	if (IsCloseService(0))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		if (pMsg) strcpy(pMsg, "Terminate Process Busy");
		return ERROR_SM_TERMINATE_BUSY;
	}

	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"There Is No TerminateSessions\n");
		if (pMsg) strcpy(pMsg, "There Is No TerminateSessions");
		return ERROR_SM_NETLAUNCHER_NOTFOUND;
	}

	if (bWithOutLock == false)
		m_Sync.Lock();

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if (!wcscmp((*ii).second->szType, L"DB") || !wcscmp((*ii).second->szType, L"Log") || !wcscmp((*ii).second->szType, L"Master"))
		{
			std::map <UINT, CLauncherSession*>::iterator ih;
			for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
				(*ih).second->SendTerminateProcess((*ii).second->nSID);
		}
	}

	if (bWithOutLock == false)
		m_Sync.UnLock();

	EjectServiceDB();
	g_Log.Log(LogType::_FILELOG, L"DB Service Terminated [Callby:%s]\n", bWithOutLock == true ? L"IdleProcess" : L"ConsolCmd");
	if (pMsg) strcpy(pMsg, "TerminateServiceDB Ok");
	return ERROR_NONE;
}

int CServiceManager::TerminateServiceEach(int nSID, char * pMsg, bool bReCreate)
{
	if (IsCloseService(nSID))
	{
		g_Log.Log(LogType::_FILELOG, L"Terminate Process Busy\n");
		if (pMsg) strcpy(pMsg, "Terminate Process Busy");
		return ERROR_SM_TERMINATE_BUSY;
	}

	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ih;
	for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
	{
		if ((*ih).second->GetMID() == nSID)
		{
			if ((*ih).second->GetType() == MANAGED_TYPE_VILLAGE || (*ih).second->GetType() == MANAGED_TYPE_GAME || (*ih).second->GetType() == MANAGED_TYPE_LOGIN)
			{
				(*ih).second->SendCloseService();

				_CLOSESERVICE close;
				memset(&close, 0, sizeof(close));

				close.nMID = (*ih).second->GetMID();
				close.nInsertTick = timeGetTime();

				m_CloseServieList.push_back(close);
			}
			else
			{
				std::map <UINT, CLauncherSession*>::iterator ii;
				for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
					(*ii).second->SendTerminateProcess(nSID);
			}

			if (bReCreate)
			{
				std::vector <int>::iterator itor;
				for (itor = m_AutoRestartList.begin(); itor != m_AutoRestartList.end(); itor++)
				{
					if ((*itor) == nSID)
						break;
				}
				if (itor == m_AutoRestartList.end())
					m_AutoRestartList.push_back(nSID);
			}
		}
	}

	m_Sync.UnLock();
	if (pMsg) strcpy(pMsg, "TerminateServiceEach Ok");
	return ERROR_NONE;
}

int CServiceManager::TerminateServiceEachbyLauncher(int nNID, char * pMsg)
{
	m_Sync.Lock();

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if (wcscmp((*ii).second->szType, L"DB") && wcscmp((*ii).second->szType, L"Log") 
			&& wcscmp((*ii).second->szType, L"Village") && wcscmp((*ii).second->szType, L"Game") \
			&& wcscmp((*ii).second->szType, L"Login"))
		{
			std::map <UINT, CLauncherSession*>::iterator ih;
			for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
				(*ih).second->SendTerminateProcess((*ii).second->nSID);
		}
		else
		{
			if ((*ii).second->nManagedLauncherID == nNID)
			{
				std::map <UINT, CServiceSession*>::iterator ih;
				for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
				{
					if ((*ih).second->GetMID() == (*ii).second->nSID)
					{
						if ((*ih).second->GetType() == MANAGED_TYPE_VILLAGE || (*ih).second->GetType() == MANAGED_TYPE_GAME || (*ih).second->GetType() == MANAGED_TYPE_LOGIN)
						{
							(*ih).second->SendCloseService();

							_CLOSESERVICE close;
							memset(&close, 0, sizeof(close));

							close.nMID = (*ih).second->GetMID();
							close.nInsertTick = timeGetTime();

							m_CloseServieList.push_back(close);
						}
					}
					else
					{
						std::map <UINT, CLauncherSession*>::iterator ij;
						for (ij = m_LauncherSessionList.begin(); ij != m_LauncherSessionList.end(); ij++)
						{
							if ((*ij).second->GetSessionID() == nNID)
							{
								(*ij).second->SendTerminateProcess((*ii).second->nSID);
							}
						}
					}
				}
			}
		}
	}	

	m_Sync.UnLock();
	if (pMsg) strcpy(pMsg, "TerminateServiceEachbyLauncher Ok");

	return ERROR_NONE;
}

int CServiceManager::TerminateServiceForceEachbyLauncher(int nNID, char * pMsg)
{
	CLauncherSession * pSession = NULL;

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
	{
		if ((*ih).second->GetSessionID() == nNID)
		{
			pSession = (*ih).second;
			break;
		}
	}

	if (pSession == NULL)
	{
		g_Log.Log(LogType::_FILELOG, L"NetLauncher not Found\n");
		if (pMsg) strcpy(pMsg, "NetLauncher not Found");
		return ERROR_SM_NETLAUNCHER_NOTFOUND;
	}

	pSession->SendTerminateProcess();
	return ERROR_NONE;
}

int CServiceManager::CancelTerminateProcess()
{
	if (m_ServiceCloser.CancelServiceClose())
	{
		g_Log.Log(LogType::_NORMAL, L"Cancel TerminateProcess\n");
	}
	else
	{
		g_Log.Log(LogType::_ERROR, L"No TerminateProcess\n");
	}
	return ERROR_NONE;
}

void CServiceManager::PatchESM(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchESM Fail try later");
		if (pMsg) strcpy(pMsg, "PatchESM Fail try later");
		return;
	}

	SendPatch(nNID, L"ESM", m_nPatchID++);

	if (pMsg) strcpy(pMsg, "ESM Patch OK");
}

int CServiceManager::StartESM()
{
	m_Sync.Lock();

	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
		(*ih).second->SendStartESM();
	
	m_Sync.UnLock();
	return ERROR_NONE;
}

int CServiceManager::StopESM()
{
	m_Sync.Lock();

	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
		(*ih).second->SendStopESM();
	m_Sync.UnLock();
	return ERROR_NONE;
}

void CServiceManager::NoticeWholeWorld(int nSec, const char * pMsg)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeMassage(_NOTICETYPE_WORLD, 0, 0, 0, nSec, pMsg);

	m_Sync.UnLock();
}

void CServiceManager::NoticeWorld(int nMasterMID, int nSec, const char * pMsg)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetMID() == nMasterMID && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeMassage(_NOTICETYPE_WORLD, 0, 0, 0, nSec, pMsg);

	m_Sync.UnLock();
}

void CServiceManager::NoticeServer(int nMasterMID, int nMID, int nSec, const char * pMsg)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetMID() == nMasterMID && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeMassage(_NOTICETYPE_EACHSERVER, nMID, 0, 0, nSec, pMsg);

	m_Sync.UnLock();
}

void CServiceManager::NoticeChannel(int nMasterMID, int nChannelID, int nSec, const char * pMsg)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if (((*ii).second->GetMID() == nMasterMID || nMasterMID == -1) && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeMassage(_NOTICETYPE_CHANNEL, 0, nChannelID, 0, nSec, pMsg);

	m_Sync.UnLock();
}

void CServiceManager::NoticeZone(int nMasterMID, int nMapIdx, int nSec, const char * pMsg)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if (((*ii).second->GetMID() == nMasterMID || nMasterMID == -1) && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeMassage(_NOTICETYPE_ZONE, 0, 0, nMapIdx, nSec, pMsg);

	m_Sync.UnLock();
}

void CServiceManager::NoticeCancel(int nMasterMID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if (((*ii).second->GetMID() == nMasterMID || nMasterMID == -1) && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendNoticeCancel();
}

void CServiceManager::MakeDumpAll()
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		(*ii).second->SendMakeDump();

	m_Sync.UnLock();
}

int CServiceManager::MakeDumEach(int nMID)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return ERROR_SM_NETLAUNCHER_NOTFOUND;
	}

	m_Sync.Lock();

	bool bRet = false;
	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetMID() == nMID)
		{
			(*ii).second->SendMakeDump();
			bRet = true;
			break;
		}
	}

	m_Sync.UnLock();

	return bRet == true ? ERROR_NONE : ERROR_SM_MAKEDUMP_FAIL;
}

void CServiceManager::WorldMaxuserControl(int nMasterMID, UINT nChangeMaxuser)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii, ih;
	for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
	{
		//<2F><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD> ã<><C3A3>
		if ((*ih).second->GetMID() == nMasterMID && (*ih).second->GetType() == MANAGED_TYPE_MASTER)
		{
			(*ih).second->SendChangeWorldMaxuser(nChangeMaxuser);
			return;
		}
	}
}

int CServiceManager::PopulationControl(int nMasterMID, int nControlMID, bool bZeroPopulation)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii, ih;
	for (ih = m_ServiceSessionList.begin(); ih != m_ServiceSessionList.end(); ih++)
	{
		//<2F><><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD> <20><><EFBFBD><EFBFBD> ã<><C3A3>
		if ((*ih).second->GetMID() == nMasterMID && (*ih).second->GetType() == MANAGED_TYPE_MASTER)
		{
			//<2F><>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ã<>´<EFBFBD>.
			for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
			{
				//<2F><>Ʈ<EFBFBD><C6AE><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ã<>Ұ<EFBFBD> 
				if ((*ii).second->GetMID() == nControlMID)
				{
					//<2F><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
					if (MANAGED_TYPE_VILLAGE == (*ii).second->GetType() || MANAGED_TYPE_GAME == (*ii).second->GetType())
					{
						g_ExceptionReportLog.Log(LogType::_FILELOG, L"ConnectRate GameServer SID[%d] BlockFlag[%s]\n", (*ii).second->GetMID(), bZeroPopulation == true ? L"TRUE" : L"FALSE");
						(*ih).second->SendPopulationControl((*ii).second->GetType(), (*ii).second->GetMID(), bZeroPopulation);
						return ERROR_NONE;
					}
					else
						_DANGER_POINT();	//<2F>̿ܿ<CCBF> ó<><C3B3><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ʴ´<CAB4>.
					break;
				}
			}
			break;
		}
	}
		
	return ERROR_SM_GAMECONTROL_FAIL;
}

int CServiceManager::ChannelControl(int nMasterMID, int nChannelID, bool bVisibility, int nChannelPopulation)
{
	bool bFlag = false;
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetMID() == nMasterMID && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
		{
			(*ii).second->SendChannelControl(nChannelID, bVisibility, nChannelPopulation);
			bFlag = true;
		}
	}

	m_Sync.UnLock();

	return bFlag == true ? ERROR_NONE : ERROR_SM_CHANNELCONTROL_FAIL;
}

void CServiceManager::GameAffinityControl(int nMasterMID, int nGameMID, int nType)
{
	if (nType != _GAMESERVER_AFFINITYTYPE_NORMAL && nType != _GAMESERVER_AFFINITYTYPE_HYBRYD && nType != _GAMESERVER_AFFINITYTYPE_PVP)
		return;

	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetMID() == nMasterMID && (*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendGameAffinity(nGameMID, nType);

	m_Sync.UnLock();
}

void CServiceManager::EventUpdate()
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		(*ii).second->SendUpdateEvent();		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>Ӽ<EFBFBD><D3BC><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>̺<EFBFBD>Ʈó<C6AE><C3B3><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD>߿<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>𸣹Ƿ<F0B8A3B9> <20>ϴ<EFBFBD><CFB4><EFBFBD> <20><> <20><><EFBFBD><EFBFBD>

	m_Sync.UnLock();
}

void CServiceManager::SimpleConfigUpdate()
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		(*ii).second->SendUpdateSimpleConfig();

	m_Sync.UnLock();
}

void CServiceManager::ReserveNoticeUpdate(const char * pURL, char * pRet)
{
	if (pURL == NULL)
		return;

	if (strstr (pURL, "http"))
	{
		char szCurPath[MAX_PATH];
		GetCurrentDirectoryA(sizeof(szCurPath), szCurPath);

		std::wstring wstrUrl;
		ToWideString(const_cast<CHAR*>(pURL), wstrUrl);

		std::wstring wstrDest;
		ToWideString(szCurPath, wstrDest);
		wstrDest.append(L"\\");
		wstrDest.append(g_Config.wszNoticePath);

		if (_waccess(wstrDest.c_str(), 0) != -1)
		{
			if (DeleteFileW(wstrDest.c_str()) == 0)
				return;
		}

		// DownLoad
		if (m_UrlUpdater.UrlUpdateUrl(wstrUrl.c_str(), wstrDest.c_str()))
		{
			char szNotice[FILENAME_MAX];
			WideCharToMultiByte(CP_ACP, 0, g_Config.wszNoticePath, -1, szNotice, 256, NULL, NULL);
			if (_access(szNotice, 0) != -1)
			{
				if (m_ReservedNotice.LoadNotice(szNotice))
				{
					g_IniFile.SetValue(L"ReserveNoticeInfo", L"FileName", g_Config.wszNoticePath);
					return;
				}
			}
		}
	}
	else
	{
		WCHAR szTemp[FILENAME_MAX];
		MultiByteToWideChar(CP_ACP, 0, pURL, -1, szTemp, FILENAME_MAX);

		g_Log.Log(LogType::_FILELOG, L"Update Reserved Notice [URL:%s]\n", szTemp);

		if (m_UrlUpdater.UrlUpdateEach(szTemp, szTemp, true))
		{
			if (m_ReservedNotice.LoadNotice(pURL))
			{
				g_IniFile.SetValue(L"ReserveNoticeInfo", L"FileName", szTemp);
				return;
			}
		}

		g_Log.Log(LogType::_FILELOG, L"ReserveNotice Download Fail [URL:%s]\n", szTemp);
		if (pRet)
			strcpy_s(pRet, 256, "ReserveNotice Load Fail CheckURL\n");
	}
}

void CServiceManager::UserRestraint(UINT nAccountDBID, char * pRet)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendUserRestraint(nAccountDBID);

	m_Sync.UnLock();
}

void CServiceManager::UserBanbyCharacterName(const char * pName)
{
	WCHAR wszName[NAMELENMAX];
	memset(wszName, 0, sizeof(wszName));
	MultiByteToWideChar(CP_ACP, 0, pName, -1, wszName, NAMELENMAX);

	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendUserBan(wszName, 0, _BANTYPE_CHARACTERNAME);

	m_Sync.UnLock();
}

void CServiceManager::UserBanbyCharacterName(const WCHAR * pwszName)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendUserBan(pwszName, 0, _BANTYPE_CHARACTERNAME);

	m_Sync.UnLock();
}

void CServiceManager::UserBanbyAccountDBID(UINT nAccountDBID)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendUserBan(NULL, nAccountDBID, _BANTYPE_ACCOUNTID);

	m_Sync.UnLock();
}

void CServiceManager::UserBanbyAccountName(const WCHAR * pwszName)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendUserBan(pwszName, 0, _BANTYPE_ACCOUNTNAME);

	m_Sync.UnLock();
}

//use http
void CServiceManager::PatchUpdateUrl(const char * pUrl, char * pMsg)
{
	if (m_PatchWatcher.HasWatchingContent())
	{
		if (pMsg) strcpy(pMsg, "PatchList Update Fail");
		return;
	}

	WCHAR wszPath[256];
	memset(wszPath, 0, sizeof(wszPath));
	MultiByteToWideChar(CP_ACP, 0, pUrl, -1, wszPath, 256);

	wcscpy_s(g_Config.wszPatchURL, wszPath);
	g_IniFile.SetValue(L"PatchInfo", L"PatchUrl", wszPath);
	
	m_UrlUpdater.UpdaterInit(g_Config.wszPatchBaseURL, g_Config.wszPatchURL);
	
	ScopeLock <CSyncLock> sync(m_Sync);
	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		std::vector <TServerExcuteData> vExeList;
		CDataManager::GetInstance()->GetExeCommandList((*ii).second->GetSessionID(), &vExeList);
		bool bOther = CDataManager::GetInstance()->IsNeedOtherExcutePath((*ii).second->GetSessionID());
		(*ii).second->SendManagingExeItem(&vExeList, bOther);

		std::list <char> lList;
		CDataManager::GetInstance()->GetAssingedPatchTypeList((*ii).second->GetSessionID(), &lList);
		(*ii).second->SendConnectedResult(&lList, g_Config.wszPatchBaseURL, g_Config.wszPatchURL);
	}

	std::map <UINT, CPatcherSession*>::iterator ih;
	for (ih = m_PatcherSessionList.begin(); ih != m_PatcherSessionList.end(); ih++)
		(*ih).second->SendConnectedResult(g_Config.wszPatchBaseURL, g_Config.wszPatchURL);

	if (pMsg) strcpy(pMsg, "PatchList Updated");
}

void CServiceManager::PatchStruct(char * pMsg)
{
	if (m_UrlUpdater.UrlUpdate(L"ServerStruct", L"System", false))
	{
		if (ReLoadStruct())
		{
			if (pMsg) strcpy(pMsg, "ServerStruct Patched");
			SendUpdateNotice(SERVERMONITOR_UPDATENOTICE_SERVERINFO);
			return ;
		}
		else
		{
			g_Log.Log(LogType::_FILELOG, _T("ServerStruct Patched Failed\n"));
			if (pMsg) strcpy(pMsg, "ServerStruct Patched Failed");
		}
	}

	g_Log.Log(LogType::_FILELOG, _T("Struct Patch Failed [URLDown]\n"));
	if (pMsg) strcpy(pMsg, "Struct Patch Failed [URLDown]");
}

void CServiceManager::PatchInfo(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchInfo Fail try later");
		if (pMsg) strcpy(pMsg, "PatchInfo Fail try later");
		return;
	}

	SendPatch(nNID, _T("Info"), m_nPatchID++);
	
	g_Log.Log(LogType::_FILELOG, _T("Send NetLauncher Info Patch\n"));
	if (pMsg) strcpy(pMsg, "Send NetLauncher Info Patch");
}

void CServiceManager::PatchSystem(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchSystem Fail try later");
		if (pMsg) strcpy(pMsg, "PatchSystem Fail try later");
		return;
	}

	SendPatch(nNID, _T("System"), m_nPatchID++);

	g_Log.Log(LogType::_FILELOG, _T("Send NetLauncher System Patch\n"));
	if (pMsg) strcpy(pMsg, "Send NetLauncher System Patch");
}

void CServiceManager::PatchConfig(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchConfig Fail try later");
		if (pMsg) strcpy(pMsg, "PatchConfig Fail try later");
		return;
	}

	SendPatch(nNID, _T("Config"), m_nPatchID++);

	g_Log.Log(LogType::_FILELOG, _T("Send NetLauncher Config Patch\n"));
	if (pMsg) strcpy(pMsg, "Send NetLauncher Config Patch");
}

void CServiceManager::PatchExe(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchExe Fail try later");
		if (pMsg) strcpy(pMsg, "PatchExe Fail try later");
		return;
	}

	if (m_LauncherSessionList.empty())
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
	else
		SendPatch(nNID, _T("Exe"), m_nPatchID++);
}

void CServiceManager::PatchFull(int nNID, char * pMsg)
{
	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_ERROR, L"PatchFull Fail try later");
		if (pMsg) strcpy(pMsg, "PatchFull Fail try later");
		return;
	}

	if (m_LauncherSessionList.empty())
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
	else
	{
#if defined(_SERVICEMANAGER_EX)
		//<2F><><EFBFBD><EFBFBD> <20>ȵ<EFBFBD> <20><><EFBFBD>İ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ġ<EFBFBD>ϰڳİ<DAB3> <20><><EFBFBD>
		if(!IsStartAllLauncherAndContinue())
		{
			g_Log.Log(LogType::_ERROR, L"PatchFull Fail try later");
			SetPatchComplete(false);
			m_pApp->OnPatchEnd(false);
			return ;
		}
#endif	// #if defined(_SERVICEMANAGER_EX)

		SendPatchStart(nNID);
		SendPatch(nNID, L"Config", m_nPatchID);
		SendPatch(nNID, L"Info", m_nPatchID);
		SendPatch(nNID, L"System", m_nPatchID);
		SendPatch(nNID, L"Exe", m_nPatchID);
		SendPatch(nNID, L"Res", m_nPatchID);
#if defined(_CH)
		SendPatch(nNID, L"Bat", m_nPatchID);
#endif	// #if defined(_CH)
		SendPatchEnd(nNID);
		SendInfoCopy(nNID);
		m_nPatchID++;
#if defined(_SERVICEMANAGER_EX)
		SetPatchComplete(true);
#endif
	}
}

void CServiceManager::PatchApply(char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		if (pMsg) strcpy(pMsg, "No Launcher");
		return;
	}
	
	TerminateServiceAll();

	ScopeLock <CSyncLock> sync(m_Sync);
	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		(*ii).second->SendPatchApply();
	
	if (pMsg) strcpy(pMsg, "Patch Apply OK");
}

void CServiceManager::InfoCopy(int nNID, char * pMsg)
{
	SendInfoCopy(nNID);
	if (pMsg) strcpy(pMsg, "Send Request NetLauncher InfoCopy");
}

void CServiceManager::Patch(const char * pUrl, char * pMsg)
{
	ScopeLock <CSyncLock> sync(m_Sync);
	
	std::map <UINT, CLauncherSession*>::iterator ih;
	for (ih = m_LauncherSessionList.begin(); ih != m_LauncherSessionList.end(); ih++)
	{
		if (m_PatchWatcher.AddWatchContent(m_nPatchID, (*ih).second->GetSessionID(), L"Url"))
		{
			(*ih).second->SendPatchByUrl(m_nPatchID, pUrl, L"Url", false, NULL);
		}
		else
			_DANGER_POINT();
	}
	m_nPatchID++;

	if (pMsg) strcpy(pMsg, "Send Request Patch By Url");
}

void CServiceManager::PatchBatch(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchBatch Fail try later");
		if (pMsg) strcpy(pMsg, "PatchBatch Fail try later");
		return;
	}

	SendPatch(nNID, L"Bat", m_nPatchID++);

	if (pMsg) strcpy(pMsg, "Batch Patch OK");
}

void CServiceManager::RunBatch(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_RunBatchWatcher.HasWatchingSpec())
	{
		if (pMsg) strcpy(pMsg, "Batch Run Fail");
		return;
	}


	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		if (m_RunBatchWatcher.AddWatchSpec(m_nRunBatchID, (*ii).second->GetSessionID(), L"RunBat"))
		{
			(*ii).second->SendBatchRun(m_nRunBatchID);
			(*ii).second->SetBatch(false);
		}
		else
			_DANGER_POINT();
	}
	m_nRunBatchID++;

	if (pMsg) strcpy(pMsg, "Batch Run OK");
}

void CServiceManager::StopBatch(int nNID, char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		if (m_StopBatchWatcher.AddWatchSpec(m_nStopBatchID, (*ii).second->GetSessionID(), L"StopBat"))
		{
			(*ii).second->SendBatchStop(m_nStopBatchID);
			(*ii).second->SetBatch(true);
		}
	}

	++m_nStopBatchID;

	m_RunBatchWatcher.ClearWatchingSpec();

	if (pMsg) strcpy(pMsg, "Batch Stop OK");
}

//for chn
void CServiceManager::PatchDyncode(char * pMsg)
{
	if (m_LauncherSessionList.empty())
	{
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
		return;
	}

	if (m_PatchWatcher.HasWatchingContent())
	{
		g_Log.Log(LogType::_FILELOG, L"PatchDynCodeBin Fail try later");
		if (pMsg) strcpy(pMsg, "PatchDynCodeBin Fail try later");
		return;
	}

	if (m_LauncherSessionList.empty())
		g_Log.Log(LogType::_ERROR, L"No Launcher\n");
	else
		SendPatch(0, _T("DynCodeBin"), m_nPatchID++);
}

void CServiceManager::ReloadDyncode(char * pMsg)
{
	if (IsService() == false)
	{
		g_Log.Log(LogType::_ERROR, L"No Service\n");
		if (pMsg) strcpy(pMsg, "No Service");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_GAME || (*ii).second->GetType() == MANAGED_TYPE_VILLAGE || (*ii).second->GetType() == MANAGED_TYPE_LOGIN)
		{
			(*ii).second->SendReloadDynCode();
		}
	}
}

//for extpatch
void CServiceManager::PatchExt()
{
	//live ext<78><74>ġ<EFBFBD><C4A1> <20>ٸ<EFBFBD> <20><>ġ<EFBFBD>÷ο<C3B7><CEBF><EFBFBD> <20>ٸ<EFBFBD><D9B8><EFBFBD> ó<><C3B3><EFBFBD>Ǿ<EFBFBD><C7BE><EFBFBD> (<28><><EFBFBD><EFBFBD>)
	//<2F><><EFBFBD><EFBFBD> GSM<53><4D> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ִ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>û<EFBFBD>Ѵ<EFBFBD>.

	if (m_LivePatcher.IsStarted())
	{
		g_Log.Log(LogType::_ERROR, L"Already Live Ext Patching PatchFailed\n");
		return;
	}

	std::wstring wstrTemp;
	wstrTemp = L"msg=RequestFileList,";
	wstrTemp += g_Config.wszPatchURL;
	wstrTemp += L"/ext";

	if (SendPacketToGsm(wstrTemp.c_str()))
	{
		if (m_LivePatcher.StartPatch() == false)
			g_Log.Log(LogType::_ERROR, L"Already Live Ext Patching PatchFailed\n");

		g_pServiceManager->SendDelExt();
		g_Log.Log(LogType::_FILELOG, L"Live Ext Patch Start\n");
		return;
	}

	g_Log.Log(LogType::_ERROR, L"ext patch err\n");
}

void CServiceManager::CancelExtPatch()
{
	m_LivePatcher.CancelPatch();
}

void CServiceManager::RecvFileList(const char * pUrl)
{
	//<2F>ش<EFBFBD> Url<72><6C><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ٿ<EFBFBD> <20>޴´<DEB4>!
	if (pUrl == NULL)
		return;

	char szCurPath[MAX_PATH];
	GetCurrentDirectoryA(sizeof(szCurPath), szCurPath);

	std::wstring wstrUrl;
	ToWideString(const_cast<CHAR*>(pUrl), wstrUrl);

	std::wstring wstrDest;
	ToWideString(szCurPath, wstrDest);
	wstrDest.append(L"\\FileList.csv");

	if (_waccess(wstrDest.c_str(), 0) != -1)
	{
		if (DeleteFileW(wstrDest.c_str()) == 0)
			return;
	}

	if (m_UrlUpdater.UrlUpdateUrl(wstrUrl.c_str(), wstrDest.c_str()))
	{
		TCHAR * pFile = NULL;
		pFile = ReadFile(L"FileList.csv");
		if (pFile)
		{
			if (m_LivePatcher.LoadPatchList(pFile) == false)
			{
				g_Log.Log(LogType::_ERROR, L"LoadPatchList Fail\n");
				m_LivePatcher.CancelPatch();
				SAFE_DELETEARRAY(pFile);
				return;
			}
			SAFE_DELETEARRAY(pFile);
			m_LivePatcher.SendLivePatch();
		}
		else
		{
			m_LivePatcher.CancelPatch();
			g_Log.Log(LogType::_ERROR, L"PatchFileList LoadFail Path[%s]\n", wstrDest.c_str());
			return;
		}
	}
	else
		m_LivePatcher.CancelPatch();
}

bool CServiceManager::CompleteLivePatchItem(int nPatchID)
{
	if (m_LivePatcher.IsStarted())
	{
		if (m_LivePatcher.RecvCompleteItem(nPatchID))
		{
			//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>ϵǸ<CFB5> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>۵<EFBFBD><DBB5><EFBFBD> <20><><EFBFBD><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20>Ǿ<EFBFBD><C7BE><EFBFBD><EFBFBD>Ŵ<EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD>鿡<EFBFBD><E9BFA1> <20>ε<EFBFBD><CEB5>϶<EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD>
			g_Log.Log(LogType::_NORMAL, L"LivePatch Ext DownLoadComplete\n");

			if (IsService() == false)
			{
				g_Log.Log(LogType::_ERROR, L"LivePatch Ext Live Patch Reload Failed No Service\n");
				m_LivePatcher.CancelPatch();
				return false;
			}

			g_Log.Log(LogType::_NORMAL, L"LivePatch Ext Live Patch Starting...\n");
			g_pServiceManager->SendCopyExt();
			return true;
		}
	}
	return false;
}

void CServiceManager::CompleteLiveExtCopy(bool bRet)
{
	if (m_LivePatcher.IsStarted())
	{
		if (bRet)
		{
			//<2F><><EFBFBD><EFBFBD> <20><><EFBFBD>缭<EFBFBD><E7BCAD><EFBFBD><EFBFBD> ext<78><74><EFBFBD><EFBFBD> <20>߰<EFBFBD><DFB0>ε<EFBFBD><CEB5>϶<EFBFBD> <20>˸<EFBFBD><CBB8><EFBFBD>~
			std::vector <int> vList;
			GetMangedIDList(vList);

			m_LivePatcher.SetReloadFlag(vList);
			if (SendExtReload(0) == false)
			{
				m_LivePatcher.CancelPatch();
				g_Log.Log(LogType::_ERROR, L"LivePatch Ext Live Patch Failed! No Service\n");
			}
		}
		else
		{
			//<2F><><EFBFBD><EFBFBD> <20>ֿܼ<DCBC> <20>޼<EFBFBD><DEBC><EFBFBD><EFBFBD><EFBFBD> ǥ<><C7A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			m_LivePatcher.CancelPatch();
			g_Log.Log(LogType::_ERROR, L"LivePatch Ext Live Patch Failed! Check ext files\n");
		}
	}
}

void CServiceManager::CompleteLiveExtReload(int nMID, bool bRet)
{
	if (bRet == false)
		g_Log.Log(LogType::_ERROR, L"LivePatch Ext Live Reload Failed!!!!! CheckServer!!!!\n");

	bool bReloadFlag = false;
	if (m_LivePatcher.SetReloadResult(nMID, bRet, bReloadFlag))
	{
		g_Log.Log(LogType::_NORMAL, L"LivePatch Ext Live Reload Ret[%s]\n", (bReloadFlag) ? L"Success" : L"Failed");
	}
}

void CServiceManager::SendDelExt()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		(*ii).second->SendLiveExtDel();
}


void CServiceManager::SendCopyExt()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
		(*ii).second->SendLiveExtCopy();
}

bool CServiceManager::SendExtReload(int nReLoadType)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (m_ServiceSessionList.empty())
		return false;

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		(*ii).second->SendExtReload(nReLoadType);
	}
	return true;
}


//NetLauncher Service For GSM
void CServiceManager::StartLauncher(char * pMsg)
{
	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	//Managed PatcherServiceOnly
	std::map <UINT, CPatcherSession*>::iterator ii;
	for (ii = m_PatcherSessionList.begin(); ii != m_PatcherSessionList.end(); ii++)
		(*ii).second->SendStartNetLauncher();

	if (pMsg) strcpy(pMsg, "Send Request Start NetLauncher");
}

void CServiceManager::StopLauncher(char * pMsg)
{
	if (IsService())
	{
		g_Log.Log(LogType::_FILELOG, L"DragonNest Service Online Plz Try Later\n");
		if (pMsg) strcpy(pMsg, "DragonNest Service Online Plz Try Later");
		return;
	}

	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CPatcherSession*>::iterator ii;
	for (ii = m_PatcherSessionList.begin(); ii != m_PatcherSessionList.end(); ii++)
		(*ii).second->SendStopNetLauncher();

	if (pMsg) strcpy(pMsg, "Send Request Stop NetLauncher");
}

void CServiceManager::StartEachLauncher(int nPSID, char * pMsg)
{
	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CPatcherSession*>::iterator ii = m_PatcherSessionList.find(nPSID);
	if (ii != m_PatcherSessionList.end())
		(*ii).second->SendStartNetLauncher();

	if (pMsg) strcpy(pMsg, "Send Request Start NetLauncher");
}

void CServiceManager::StopEachLauncher(int nPSID, char * pMsg)
{
	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CPatcherSession*>::iterator ii = m_PatcherSessionList.find(nPSID);
	if (ii != m_PatcherSessionList.end())
		(*ii).second->SendStopNetLauncher();

	if (pMsg) strcpy(pMsg, "Send Request Stop NetLauncher");
}

void CServiceManager::StopEachLauncherAsync(int nPSID)
{
	if (m_PatcherSessionList.empty())
	{
		std::map <UINT, CLauncherSession*>::iterator itor = m_LauncherSessionList.find(nPSID);
		if (itor != m_LauncherSessionList.end())
			(*itor).second->DetachConnection(L"NetLauncher ProblemDetach");
		return;
	}

	std::map <UINT, CPatcherSession*>::iterator ii = m_PatcherSessionList.find(nPSID);
	if (ii != m_PatcherSessionList.end())
		(*ii).second->SendStopNetLauncher();
}

//NetLauncher Patch
void CServiceManager::PatchNetLauncher(char * pMsg)
{
	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	std::map <UINT, CPatcherSession*>::iterator ii;
	std::vector <TNetLauncherInfo>::iterator itor;

	//check
	std::vector <TNetLauncherInfo> vList;
	CDataManager::GetInstance()->GetLauncherIds(&vList);
	int nCount = 0;
	for (itor = vList.begin(); itor != vList.end(); itor++)
	{
		ii = m_PatcherSessionList.find((*itor).nNID);
		if (ii != m_PatcherSessionList.end())
			nCount++;
		else
		{
			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			g_Log.Log(LogType::_FILELOG, L"LauncherPatcher Not Exists IP[%s]\n", (*itor).wszIP);
		}
	}
	if (vList.size() != nCount)
	{
		g_Log.Log(LogType::_FILELOG, L"Launcher Patch Failed\n");
		return;
	}
	
	if (IsService())
	{
		g_Log.Log(LogType::_FILELOG, L"DragonNest Service Online PatchFailed\n");
		if (pMsg) strcpy(pMsg, "DragonNest Service Online PatchFailed");
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);
	
	for (ii = m_PatcherSessionList.begin(); ii != m_PatcherSessionList.end(); ii++)
		(*ii).second->SendStopNetLauncher();

	Sleep(500);

	for (ii = m_PatcherSessionList.begin(); ii != m_PatcherSessionList.end(); ii++)
	{
		if ((*ii).second->SendNetLauncherPatch())
			m_PatchWatcher.AddWatchContent(-1, (*ii).second->GetSessionID(), L"Net");
	}

	if (pMsg) strcpy(pMsg, "Send Request Patch NetLauncher");
}

void CServiceManager::PatchNetLauncherEach(int nID, char * pMsg)
{
	if (m_PatcherSessionList.empty())
	{
		g_Log.Log(LogType::_FILELOG, L"No PatcherService\n");
		if (pMsg) strcpy(pMsg, "No PatcherService");
		return;
	}

	std::map <UINT, CPatcherSession*>::iterator ii;
	std::vector <TNetLauncherInfo>::iterator itor;

	//check
	bool bCheck = false;
	std::vector <TNetLauncherInfo> vList;
	CDataManager::GetInstance()->GetLauncherIds(&vList);

	ScopeLock <CSyncLock> sync(m_Sync);
	ii = m_PatcherSessionList.find(nID);
	if (ii != m_PatcherSessionList.end())
	{
		for (itor = vList.begin(); itor != vList.end(); itor++)
		{
			if ((*itor).nNID == nID)
			{
				bCheck = true;
				break;
			}
		}
	}

	if (bCheck == false)
	{
		g_Log.Log(LogType::_FILELOG, L"LauncherPatcher Not Exists IP[%s]\n", ii == m_PatcherSessionList.end() ? "none" : (*ii).second->GetIp());
		return;
	}	

	ii = m_PatcherSessionList.find(nID);
	if (ii != m_PatcherSessionList.end())
	{
		(*ii).second->SendStopNetLauncher();
		Sleep(500);
		(*ii).second->SendNetLauncherPatch();
	}

	if (pMsg) strcpy(pMsg, "Send Request Patch NetLauncher");
}

void CServiceManager::PatchedLauncher(int nNID)
{
	bool bComplete = false;
#if defined(_SERVICEMANAGER_EX)
	bool bNIDComplete = false;
	m_PatchWatcher.DelWatchContent(-1, nNID, L"Net", bComplete, bNIDComplete);
#else
	m_PatchWatcher.DelWatchContent(-1, nNID, L"Net", bComplete);
#endif
	if (bComplete)
	{
		g_Log.Log(LogType::_NORMAL, L"NetLauncherPatch Complete\n");
	}
}

void CServiceManager::CheckPatch()
{
	if (m_PatchWatcher.HasWatchingContent() == false)
	{
		g_Log.Log(LogType::_NORMAL, L"No Watching Patch Content\n");
	}
}

void CServiceManager::Clearpatch()
{
	m_PatchWatcher.ClearWatchingContent();
}

void CServiceManager::CheckNetLauncher(int nNID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (nNID == -1)
	{
		std::vector <TNetLauncherInfo> vTemp;
		CDataManager::GetInstance()->GetLauncherIds(&vTemp);

		for (int i = 0; i < (int)vTemp.size(); i++)
		{
			std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.find(vTemp[i].nNID);
			if (ii == m_LauncherSessionList.end())
				g_Log.Log(LogType::_NORMAL, L"NetLauncher was not connected[ID:%d][IP:%s]\n", vTemp[i].nNID, vTemp[i].wszIP);
		}
	}
	else
	{
		const TNetLauncher * pLauncher = CDataManager::GetInstance()->GetLauncherInfobyID(nNID);
		if (pLauncher)
		{
			g_Log.Log(LogType::_NORMAL, L"NetLauncher [ID:%d][PID:%d][WID:%d][IP:%s]\n", pLauncher->nID, pLauncher->nPID, pLauncher->nWID, pLauncher->szIP);
		}

		std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.find(nNID);
		if (ii != m_LauncherSessionList.end())
		{
			(*ii).second->SendReturnPing(-1);
		}
	}
}

void CServiceManager::CheckAliveNetLauncher()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (m_LauncherSessionList.size() <=0)
	{
		g_Log.Log(LogType::_FILELOG, L"All Launchers Closed\n");
		return;
	}

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		g_Log.Log(LogType::_NORMAL, L"NetLauncher is alive [ID:%d][IP:%S]\n", (*ii).second->GetSessionID(), (*ii).second->GetIp());
	}
	
}

void CServiceManager::TestLauncher(int nNID)
{
	ScopeLock <CSyncLock> sync(m_Sync);
	ULONG nCurTick = timeGetTime();
	m_LaunchetTestList.clear();
	
	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if ((*ii).second->SendReturnPing(0))
			m_LaunchetTestList.insert(std::make_pair((*ii).second->GetSessionID(), nCurTick));
	}
}

void CServiceManager::CheckBatch(int nNID)
{
	// BatchWatcher<65><72><EFBFBD>ٴ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> CheckNetLauncheró<72><C3B3> ó<><C3B3><EFBFBD>Ѵ<EFBFBD>.
	ScopeLock <CSyncLock> sync(m_Sync);

	if (nNID == -1)
	{
		std::vector <TNetLauncherInfo> vTemp;
		CDataManager::GetInstance()->GetLauncherIds(&vTemp);

		for (int i = 0; i < (int)vTemp.size(); i++)
		{
			std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.find(vTemp[i].nNID);
			if (ii == m_LauncherSessionList.end())
				g_Log.Log(LogType::_NORMAL, L"NetLauncher was not connected[ID:%d][IP:%s]\n", vTemp[i].nNID, vTemp[i].wszIP);
			else
			{
				if (false == (*ii).second->IsBatch())
				{
					g_Log.Log(LogType::_ERROR, L"Batch was not completed [ID:%d][IP:%s]\n", vTemp[i].nNID, vTemp[i].wszIP);
				}
			}
		}
	}
	else
	{
		const TNetLauncher * pLauncher = CDataManager::GetInstance()->GetLauncherInfobyID(nNID);
		if (pLauncher)
		{
			g_Log.Log(LogType::_NORMAL, L"NetLauncher [ID:%d][PID:%d][WID:%d][IP:%s]\n", pLauncher->nID, pLauncher->nPID, pLauncher->nWID, pLauncher->szIP);
		}
		else
		{
			g_Log.Log(LogType::_NORMAL, L"CheckBatch NID[%d] NotFound\n", nNID);
		}

		std::map <UINT, CLauncherSession*>::iterator ii = m_LauncherSessionList.find(nNID);
		if (ii != m_LauncherSessionList.end())
		{
			if (false == (*ii).second->IsBatch())
			{
				g_Log.Log(LogType::_ERROR, L"Batch was not completed [ID:%d][IP:%s]\n", nNID, (*ii).second->GetIp());
			}
		}
	}
}

bool CServiceManager::CreateServiceServer(int nSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		if ((*ii).second->nState != _SERVICE_STATE_ONLINE || (*ii).second->nState != _SERVICE_STATE_CREATE)
		{
			(*ii).second->nState = _SERVICE_STATE_CREATE;
			g_Log.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d]Service Created\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID);
			int nState = (*ii).second->nState;

			(*ii).second->nCreateTime = timeGetTime();

			ReportToGSMServiceState(nSID, nState, NULL, NULL);
			ReportToMonitorServiceState(nSID, nState);
		}
		return true;
	}
	return false;
}

bool CServiceManager::OnlineServiceServer(int nSID, int nServiceSessionID, const char * pVersion, const char * pResVersion, CServiceSession * pSession, BYTE cWorldCount, BYTE * pWorldID, bool bFinalBuild)
{
	std::string strCmd;
	strCmd = pVersion;
	ToLowerA(strCmd);

	std::vector<std::string> tokens;
	TokenizeA(strCmd, tokens, ".");

	if (tokens.size() < 2)
		return false;

	int nMajorVersion = atoi(tokens[0].c_str());
	int nMinorVersion = atoi(tokens[1].c_str());

	if (nMajorVersion != m_nMajorVersion && nMinorVersion != m_nMinorVersion)
	{
		//TerminateServiceEachForce(nSID);
		g_Log.Log(LogType::_ERROR, L"Server Version MisMatch ServiceManager[%S] Server[%S] IP[%S]\n", g_Config.szVersion, pVersion, pSession->GetIp());
	}

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		if ((*ii).second->nState == _SERVICE_STATE_ONLINE)
		{
			if((*ii).second->bIsReConnect == false)
			{
				(*ii).second->bIsReConnect = true;
				g_Log.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [Session:%d, ConnectedSession:%d] Reconnect Service\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pSession->GetSessionID(), (*ii).second->nServiceSessionID);
			}
			else
			{
				g_Log.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [Session:%d, ConnectedSession:%d] Already Service Online\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pSession->GetSessionID(), (*ii).second->nServiceSessionID);
				return true;
			}
		}
		else
#if defined( _SERVICEMANAGER_EX )
			g_FileLog.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [Version:%S] [ResVersion:%S] [Session:%d] Service Online\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pVersion, pResVersion, pSession->GetSessionID());
#else
			g_Log.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [Version:%S] [ResVersion:%S] [Session:%d] Service Online\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pVersion, pResVersion, pSession->GetSessionID());
#endif
		
		(*ii).second->nState = _SERVICE_STATE_ONLINE;
		(*ii).second->nServiceSessionID = nServiceSessionID;

		int nState = (*ii).second->nState;
		//memcpy((*ii).second->cWorldIDs, pWorldID, cWorldCount);
		strncpy ((*ii).second->szVersion, pVersion, SERVERVERSIONMAX);
		(*ii).second->bFinalBuild = bFinalBuild;

		ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, pVersion, pResVersion);
		ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);
		return true;
	}
	return false;
}

bool CServiceManager::CheckAllServiceOnline()
{
	for (std::map <int, sServiceState*>::iterator ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if( ii->second->nState != _SERVICE_STATE_ONLINE )
			return false;		
	}
	return true;
}

bool CServiceManager::ReportTerminateService(int nSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		CLauncherSession * pLauncher = NULL;
		std::map <UINT, CLauncherSession*>::iterator ih = m_LauncherSessionList.find((*ii).second->nManagedLauncherID);
		if (ih != m_LauncherSessionList.end())
			pLauncher = (*ih).second;

		(*ii).second->nState = _SERVICE_STATE_TERMINATED;
		int nState = (*ii).second->nState;		
		g_Log.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [IP:%S]Service Terminated\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pLauncher ? pLauncher->GetIp() : "0");
		g_ExceptionReportLog.Log(LogType::_FILELOG, L"[LauncherReport [NLID:%d] [SID:%d] [IP:%S]Service Terminated\n", (*ii).second->nManagedLauncherID, (*ii).second->nSID, pLauncher ? pLauncher->GetIp() : "0");

		//Ȥ<><C8A4> <20>𸣴<EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>ġ<EFBFBD>մϴ<D5B4>
		std::map <UINT, CServiceSession*>::iterator is;
		for (is = m_ServiceSessionList.begin(); is != m_ServiceSessionList.end(); is++)
		{
			if ((*is).second->GetMID() == nSID)
			{
				(*is).second->DetachConnection(L"terminated");
				break;
			}
		}

		ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, NULL, NULL);
		ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);
		return true;
	}
	return false;
}

void CServiceManager::EjectForce()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		(*ii).second->nState = _SERVICE_STATE_OFFLINE;
		(*ii).second->bIsReConnect = false;

		ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, NULL, NULL);
		ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);
	}
}

void CServiceManager::EjectServiceAll()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if (wcscmp((*ii).second->szType, L"DB") && wcscmp((*ii).second->szType, L"Log"))
		{
			(*ii).second->nState = _SERVICE_STATE_OFFLINE;
			(*ii).second->bIsReConnect = false;

			ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, NULL, NULL);
			ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);
		}
	}
}

void CServiceManager::EjectServiceDB()
{
	m_Sync.Lock();

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if (!wcscmp((*ii).second->szType, L"DB") || !wcscmp((*ii).second->szType, L"Log"))
		{
			(*ii).second->nState = _SERVICE_STATE_OFFLINE;
			(*ii).second->bIsReConnect = false;

			ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, NULL, NULL);
			ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);
		}
	}

	m_Sync.UnLock();
}

void CServiceManager::EjectService(int nSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if ((*ii).second->nSID == nSID)
		{
			(*ii).second->nState = _SERVICE_STATE_OFFLINE;
			(*ii).second->bIsReConnect = false;

			ReportToGSMServiceState((*ii).second->nSID, (*ii).second->nState, NULL, NULL);
			ReportToMonitorServiceState((*ii).second->nSID, (*ii).second->nState);

			std::vector <_CLOSESERVICE>::iterator ih;
			for (ih = m_CloseServieList.begin(); ih != m_CloseServieList.end(); ih++)
			{
				if ((*ih).nMID == nSID)
				{
					m_CloseServieList.erase(ih);
					break;
				}
			}
			return;
		}
	}
}

void CServiceManager::UpdateWorldMaxUser(TServiceWorldInfo * pPacket)
{
	{
		ScopeLock <CSyncLock> sync(m_Sync);

		std::map <int, sMonitorWorldInfo>::iterator ii = m_WorldInfo.find(pPacket->nWorldID);
		if (ii != m_WorldInfo.end())
		{
			(*ii).second.nWorldMaxUser = pPacket->nWorldMaxuser;
		}
		else
		{
			sMonitorWorldInfo World;
			memset(&World, 0, sizeof(World));

			World.nWorldID = pPacket->nWorldID;
			World.nWorldMaxUser = pPacket->nWorldMaxuser;
			m_WorldInfo.insert(std::make_pair(pPacket->nWorldID, World));
		}

#if defined (_SERVICEMANAGER_EX)
		OnWorldMaxUser(pPacket->nWorldID, pPacket->nWorldMaxuser);
#endif

		m_nContainerVersion++;
	}

	SendUpdateNotice(SERVERMONITOR_UPDATENOTICE_WOLRDINFO);
}

void CServiceManager::UpdateMeritInfo(TServiceMeritInfo * pPacket)
{
	{
		ScopeLock <CSyncLock> sync(m_Sync);
		m_ChannelMerit.clear();

		std::map <int, TMeritInfo>::iterator ii;
		for (int i = 0; i < pPacket->cCount; i++)
		{
			ii = m_ChannelMerit.find(pPacket->Info[i].nID);
			if (ii == m_ChannelMerit.end())
				m_ChannelMerit.insert(std::make_pair(pPacket->Info[i].nID, pPacket->Info[i]));
		}

		m_nContainerVersion++;
	}

	SendUpdateNotice(SERVERMONITOR_UPDATENOTICE_MERITINFO);
}

void CServiceManager::UpdateChannelInfo(TServiceChannelInfo * pPacket)
{
	bool NeedNotice = false;
	{
		ScopeLock <CSyncLock> sync(m_Sync);

		std::map <INT64, tMonitorChannelInfo>::iterator ii;

		bool bNeedInclease = false;
		tMonitorChannelInfo Info;
		INT64 nKey = 0;
		for (int i = 0; i < pPacket->cCount; i++)
		{
			nKey = MAKE_SM_SVRCHN(pPacket->nManagedID, pPacket->Info[i].nChannelID);
			ii = m_ChannelList.find(nKey);
			if (ii != m_ChannelList.end())
				memcpy(&(*ii).second.Info, &pPacket->Info[i], sizeof(sChannelInfo));
			else
			{
				memset(&Info, 0, sizeof(Info));

				Info.nManagedID = pPacket->nManagedID;
				Info.nWorldID = pPacket->nWorldID;

				m_ChannelList.insert(std::make_pair(nKey, Info));
				bNeedInclease = true;
				NeedNotice = true;
			}
		}

		if (bNeedInclease)
			m_nContainerVersion++;
	}

	if (NeedNotice)
		SendUpdateNotice(SERVERMONITOR_UPDATENOTICE_CHANNELINFO);
}

int CServiceManager::GetMasterSIDByChannelID(int nWorldID, int nChannelID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ih;
	for (ih = m_ServiceList.begin(); ih != m_ServiceList.end(); ih++)
	{
		if (GetServerType((*ih).second->szType) == MANAGED_TYPE_MASTER)
		{
			for (int i = 0; i < WORLDCOUNTMAX; i++)
			{
				if ((*ih).second->cWorldIDs[i] <= 0) continue;
				if ((*ih).second->cWorldIDs[i] == nWorldID)
					return (*ih).second->nSID;
			}
		}
	}
	return -1;
}

bool CServiceManager::GetMasterSIDByGameSID(int nGameSID, int * pnMasterIDs)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	BYTE cWorldIDs[WORLDCOUNTMAX];
	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nGameSID);
	if (ii != m_ServiceList.end())
		memcpy(cWorldIDs, (*ii).second->cWorldIDs, sizeof(cWorldIDs));
	else
		return false;

	int nCount = 0;
	std::map <int, sServiceState*>::iterator ih;
	for (ih = m_ServiceList.begin(); ih != m_ServiceList.end(); ih++)
	{
		if (GetServerType((*ih).second->szType) == MANAGED_TYPE_MASTER)
		{
			for (int i = 0; i < WORLDCOUNTMAX; i++)
			{
				if (cWorldIDs[i] <= 0) continue;
				for (int h = 0; h < WORLDCOUNTMAX; h++)
				{
					if ((*ih).second->cWorldIDs[h] <= 0) continue;
					if (cWorldIDs[i] == (*ih).second->cWorldIDs[h])
						pnMasterIDs[nCount++] = (*ih).first;
				}
			}
		}
	}

	return true;
}

int CServiceManager::GetDBWorldIDBySID (int nSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, sServiceState*>::iterator ih;
	for (ih = m_ServiceList.begin(); ih != m_ServiceList.end(); ih++)
	{
		if (GetServerType((*ih).second->szType) == MANAGED_TYPE_DB)
		{
			for (int i = 0; i < WORLDCOUNTMAX; i++)
			{
				if ((*ih).second->cWorldIDs[i] <= 0) continue;
				if ((*ih).second->nSID == nSID)
					return (*ih).second->cWorldIDs[i];
			}
		}

	}

	return -1;
}

void CServiceManager::LauncherReturn(int nNID, int nIdx, ULONG nReturnPing)
{
	if (nIdx == -1)
	{
		g_Log.Log(LogType::_NORMAL, L"NetLauncher ReturnPing [NID:%d][Gap:%d]\n", nNID, timeGetTime() - nReturnPing);
		return;
	}

	ScopeLock <CSyncLock> sync(m_Sync);
	std::map <int, ULONG>::iterator ii = m_LaunchetTestList.find(nNID);
	if (ii != m_LaunchetTestList.end())
	{
		m_LaunchetTestList.erase(ii);
	}
}

void CServiceManager::CheckTestLauncher()
{
	ScopeLock <CSyncLock> sync(m_Sync);
	ULONG nCurTick = timeGetTime();
	std::map <int, ULONG>::iterator testItor;
	if (m_LaunchetTestList.size() > 0)
	{
		for (testItor = m_LaunchetTestList.begin(); testItor != m_LaunchetTestList.end(); )
		{
			if (nCurTick > (*testItor).second + (30 * 1000))
			{
				g_Log.Log(LogType::_ERROR, L"NetLauncher ping return delayed [NID:%d]\n", (*testItor).first);
				testItor = m_LaunchetTestList.erase(testItor);
			}
			else
				testItor++;
		}
	}
	else
		g_Log.Log(LogType::_NORMAL, L"All Launcher Test OK\n");
}

void CServiceManager::SelectJoin(int nMasterSID, int nSID, const WCHAR * pwszCharacterName)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetMID() == nMasterSID)
		{
			if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
				(*ii).second->SendSelectJoin(nSID, pwszCharacterName);
			else
				g_Log.Log(LogType::_ERROR, L"[SID:%d] Is not masterserver\n", nMasterSID);
			break;
		}
	}
}

void CServiceManager::ClearSelectJoin(int nMasterSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetMID() == nMasterSID)
		{
			if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
				(*ii).second->SendClearSelectjoin();
			else
				g_Log.Log(LogType::_ERROR, L"[SID:%d] Is not masterserver\n", nMasterSID);
			break;
		}
	}
}

void CServiceManager::SendServiceClose(__time64_t _tOderedTime, __time64_t _tCloseTime)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_GAME || (*ii).second->GetType() == MANAGED_TYPE_VILLAGE || (*ii).second->GetType() == MANAGED_TYPE_LOGIN)
			(*ii).second->SendScheduleCloseService(_tOderedTime, _tCloseTime);
	}
}

void CServiceManager::UpdateSaleData()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_CASH || (*ii).second->GetType() == MANAGED_TYPE_DB || (*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
			(*ii).second->SendUpdateSaleData();
	}
}

void CServiceManager::UpdateBanFile(const char * pUrl)
{
	if (pUrl == NULL)
		return;

	char szCurPath[MAX_PATH];
	GetCurrentDirectoryA(sizeof(szCurPath), szCurPath);

	std::wstring wstrUrl;
	ToWideString(const_cast<CHAR*>(pUrl), wstrUrl);

	std::wstring wstrDest;
	ToWideString(szCurPath, wstrDest);
	wstrDest.append(L"/BanFile.csv");

	if (_waccess(wstrDest.c_str(), 0) != -1)
	{
		if (DeleteFileW(wstrDest.c_str()) == 0)
			return;
	}
	
	if (m_UrlUpdater.UrlUpdateUrl(wstrUrl.c_str(), wstrDest.c_str()))
	{
		eBanFileType eBanType = _BANTYPE_MAX;
		std::vector <std_str> vBanList;

		TCHAR * pFile = NULL;
		pFile = ReadFile(L"BanFile.csv");
		if (pFile)			//<2F><><EFBFBD>ϸ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
		{
			std::vector<std::wstring> tokens;
			TokenizeW(pFile, tokens, L",");

			for (int i = 0; i < (int)tokens.size(); i++)
			{
				std_str strTempName = tokens[i];

				if (i == 0)
				{
					if (strTempName == _SZACCOUNTNAMETYPE)
						eBanType = _BANTYPE_ACCOUNTNAME;
					else if (strTempName == _SZACCOUNTIDTYPE)
						eBanType = _BANTYPE_ACCOUNTID;
					else if (strTempName == _SZCHARACTERNAMETYPE)
						eBanType = _BANTYPE_CHARACTERNAME;
					else
					{
						g_Log.Log(LogType::_FILELOG, L"UserBanFile Seperater Err [:%S]\n", strTempName);
						SAFE_DELETEARRAY(pFile);
						return;
					}
				}
				else
				{
					if (strTempName.size() > 0)
						vBanList.push_back(strTempName);
				}
			}

			SAFE_DELETEARRAY(pFile);
		}

		std::vector <std_str>::iterator ii;
		for (ii = vBanList.begin(); ii != vBanList.end(); ii++)
		{
			switch (eBanType)
			{
			case _BANTYPE_ACCOUNTNAME:
				UserBanbyAccountName((*ii).c_str());
				break;
			case _BANTYPE_CHARACTERNAME:
				UserBanbyCharacterName((*ii).c_str());
				break;
			case _BANTYPE_ACCOUNTID:
				UserBanbyAccountDBID(_wtoi((*ii).c_str()));
				break;
			}
		}
	}
}

void CServiceManager::UpdateFarm(int nWorldID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		(*ii).second->SendUpdateFarm(nWorldID);
	}
}

void CServiceManager::StartFarm()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		(*ii).second->SendUpdateFarm(0, true);
	}
}

void CServiceManager::ReqUpdateFarm()
{
	SendPacketToGsm(_T("msg=Farm,1"));
	CGsmCmdProcess::GetInstance()->AddCmdProcess("msg=Farm,1", "farmupdated", m_CmdTable.lpFarmUpdate);
}

void CServiceManager::UpdateFarm()
{
	g_pServiceManager->UpdateFarm(0);
}

void CServiceManager::UpdateFarmStatus (TServiceReportMaster* pPacket)
{	
	if (pPacket->nWorldID >= WORLDCOUNTMAX)
		return;

	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <int, std::vector<TFarmStatus>>& pFarmStatus = m_FarmStatus[pPacket->nWorldID];

	pFarmStatus.clear();

	for( int i=0; i<pPacket->cFarmCount; i++ )
	{
		std::map <int, std::vector<TFarmStatus>>::iterator managed_itor = pFarmStatus.find(pPacket->FarmStatus[i].nManagedID);
		if( managed_itor == pFarmStatus.end() )
		{
			std::vector<TFarmStatus> vList;
			vList.push_back(pPacket->FarmStatus[i]);
			pFarmStatus.insert (std::make_pair(pPacket->FarmStatus[i].nManagedID, vList));
		}
		else
		{
			std::vector<TFarmStatus>::iterator farm_itor = managed_itor->second.begin();

			bool bAddStatus = true;
			for (; farm_itor != managed_itor->second.end(); farm_itor++)
			{
				TFarmStatus& pStatus = *farm_itor;
				if (pStatus.nFarmDBID == pPacket->FarmStatus[i].nFarmDBID)
				{

					bAddStatus = false;
					if (pPacket->FarmStatus[i].bActivate)
						pStatus.nFarmCurUserCount = pPacket->FarmStatus[i].nFarmCurUserCount;
					else
						pStatus.nFarmCurUserCount = 0;

					break;
				}
			}

			if (bAddStatus)
				managed_itor->second.push_back(pPacket->FarmStatus[i]);
		}
	}
}

void CServiceManager::UpdateGuildWarSchedule()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
		{
			(*ii).second->SendUpdateGuildWarSchedule();
		}	
	}
}

void CServiceManager::SendUpdateGuildWare(int nGuildID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
		{
			(*ii).second->SendUpdateGuildWare(nGuildID);
		}	
	}
}

bool CServiceManager::IsService()
{
	bool bFlag = false;
	m_Sync.Lock();
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	if ((*ii).second->nState == _SERVICE_STATE_CREATE || (*ii).second->nState == _SERVICE_STATE_ONLINE)
	{
		bFlag = true;
		break;
	}
	m_Sync.UnLock();
	return bFlag;
}

bool CServiceManager::IsService(int nSID)
{
	bool bFlag = false;
	m_Sync.Lock();
	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		if ((*ii).second->nState == _SERVICE_STATE_CREATE || (*ii).second->nState == _SERVICE_STATE_ONLINE)
			bFlag = true;
	}
	m_Sync.UnLock();
	return bFlag;
}

bool CServiceManager::ReportServiceInfoLogin(int nSID, int nLoginUser)
{
	ScopeLock <CSyncLock> Lock(m_Sync);

	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		SendPacketToGsm(_T("msg=SInfo,%d,%d"), nSID, nLoginUser);
		return true;
	}
	return false;
}

bool CServiceManager::ReportServiceInfoVillage(int nSID, UINT nUserCount, int nCnt, TVillageUserReport * pReport)
{
	ScopeLock <CSyncLock> Lock(m_Sync);

	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		INT64 nKey = 0;
		for (int i = 0; i < nCnt; i++)
		{
			nKey = MAKE_SM_SVRCHN(nSID, pReport[i].nChannelID);
			std::map <INT64, tMonitorChannelInfo>::iterator itor = m_ChannelList.find(nKey);
			if (itor != m_ChannelList.end())
			{
				(*itor).second.Info.nCurrentUserCount = pReport[i].nChannelUserCount;
			}
		}

		char szCmdBuf[4096];
		memset(szCmdBuf, 0, sizeof(szCmdBuf));
		sprintf(szCmdBuf, "msg=SInfo,%d,%d,%d,", nSID, nUserCount, nCnt);

		int nLen = (int)strlen(szCmdBuf);
		memcpy_s(szCmdBuf + nLen, sizeof(szCmdBuf) - (nLen + 2), pReport, sizeof(TVillageUserReport) * nCnt);
		SendPacketToGsm(szCmdBuf, nLen + sizeof(TVillageUserReport) * nCnt);
		return true;
	}
	return false;
}

bool CServiceManager::ReportServiceMaster(int nSID, int nWorldID, UINT nWaitUserCount)
{
	ScopeLock <CSyncLock> Lock(m_Sync);

		SendPacketToGsm(L"msg=WInfo,%d,%d", nWorldID, nWaitUserCount);
		return true;
}

bool CServiceManager::ReportServiceInfoGame(int nSID, UINT nUserCount, UINT nRoomCount)
{
	ScopeLock <CSyncLock> Lock(m_Sync);
	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
	{
		SendPacketToGsm(L"msg=SInfo,%d,%d,%d", nSID, nUserCount, nRoomCount);
		return true;
	}
	return false;
}

void CServiceManager::ReportedServiceClosed(int nSID)
{
	g_Log.Log(LogType::_FILELOG, L"ReportedService Closed MID[%d]\n", nSID);
	
	ScopeLock <CSyncLock> sync(m_Sync);
	std::vector <_CLOSESERVICE>::iterator in;
	for (in = m_CloseServieList.begin(); in != m_CloseServieList.end(); in++)
	{
		if ((*in).nMID == nSID)
			(*in).nTerminateTick = timeGetTime();
	}
}

void CServiceManager::LauncherConnected(CLauncherSession * pSession)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	//1<><31>
	std::vector <TServerExcuteData> vExeList;
	CDataManager::GetInstance()->GetExeCommandList(pSession->GetSessionID(), &vExeList);
	bool bOther = CDataManager::GetInstance()->IsNeedOtherExcutePath(pSession->GetSessionID());
	pSession->SendManagingExeItem(&vExeList, bOther);

	//2<><32> <20><><EFBFBD><EFBFBD> <20>ٲٸ<D9B2> <20>ȵ<EFBFBD>~
	std::list <char> lList;
	CDataManager::GetInstance()->GetAssingedPatchTypeList(pSession->GetSessionID(), &lList);
	pSession->SendConnectedResult(&lList, g_Config.wszPatchBaseURL, g_Config.wszPatchURL);
}

bool CServiceManager::VerifyPatcher(const char * pIP)
{
	ScopeLock <CSyncLock> sync(m_Sync);
	std::vector <CPatcherSession*>::iterator ii;
	for (ii = m_vPatcherSessionList.begin(); ii != m_vPatcherSessionList.end(); ii++)
	{
		if (!strcmp((*ii)->GetIp(), pIP))
			return false;
	}
	return true;
}

bool CServiceManager::IsCloseService(int nSID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	if (nSID == 0)
	{
		bool bCheck = m_CloseServieList.empty() ? false : true;
		return bCheck;
	}
	else
	{
		std::vector <_CLOSESERVICE>::iterator ii;
		for (ii = m_CloseServieList.begin(); ii != m_CloseServieList.end(); ii++)
		{
			if ((*ii).nMID == nSID)
				return true;
		}
	}
	return false;
}

bool CServiceManager::ExcuteProcess(const TServerExcuteData * pExe, bool bForcePatch)
{
	std::map <UINT, CLauncherSession*>::iterator ii;
	ii = m_LauncherSessionList.find(pExe->nAssignedLauncherID);
	if (ii != m_LauncherSessionList.end())
	{
		sServiceState * pState = GetServiceState(pExe->nSID);
		if (pState && pState->nState != _SERVICE_STATE_CREATE && pState->nState != _SERVICE_STATE_ONLINE)
		{
			(*ii).second->SendRunProcess(pExe->nSID, pExe->nCreateCount, pExe->nCreateIndex, pExe->wszType, pExe->wstrExcuteData.c_str(), bForcePatch);
			s_ExcuteLog.Log(LogType::_FILELOG, L"ExcuteParam[%s]\n", pExe->wstrExcuteData.c_str());
			pState->Init();
			return true;
		}
		else
			g_Log.Log(LogType::_FILELOG, L"Service Already Online SID[%d]\n", pExe->nSID);
	}
	
	g_Log.Log(LogType::_FILELOG, L"NetLauncher Offline ID[%d]\n", pExe->nAssignedLauncherID);
	return false;
}

bool CServiceManager::MakeServiceList(int nSID, int nNetLauncherID, const TCHAR * pType, bool bForce)
{
	if (GetServiceState(nSID) != NULL)
		return false;

	sServiceState * pState = new sServiceState;
	memset(pState, 0, sizeof(sServiceState));
	
	pState->nSID = nSID;
	pState->nManagedLauncherID = nNetLauncherID;
	pState->nState = bForce == false ? _SERVICE_STATE_OFFLINE : _SERVICE_STATE_ONLINE;
	_tcscpy_s(pState->szType, pType);
	pState->bIsReConnect = false;
	m_ServiceList[pState->nSID] = pState;
	return true;
}

bool CServiceManager::MakeWorldList()
{
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if (GetServerType((*ii).second->szType) == MANAGED_TYPE_MASTER)
		{
			const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand((*ii).second->nSID);
			if (pExe)
			{
				int nWorldID = 0;
				GetFirstRightIntValue(L"mwi", pExe->wstrExcuteData.c_str(), nWorldID);
				(*ii).second->cWorldIDs[0] = nWorldID;
			}
		}
	}

	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		int nCount = 0;
		const TServerExcuteData * pExe = CDataManager::GetInstance()->GetCommand((*ii).second->nSID);
		if (pExe == NULL) continue;

		switch (GetServerType((*ii).second->szType))
		{
		//case MANAGED_TYPE_LOGIN:
		/*case MANAGED_TYPE_DB:
			{
				std::vector <std::wstring>::const_iterator ih;
				for (ih = pExe->strMasterCon.begin(); ih != pExe->strMasterCon.end(); ih++)
				{
					std::vector<std::wstring> tokens;
					TokenizeW((*ih), tokens, L" ");

					if (_wtoi(tokens[0].c_str()) > 0)
						(*ii).second->cWorldIDs[nCount++] = _wtoi(tokens[0].c_str());
					else if (_wtoi(tokens[0].c_str()) <= 0)
					{
						int nLast = _wtoi(tokens[1].c_str());
						for (int i = 0; i < nLast; i++)
							(*ii).second->cWorldIDs[nCount++] = i+1;
					}
				}
			}
			break;*/
		case MANAGED_TYPE_DB:
			{
				std::wstring wstrTempWorld;
				GetValueCount(L"wdb", pExe->wstrExcuteData, nCount);
				for (int h = 0; h < nCount; h++)
				{
					if (GetRightValueByIndex(L"wdb", pExe->wstrExcuteData, h, wstrTempWorld))
						(*ii).second->cWorldIDs[h] = _wtoi(wstrTempWorld.c_str());
					else
						_ASSERT_EXPR(0, L"[MakeWorldList] Can't find wdb");
				}
			}
			break;

		case MANAGED_TYPE_VILLAGE:
			{
				int nVMID = 0;
				if (GetFirstRightIntValue(L"vwid", pExe->wstrExcuteData.c_str(), nVMID) == false)
					_ASSERT_EXPR(0, L"[MakeWorldList] Can't find vwid");
				(*ii).second->cWorldIDs[0] = nVMID;
			}
			break;

		case MANAGED_TYPE_GAME:
			{
				std::wstring wstrTempWorld;
				GetValueCount(L"gwid", pExe->wstrExcuteData, nCount);
				for (int h = 0; h < nCount; h++)
				{
					if (GetRightValueByIndex(L"gwid", pExe->wstrExcuteData, h, wstrTempWorld))
						(*ii).second->cWorldIDs[h] = _wtoi(wstrTempWorld.c_str());
					else
						_ASSERT_EXPR(0, L"[MakeWorldList] Can't find gwid");
				}
			}
			break;
			
		case MANAGED_TYPE_CASH:
			{
				int nCashID = 0;
				if (GetFirstRightIntValue(L"cwid", pExe->wstrExcuteData.c_str(), nCashID) == false)
					_ASSERT_EXPR(0, L"[MakeWorldList] Can't find cwid");
				(*ii).second->cWorldIDs[0] = nCashID;
			}
			break;
		}
	}
	return true;
}

sServiceState * CServiceManager::GetServiceState(int nSID)
{
	std::map <int, sServiceState*>::iterator ii = m_ServiceList.find(nSID);
	if (ii != m_ServiceList.end())
		return (*ii).second;
	return NULL;
}

sServiceState * CServiceManager::GetServiceStateByServiceSession(int nServiceSessionID)
{
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)	
		if ((*ii).second->nServiceSessionID == nServiceSessionID)
			return (*ii).second;
	return NULL;
}

int CServiceManager::GetNeedResType(int nNetLauncherID)
{
	int nRet = 0;			//0 <20>ƹ<EFBFBD><C6B9>͵<EFBFBD> <20><><EFBFBD>ʿ<EFBFBD><CABF><EFBFBD> 1 VillageRes 2 GameRes
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
	{
		if ((*ii).second->nManagedLauncherID == nNetLauncherID)
		{
			if (_tcsstr((*ii).second->szType, _T("Game")))
				nRet = 2;
			else	if (_tcsstr((*ii).second->szType, _T("Login")) || _tcsstr((*ii).second->szType, _T("Master")) || _tcsstr((*ii).second->szType, _T("Village")) || _tcsstr((*ii).second->szType, _T("DB")))
				nRet = nRet >= 2 ? 2 : 1;
		}
	}
	return nRet;
}

void CServiceManager::DeleteManagedService(int nNetLauncherID)
{
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
		if ((*ii).second->nManagedLauncherID == nNetLauncherID)
			(*ii).second->Init();
}

void CServiceManager::ClearList()
{
	std::map <int, sServiceState*>::iterator ii;
	for (ii = m_ServiceList.begin(); ii != m_ServiceList.end(); ii++)
		SAFE_DELETE((*ii).second);
	m_ServiceList.clear();
}

void CServiceManager::SendPatchStart(int nNID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		(*ii).second->SendPatchStart();
	}
}

void CServiceManager::SendPatch(int nNID, const WCHAR * pKey, int nPatchID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		if ((*ii).second->SendPatch(pKey, GetNeedResType((*ii).second->GetSessionID()), nPatchID))
		{
			if (m_PatchWatcher.AddWatchContent(nPatchID, (*ii).second->GetSessionID(), pKey) == false)
				_DANGER_POINT();
		}
		else
		{
			g_Log.Log(LogType::_ERROR, L"SendPatch Fail Check netlauncher [NID:%d][IP:%S]\n", (*ii).second->GetSessionID(), (*ii).second->GetIp());
		}
	}
}

int CServiceManager::SendPatchEachItem(int nNID, const WCHAR * pURL, const WCHAR * pDest)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	char szTempURL[512];

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		WideCharToMultiByte(CP_ACP, 0, pURL, -1, szTempURL, 512, NULL, NULL);
		if (m_PatchWatcher.AddWatchContent(m_nPatchID, (*ii).second->GetSessionID(), L"Live"))
		{
			if ((*ii).second->SendPatchByUrl(m_nPatchID, szTempURL, L"Live", true, pDest) == false)
				g_Log.Log(LogType::_ERROR, L"LivePatchError [NID:%d] [IP:%s] [Url:%s]\n", (*ii).second->GetSessionID(), (*ii).second->GetwszIp(), pURL);
		}
	}
	int nPatchTemp = m_nPatchID;
	m_nPatchID++;
	return nPatchTemp;
}

void CServiceManager::SendPatchEnd(int nNID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		(*ii).second->SendPatchEnd();
	}
}

void CServiceManager::SendInfoCopy(int nNID)
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CLauncherSession*>::iterator ii;
	for (ii = m_LauncherSessionList.begin(); ii != m_LauncherSessionList.end(); ii++)
	{
		if (nNID > 0 && (*ii).second->GetSessionID() != nNID)
			continue;

		(*ii).second->SendInfoCopy(CDataManager::GetInstance()->IsNeedOtherExcutePath((*ii).first));
	}
}

void CServiceManager::SendCreatEachDB(int nWorldID)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_LOGIN)
			(*ii).second->SendCreatEachDB(nWorldID);

	m_Sync.UnLock();
}

void CServiceManager::SendReloadGuildwar(int nWorldID)
{
	m_Sync.Lock();

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_MASTER)
			(*ii).second->SendReloadSchedule(nWorldID);

	m_Sync.UnLock();
}


void CServiceManager::SendChangeLimiteItemMax(int nSN, int nLimitMax)
{
	ScopeLock <CSyncLock> sync(m_Sync);
	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
		if ((*ii).second->GetType() == MANAGED_TYPE_CASH)
			(*ii).second->SendChangeLimitedItemMax(nSN, nLimitMax);
}


bool CServiceManager::AmountTokenizedString(char * pExtStr, int nExtMaxSize, std::vector<std::string> &vStr, int nStartCount, int nEndCount)
{
	int nLen = 0;
	for (int i = nStartCount; i < (int)vStr.size() && i < nEndCount; i++)
	{
		int nTempLen = (int)strlen(vStr[i].c_str());
		if (nTempLen + nLen >= nExtMaxSize)
			return false;
		_strcpy(pExtStr+nLen, vStr[i].c_str(), nTempLen);
		nLen += nTempLen;
		pExtStr[nLen++] = ' ';
	}
	if(nLen < nExtMaxSize)
		pExtStr[nLen] = '\0';
	else
		return false;
	return true;
}

int CServiceManager::GetServiceCount(int nServiceType, std::map <UINT, int> * pmList)
{
	//Need Sync
	int nCount = 0;

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == nServiceType)
		{
			pmList->insert(std::make_pair((*ii).second->GetMID(), (*ii).second->GetType()));
			nCount++;
		}
	}

	return nCount;
}

int CServiceManager::GetVillageServiceCount()
{
	//Need Sync
	int nCount = 0;

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
			nCount++;
	}

	return nCount;
}

int CServiceManager::GetGameServiceCount()
{
	//Need Sync
	int nCount = 0;

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_GAME)
			nCount++;
	}

	return nCount;
}

bool CServiceManager::GetChannelInfo(int nChannelID, short & nMeritID, int & nLimitLevel, bool & bVisibility, bool & bShow)
{
	//Need Sync
	std::map <INT64, tMonitorChannelInfo>::iterator ii;
	for (ii = m_ChannelList.begin(); ii != m_ChannelList.end(); ii++)
	{
		if ((*ii).second.Info.nChannelID == nChannelID)
		{
			nMeritID = (*ii).second.Info.nMeritBonusID;
			nLimitLevel = (*ii).second.Info.nLimitLevel;
			bVisibility = (*ii).second.Info.bVisibility;
			bShow = (*ii).second.Info.bShow;

			return true;
		}
	}
	return false;
}

void CServiceManager::ReportToGSMServiceState(int nSID, int nServiceState, const char * pVersion, const char * pRevision)
{
	switch (nServiceState)
	{
	case _SERVICE_STATE_OFFLINE:
		{
			SendPacketToGsm(_T("msg=PInfo,%d,Terminated"), nSID);
			break;
		}

	case _SERVICE_STATE_CREATE:
		{
			SendPacketToGsm(_T("msg=PInfo,%d,Create"), nSID);
			break;
		}

	case _SERVICE_STATE_ONLINE:
		{
			SendPacketToGsm(_T("msg=PInfo,%d,Online,%S,%S"), nSID, pVersion, pRevision);
			break;
		}

	case _SERVICE_STATE_TERMINATED:
		{
			SendPacketToGsm(_T("msg=PInfo,%d,Terminated"), nSID);
			break;
		}
	}
}

void CServiceManager::ReportToMonitorServiceState(int nSID, int nServiceState, int nServiceException, const char * pDetail)
{
	//NeedSync
	std::vector <CMonitorSession*>::iterator ii;
	for (ii = m_MonitorSessionList.begin(); ii != m_MonitorSessionList.end(); ii++)
		(*ii)->SendUpdateServerState(nSID, nServiceState, nServiceException, pDetail);
}

void CServiceManager::AddServerDelayMID(int nType, int nMID)
{
	if (m_vServerDelayMIDs[nType].size() > SERVICEMANAGER_SERVERDEALY_SIZE)
		return;

	m_vServerDelayMIDs[nType].push_back(nMID);
};

void CServiceManager::ReportToMonitorServerDelay(int nType)
{
	if (m_vServerDelayMIDs[nType].size() <= 0)
		return;

	//NeedSync
	std::vector <CMonitorSession*>::iterator ii;
	for (ii = m_MonitorSessionList.begin(); ii != m_MonitorSessionList.end(); ii++)
		(*ii)->SendServerDelayInfo(nType, m_vServerDelayMIDs[nType]);
	m_vServerDelayMIDs[nType].clear();
}

bool CServiceManager::SendPacketToGsm(const WCHAR * fmt, ...)
{
	WCHAR buf[4096];
	va_list arg;
	va_start(arg, fmt);
	_vsntprintf(buf, _countof(buf), fmt, arg);
	
	char szMsg[4096];
	WideCharToMultiByte(CP_ACP, 0, buf, -1, szMsg, 4096, NULL, NULL);

	bool bRet = SendPacketToGsm(szMsg, (int)strlen(szMsg));

	va_end(arg);
	return bRet;
}

bool CServiceManager::SendPacketToGsm(char * fmt, int nSize)
{
	if (m_bHttpSendFail)
	{
		if (m_nHttpFailTick + (60 * 1000) > timeGetTime())
			return false;
		else
		{
			m_bHttpSendFail = false;
			m_nHttpFailTick = 0;
		}
	}

	_SYNCGSMTASK task;
	memset(&task, 0, sizeof(_SYNCGSMTASK));

	task.nSize = (short)(nSize + sizeof(short));
	STRCPYA(task.szMsg, 4096, fmt);

	m_pStoredPacketBuffer->Lock();

	int nRet = m_pStoredPacketBuffer->Push(&task, task.nSize);
	if (nRet < 0)
		_DANGER_POINT();

	m_pStoredPacketBuffer->UnLock();
	g_pServiceServer->AddSyncCall();
	return true;
}

TCHAR * CServiceManager::ReadFile(const TCHAR * fname)
{
	char * ptr;
	int len;

	FILE *fp;
	fp = _tfopen(fname, _T("rb"));
	if (fp == NULL)
		return NULL;
	fseek(fp, 0, SEEK_END);
	len = ftell(fp);
	if( len < 0 )
	{
		fclose(fp);
		return NULL;
	}
	fseek(fp, 0, SEEK_SET);
	ptr = new char [len+2];
	fread(ptr, 1, len, fp);
	fclose(fp);

	ptr[len] = '\0';
	ptr[len+1] = '\0';

	static unsigned char _unicodeset[] = {
		0xff, 0xfe
	} ;
	if (!memcmp(ptr, _unicodeset, 2))
	{	//	<09><><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD> <20><><EFBFBD><EFBFBD>
#ifdef UNICODE
		TCHAR * wptr = new TCHAR [(len-2) / sizeof(TCHAR) + 1];
		memcpy(wptr, &ptr[2], (len+2) - 2);
		delete [] ptr;
		return wptr;
#else
		char * bptr = new char [len*2 + 1];
		memset(bptr, 0, len*2 + 1);
		WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)&ptr[2], (len-2)/2, bptr, len*2 + 1, NULL, NULL);
		delete [] ptr;
		return bptr;
#endif
	}	else
	{
#ifdef UNICODE
		TCHAR * wptr = new TCHAR [len + 1];
		memset(wptr, 0, sizeof(TCHAR) * (len+1));
		MultiByteToWideChar(CP_ACP, 0, ptr, len, wptr, len+1);
		delete [] ptr;
		return wptr;
#else
		return ptr;
#endif
	}
}

void CServiceManager::SendUpdateWorldPvPRoom()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
		{
			(*ii).second->SendUpdateWorldPvPRoom();
		}	
	}
}

void CServiceManager::SendCreateGambleRoom(int nRoomIndex, int nRegulation, int nGambleType, int nPrice )
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
		{
			(*ii).second->SendCreateGambleRoom( nRoomIndex, nRegulation, nGambleType, nPrice);
		}	
	}
}

void CServiceManager::SendStopGambleRoom()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
		{
			(*ii).second->SendStopGambleRoom();
		}	
	}
}

void CServiceManager::SendDelGambleRoom()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE)
		{
			(*ii).second->SendDelGambleRoom();
		}	
	}
}

void CServiceManager::SendUpdateDWCStatus()
{
	ScopeLock <CSyncLock> sync(m_Sync);

	std::map <UINT, CServiceSession*>::iterator ii;
	for (ii = m_ServiceSessionList.begin(); ii != m_ServiceSessionList.end(); ii++)
	{
		if ((*ii).second->GetType() == MANAGED_TYPE_VILLAGE || (*ii).second->GetType() == MANAGED_TYPE_LOGIN)
		{
			(*ii).second->SendUpdateDWCStatus();
		}	
	}
}

#if defined (_SERVICEMANAGER_EX)
bool CServiceManager::IsStartAllLauncherAndContinue(void)
{
	//<2F><><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD>Ʈ<EFBFBD><C6AE> <20><><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD> <20><><EFBFBD><EFBFBD> <20>ٸ<EFBFBD><D9B8><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>ڿ<EFBFBD><DABF><EFBFBD> <20><>ġ<EFBFBD><C4A1> <20>Ұ<EFBFBD><D2B0><EFBFBD><EFBFBD><EFBFBD> Ȯ<><C8AE> <20><> <20><><EFBFBD><EFBFBD>
	int nNotConnectCnt = CDataManager::GetInstance()->GetLauncherCount() - (int)m_LauncherSessionList.size();
	if(nNotConnectCnt > 0)
	{	
		if( AfxMessageBox(L"Find Offline Launcher!\nPatch Conitnue?", MB_YESNO) == IDNO)
			return false;
	}
	return true;
}
bool CServiceManager::IsRunLauncher(void){ 
	if(m_LauncherSessionList.empty())
		return false;

	return true; 
}
void CServiceManager::GetPartitionList(OUT vector<const TPartitionInfo*>& list) const
{
	CDataManager::GetInstance()->GetPartitionList(list);
}

void CServiceManager::GetPartitionText(OUT wchar_t text[256]) const
{
	CDataManager::GetInstance()->GetPartitionText(text);
}

void CServiceManager::GetWorldList(OUT vector<const TServerInfo*>& list) const
{
	CDataManager::GetInstance()->GetWorldList(list);
}

void CServiceManager::GetLauncherList(OUT vector<const TNetLauncher*>& list) const
{
	CDataManager::GetInstance()->GetLauncherList(list);
}

void CServiceManager::GetServiceServerList(OUT vector<const sServiceState*>& list) const
{
	for each (map<int, sServiceState*>::value_type v in m_ServiceList)
	{
		list.push_back(v.second);
	}
}

const TDefaultServerInfo& CServiceManager::GetDefaultServerInfo() const
{
	return CDataManager::GetInstance()->GetDefaultServerInfo();
}

const TDefaultDatabaseInfo& CServiceManager::GetDefaultDatabaseInfo() const
{
	return CDataManager::GetInstance()->GetDefaultDatabaseInfo();
}

const TServerInfo* CServiceManager::GetWorldInfo(int id) const
{
	return CDataManager::GetInstance()->GetServerInfo(id);
}

const TNetLauncher* CServiceManager::GetLauncherInfo(int id) const
{
	return CDataManager::GetInstance()->GetLauncherInfobyID(id);
}

const TServerExcuteData* CServiceManager::GetServerExecuteData(int id) const
{
	return CDataManager::GetInstance()->GetCommand(id);
}

void CServiceManager::GetActiveLaunchers(OUT vector<int>& list) const
{
	for each (map<UINT, CLauncherSession*>::value_type v in m_LauncherSessionList)
	{
		list.push_back(v.first);
	}
}

bool CServiceManager::IsLauncherConnected(int id) const
{
	map<UINT, CLauncherSession*>::const_iterator it = m_LauncherSessionList.find(id);
	if (it == m_LauncherSessionList.end())
		return false;

	return true;
}

void CServiceManager::OnPatchStart()
{
	m_pApp->OnPatchStart();
}

void CServiceManager::OnPatchProgress(int id, const wchar_t* key, unsigned long progress, unsigned long progressMax)
{
	m_pApp->OnPatchProgress(id, key, progress, progressMax);
}

void CServiceManager::OnPatchEnd()
{
	m_pApp->OnPatchEnd(m_bPatchComplete);
}

void CServiceManager::OnUnzipProgress(int id, const wchar_t* filename, unsigned long progress, unsigned long progressMax)
{
	m_pApp->OnUnzipProgress(id, filename, progress, progressMax);
}

void CServiceManager::OnWorldMaxUser(int id, int maxUser)
{
	m_pApp->OnWorldMaxUser(id, maxUser);
}

void CServiceManager::OnPatchFail(int id, const wchar_t* msg)
{
	m_pApp->OnPatchFail(id, msg);
}

void CServiceManager::OnPatchCompleted(int id)
{
	m_pApp->OnPatchCompleted(id);
}

void CServiceManager::BuildExceptionReport(size_t days, wstring& buffer) const
{
	m_pApp->ReportExceptionToBuffer(days, buffer);
}

void CServiceManager::OnCommandPatch()
{
	m_pApp->OnCommandPatch();
}

void CServiceManager::InitializeCommand()
{
	m_Commands.clear();

	m_Commands.insert(make_pair(L"makeselfdump", 0));
	m_Commands.insert(make_pair(L"testgsm", 0));
	m_Commands.insert(make_pair(L"reload", 0));
	m_Commands.insert(make_pair(L"reloaduser", 0));
	m_Commands.insert(make_pair(L"resetclose", 0));
	m_Commands.insert(make_pair(L"start", 0));
	m_Commands.insert(make_pair(L"starteach", 0));
	m_Commands.insert(make_pair(L"starteachbylauncher", 0));
	m_Commands.insert(make_pair(L"stopforce", 0));
	m_Commands.insert(make_pair(L"stopforceeach", 0));
	m_Commands.insert(make_pair(L"stopforceeachbylauncher", 0));
	m_Commands.insert(make_pair(L"stopall", 0));
	m_Commands.insert(make_pair(L"cancelstop", 0));
	m_Commands.insert(make_pair(L"stopdb", 0));
	m_Commands.insert(make_pair(L"stopeach", 0));
	m_Commands.insert(make_pair(L"stopeachbylauncher", 0));
	m_Commands.insert(make_pair(L"patchurl", 0));
	m_Commands.insert(make_pair(L"patchstruct", 0));
	m_Commands.insert(make_pair(L"patchinfo", 0));
	m_Commands.insert(make_pair(L"patchsystem", 0));
	m_Commands.insert(make_pair(L"patchconfig", 0));
	m_Commands.insert(make_pair(L"patchexe", 0));
	m_Commands.insert(make_pair(L"patchfull", 0));
	m_Commands.insert(make_pair(L"patchapply", 0));
	m_Commands.insert(make_pair(L"infocopy", 0));
	m_Commands.insert(make_pair(L"patch", 0));
	m_Commands.insert(make_pair(L"patchdyncode", 0));
	m_Commands.insert(make_pair(L"patchcash", 0));
	m_Commands.insert(make_pair(L"cancelpatchcash", 0));
	m_Commands.insert(make_pair(L"filelist", 0));
	m_Commands.insert(make_pair(L"notice", 0));
	m_Commands.insert(make_pair(L"noticeall", 0));
	m_Commands.insert(make_pair(L"noticechannel", 0));
	m_Commands.insert(make_pair(L"noticeserver", 0));
	m_Commands.insert(make_pair(L"noticezone", 0));
	m_Commands.insert(make_pair(L"cancelnotice", 0));
	m_Commands.insert(make_pair(L"worldmaxuser", 0));
	m_Commands.insert(make_pair(L"channelcontrol", 0));
	m_Commands.insert(make_pair(L"populationcontrol", 0));
	m_Commands.insert(make_pair(L"affinitycontrol", 0));
	m_Commands.insert(make_pair(L"eventupdate", 0));
	m_Commands.insert(make_pair(L"makedumpall", 0));
	m_Commands.insert(make_pair(L"makedumpeach", 0));
	m_Commands.insert(make_pair(L"reservenotice", 0));
	m_Commands.insert(make_pair(L"userban", 0));
	m_Commands.insert(make_pair(L"userbanid", 0));
	m_Commands.insert(make_pair(L"restraint", 0));
	m_Commands.insert(make_pair(L"startlauncher", 0));
	m_Commands.insert(make_pair(L"stoplauncher", 0));
	m_Commands.insert(make_pair(L"starteachlauncher", 0));
	m_Commands.insert(make_pair(L"stopeachlauncher", 0));
	m_Commands.insert(make_pair(L"patchlauncher", 0));
	m_Commands.insert(make_pair(L"patchlaunchereach", 0));
	m_Commands.insert(make_pair(L"checkpatch", 0));
	m_Commands.insert(make_pair(L"clearpatch", 0));
	m_Commands.insert(make_pair(L"checklauncher", 0));
	m_Commands.insert(make_pair(L"testlauncher", 0));
	m_Commands.insert(make_pair(L"checktestlauncher", 0));
	m_Commands.insert(make_pair(L"reloaddyncode", 0));
	m_Commands.insert(make_pair(L"checkalivelauncher", 0));
	m_Commands.insert(make_pair(L"selectjoin", 0));
	m_Commands.insert(make_pair(L"clearselectjoin", 0));
	m_Commands.insert(make_pair(L"updatesale", 0));
	m_Commands.insert(make_pair(L"patchbatch", 0));
	m_Commands.insert(make_pair(L"runbatch", 0));
	m_Commands.insert(make_pair(L"runbatcheach", 0));
	m_Commands.insert(make_pair(L"stopbatch", 0));
	m_Commands.insert(make_pair(L"checkbatch", 0));
	m_Commands.insert(make_pair(L"userbanfile", 0));
	m_Commands.insert(make_pair(L"farmupdate", 0));
	m_Commands.insert(make_pair(L"farmupdated", 0));
	m_Commands.insert(make_pair(L"farmstart", 0));
	m_Commands.insert(make_pair(L"guildwarupdate", 0));
	m_Commands.insert(make_pair(L"createdb", 0));
}
#endif // #if defined (_SERVICEMANAGER_EX)