#include "stdafx.h"

#include <AgentServer.h>

#include <PacketStruct_ServerCommon.h>
#include <PacketStruct_AM.h>
#include <PacketStruct_CG.h>

#include "Handler_FromMasterServer.h"
#include "PacketHandler.Shared.h"

#include <ServerSessions/ServerSessionEx.h>
#include <ServerSessions/ServerSessionManager.h>

#include <UserSessions/User.h>
#include <UserSessions/UserManager.h>

#undef ADD_HANDLER_INFO_EOR
#undef ADD_HANDLER_INFO
#define ADD_HANDLER_INFO_EOR()	{ MAKEWORD(0, 0), PHASE_NOACTION, (PH_fnHandler)NULL }
#define ADD_HANDLER_INFO( c, p, accptablePHASE )		\
	{ MAKEWORD(c, p), (ePHASE_SHIFT)(accptablePHASE), (PH_fnHandler)&Handler_AM::On##p }


sPACKET_HANDLER_INFO*	Handler_AM::GetHandlerInfo()
{
	static sPACKET_HANDLER_INFO s_pHandlerInfo[] =
	{
        ADD_HANDLER_INFO( AM_CONNECTION, AM_CONNECTION_GROUND_CMD, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( AM_OPERATION, AM_OPERATION_CHAR_DISCONNECT_SYN, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( AM_OPERATION, AM_OPERATION_CHAR_DISCONNECT_ACK, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( AM_OPERATION, AM_OPERATION_LOGIC_VIOLATION_DISCONNECT_CMD, PHASE_UNLIMITED ),

		ADD_HANDLER_INFO( AM_CONNECTION, AM_CONNECTION_SERVER_INFO_CMD, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( SERVERCOMMON, SERVERCOMMON_SERVERSHUTDOWN_REQ, PHASE_UNLIMITED ),

#ifdef __WAVERIX_SOLAR_AUTH_SERVER_IMPLEMENTATION__
		//
		ADD_HANDLER_INFO( AM_CONNECTION, AM_CONNECTION_PHASE_SHIFT_CMD, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( SERVERCOMMON, SERVERCOMMON_DATA_TRANSFER_PLZ_GIVEME_DATA_ACK, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( SERVERCOMMON, SERVERCOMMON_DATA_TRANSFER_PLZ_GIVEME_DATA_NAK, PHASE_UNLIMITED ),
		ADD_HANDLER_INFO( SERVERCOMMON, SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD, PHASE_UNLIMITED ),
#endif
		ADD_HANDLER_INFO_EOR(),
	};

	return s_pHandlerInfo;
};

VOID	Handler_AM::RegisterHandler_ALL( PACKET_HANDLER_DELEGATOR pInstance )
{
	pInstance->RegisterHandler_<MASTER_SERVER>( GetHandlerInfo() );
	//pInstance->RegisterHandler_<MASTER_SERVER>( PacketHandlerShared::GetHandlerInfo() );
}

//
//
//

#undef FINDnALIGN_USER
#define FINDnALIGN_USER(pUserInstance, UserKey)							\
	User* pUserInstance = UserManager::Instance()->GetUser( (UserKey) );	\
	if( !pUserInstance )												\
	{																	\
		SUNLOG( eFULL_LOG, _T("[M2A] Can't Find User %u"), (UserKey) );	\
		return;															\
	}

HANDLER_AM_IMPL(AM_CONNECTION_GROUND_CMD)
{
    __UNUSED((pServerSession, pMsg, wSize));
}

HANDLER_AM_IMPL(AM_CONNECTION_SERVER_INFO_CMD)
{
    __TOUCHED((pServerSession, pMsg, wSize));
	MSG_AM_CONNECTION_SERVER_INFO_CMD* pRecvMsg = (MSG_AM_CONNECTION_SERVER_INFO_CMD*)pMsg;

	AgentServer* pAgentServer = AgentServer::GetInstance();
	SERVER_KEY rKey(pRecvMsg->m_ServerKey);

	pAgentServer->SetKey( pRecvMsg->m_ServerKey );

	SUNLOG( eCRITICAL_LOG, _T("¸¶½ºÅͷκÎÅÍ ¹ÞÀº ¼­¹öÅ° ¼ÂÆÃ(%u) (%u, %u, %u, %u)"),
		rKey, rKey.GetWorldID(), rKey.GetChannelID(), rKey.GetServerType(), rKey.GetServerID() );

	pAgentServer->UpdateAppTitle();

	//DWORD dwErrCode = 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szAgentServerInnerIP[0] == '0' || !pRecvMsg->m_wAgentServerInnerPort) ? 1 : 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szDBProxyServerIP[0] == '0' || !pRecvMsg->m_wDBProxyServerPort) ? 2 : 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szWorldServerIP[0] == '0' || !pRecvMsg->m_wWorldServerPort) ? 3 : 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szAuthAgentServerIP[0] == '0' || !pRecvMsg->m_wAuthAgentServerPort) ? 4 : 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szGuildServerIP[0] == '0' || !pRecvMsg->m_wGuildServerPort) ? 5 : 0;
	//if( !dwErrCode )
	//	dwErrCode = (pRecvMsg->m_szAgentServerIP[0] == '0' || !pRecvMsg->m_wAgentServerPort) ? 6 : 0;

	//////////////////////////////////////////////////////////////////////////
	if( !pAgentServer->SessionDBProxyServer() )
		pAgentServer->InitConnectSession( GAME_DBPROXY, pRecvMsg->m_szDBProxyServerIP, pRecvMsg->m_wDBProxyServerPort );
	if( !pAgentServer->SessionWorldServer() )
		pAgentServer->InitConnectSession( WORLD_SERVER, pRecvMsg->m_szWorldServerIP, pRecvMsg->m_wWorldServerPort );
	if( !pAgentServer->SessionAuthAgentServer() )
		pAgentServer->InitConnectSession( AUTH_AGENT_SERVER, pRecvMsg->m_szAuthAgentServerIP, pRecvMsg->m_wAuthAgentServerPort );

	pAgentServer->SetWorldServerClientAddr( pRecvMsg->m_szWorldServerClientIP, pRecvMsg->m_wWorldServerClientPort );

#ifndef __WAVERIX_SOLAR_AUTH_SERVER_IMPLEMENTATION__
	pAgentServer->ConnectTo( GAME_DBPROXY );
	pAgentServer->ConnectTo( WORLD_SERVER );
	pAgentServer->ConnectTo( AUTH_AGENT_SERVER );
	pAgentServer->SetListenIP_s( pRecvMsg->m_szAgentServerInnerIP );
	pAgentServer->SetListenPort_s( pRecvMsg->m_wAgentServerInnerPort );
	pAgentServer->SetListenIP_c( pRecvMsg->m_szAgentServerIP );
	pAgentServer->SetListenPort_c( pRecvMsg->m_wAgentServerPort );
	pAgentServer->Listen( SERVER_IOHANDLER );

#else //__WAVERIX_SOLAR_AUTH_SERVER_IMPLEMENTATION__
	pAgentServer->SetListenIP_s( pRecvMsg->m_szAgentServerInnerIP );
	pAgentServer->SetListenPort_s( pRecvMsg->m_wAgentServerInnerPort );
	pAgentServer->SetListenIP_c( pRecvMsg->m_szAgentServerIP );
	pAgentServer->SetListenPort_c( pRecvMsg->m_wAgentServerPort );
#endif //
}

HANDLER_AM_IMPL(SERVERCOMMON_SERVERSHUTDOWN_REQ)
{
    __TOUCHED((pServerSession, pMsg, wSize));
	// Á¤»óÁ¾·á µé¾î°£´Ù!
	AgentServer* pAgentServer = AgentServer::GetInstance();
	pAgentServer->SERVER_EXIT.StartServerExitProcess();

	// Á¾·áÇÑ´Ù°í ¾Ë·ÁÁà~
	MSG_SERVERCOMMON_SERVERSHUTDOWN_ANS	msgANS;

	msgANS.m_byCategory = SERVERCOMMON;
	msgANS.m_byProtocol = SERVERCOMMON_SERVERSHUTDOWN_ANS;

	pServerSession->Send( (BYTE*)&msgANS, sizeof(MSG_SERVERCOMMON_SERVERSHUTDOWN_ANS) );
}

//-------------------------------------------------------------------------------------------------
#ifdef __WAVERIX_SOLAR_AUTH_SERVER_IMPLEMENTATION__

#include <AgentServer.h>
#include <PacketStruct_ServerCommon.h>
#include <PacketStruct_AM.h>
#include <PacketHandler/PacketHandler.h>
#include <ServerSessions/MasterServerSession.h>
#include "Handler_FromMasterServer.h"

// MASTER SERVER "SM_CONNECTION_PHASE_SHIFT_CMD" º¯°æ½Ã ÂüÁ¶ÇØ¾ß ÇÑ´Ù.
// ¾ÖÃÊ, SM_CONNECTION_PHASE_SHIFT_CMD¸¦ ¼öÁ¤ÇÒ ¶§ ÀÏ°ýÀûÀ¸·Î º¯°æÇØ¾ß ÇÑ´Ù.
HANDLER_AM_IMPL( AM_CONNECTION_PHASE_SHIFT_CMD )
{
    __TOUCHED((pServerSession, pMsg, wSize));
	MSG_AM_CONNECTION_PHASE_SHIFT_CMD* pCMD = (MSG_AM_CONNECTION_PHASE_SHIFT_CMD*)pMsg;
	ePHASE_SHIFT ePhase = (ePHASE_SHIFT)pCMD->m_dwPHASE_SHIFT;

	ePhase = (ePHASE_SHIFT)(ePhase&PHASE_UNLIMITED);	// BLOCK CMDÀÏ ¼ö ÀÖ´Ù.
	ePHASE_SHIFT prevPhase = AgentServer::GetInstance()->GetPhaseStatus();

	switch( ePhase )
	{
	case PHASE_UNKNOWN:
		// ÀÎÁõ ´Ü°è¸¦ ´Ù½Ã °ÅÄ¡¶ó´Â ÀǹÌ
		break;
	case PHASE_EXCHANGE:
		{

			if( PHASE_EXCHANGE == prevPhase )
				return;

			AgentServer::GetInstance()->SetPhaseStatus( ePhase );

			if( PHASE_SERVICE == prevPhase )
			{
				// ´Ù½Ã EXCHANGE»óÅ·ΠÀüȯµÇ¾ú´Ù´Â °ÍÀº ¼­¹ö ¿¬°á »óÀÇ ¹®Á¦ ¶§¹®¿¡ Á¦¾àÀ»...
				// PHASE_SERVICE -> PHASE_EXCHANGE
				// ÀÌ°ÍÀº PROCESS_CONNECTION_PHASE_SHIFT_CMD___ON_START_EXCHANGE°¡ Á¸ÀçÇÑ´Ù´Â ÀǹÌ

				// µ¥ÀÌÅ͸¦ ´Ù½Ã ¹Þ¾Æ¾ß ÇÏ´ÂÁö µîµîÀ» NOTIFY_SIGNAL·Î ÇØ°áÇØ º¸ÀÚ.
				eSCRIPT_DATA_CMD cmd =
					SCRIPT_DATA_CMD::SET | SCRIPT_DATA_CMD::RANGE::ONENODE | SCRIPT_DATA_CMD::STATUS::MOVE2EMPTYDATA;
				ScriptDataManager::DataStatusCommand( cmd, SCRIPT_NOTIFY_SIGNAL );
			}
			else
			{
				//
				// PHASE_UNKNOWN -> PHASE_EXCHANGE
				//
				// ¼­ºñ½º·ÎÀÇ ÀüȯÀ̹ǷΠÆÄÀÏ Àü¼Ûµîµî, ¿©·¯°¡ÁöÀÇ SolarAuth°ü·Ã ¼­ºñ½º¸¦
				// ¹ÞÀ» ¼ö ÀÖ´Ù. ¶Ç´Â ÁÖ¾îÁø CMD¿¡ ´ëÇÑ Ã³¸®¸¦ ¼öÇàÇÒ ¼ö ÀÖ´Ù.
				// ÀÌ°÷¿¡¼­ WorkLoad¼³Á¤ÇÏ¸é µÈ´Ù.
				// ÀÌ°Í ÀÌ¿ÜÀÇ »óÅÂÀÏ °æ¿ì´Â °ü·Ã WorkLoad Á¦°ÅÇÏÀÚ. ¾Æ´Ï¸é Á¦°ÅµÇµµ·Ï ±¸¼ºÇÑ´Ù.

				// <THINKING2>
				//   ±âÁ¸¿¡ Á¾·áµÇÁö ¾Ê´Â ÀÛ¾÷ÀÌ ÀÖÀ» ¼ö ÀÖ´Ù. À̸¦ ¾î¶»°Ô ÇØ°áÇÒ °ÍÀΰ¡?
				//if( WorkLoadManager::c_NotExistKey ==
				//	pServerSession->GetWorkLoadContainer().FindWorkKey( scriptCode ) )

				PROCESS_CONNECTION_PHASE_SHIFT_CMD___ON_START_EXCHANGE* pWorkNode =
					new PROCESS_CONNECTION_PHASE_SHIFT_CMD___ON_START_EXCHANGE();

				pWorkNode->SetInformation( pServerSession, pServerSession->GetSyncKey(), (DWORD)PHASE_EXCHANGE );
				WORK_KEY workKey = WorkLoadManager::RegisterTask( pWorkNode );
				if( WorkLoadManager::c_NotExistKey != workKey )
				{
					pServerSession->GetWorkLoadContainer().RegisterWork( workKey, (DWORD)(__int64)pWorkNode );
					return;
				}
			}
		}
		break;
	case PHASE_SERVICE:
		{
			if( PHASE_UNKNOWN == prevPhase )
			{
				ASSERT( !"À߸øµÈ Á¦¾î »óÅ´٠ȮÀÎÇÒ °Í" );
				return;
			}
			else if( PHASE_SERVICE == prevPhase )
			{
				ASSERT( !"À߸øµÈ Á¦¾î »óÅ´٠ȮÀÎÇÒ °Í - ¹º°¡ Âø°¢ÇÑ °Í ¾Æ´Ñ°¡?" );
				return;
			}
			AgentServer* pAgentServer = AgentServer::GetInstance();
			pAgentServer->SetPhaseStatus( ePhase );

			pAgentServer->ConnectTo( GAME_DBPROXY );
			pAgentServer->ConnectTo( WORLD_SERVER );
			pAgentServer->ConnectTo( AUTH_AGENT_SERVER );
		}
		break;
	};

	//printf( "RECEIVED {AM_CONNECTION_PHASE_SHIFT_CMD} SEND {MSG_AM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN}\n" );
}

//
//HANDLER_AM_IMPL( AM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN )

HANDLER_AM_IMPL( SERVERCOMMON_DATA_TRANSFER_PLZ_GIVEME_DATA_ACK )
{
    __TOUCHED((pServerSession, pMsg, wSize));
}

HANDLER_AM_IMPL( SERVERCOMMON_DATA_TRANSFER_PLZ_GIVEME_DATA_NAK )
{
    __TOUCHED((pServerSession, pMsg, wSize));
}

HANDLER_AM_IMPL( SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD )
{
    __TOUCHED((pServerSession, pMsg, wSize));
	//printf( "RECEIVED {_DATA_TRANSFER_SENDDATA_CMD} " );

	MSG_SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD* pMsgCMD = (MSG_SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD*)pMsg;
	switch( (DWORD)pMsgCMD->m_wControlCmd )
	{
	case MSG_SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_HEADER:
		{
			DWORD dwDataType = (DWORD)pMsgCMD->m_FILE_INFO.m_wDataType;
			DWORD dwBufferSize = (DWORD)pMsgCMD->m_FILE_INFO.m_dwBufferSize;

			// <Work><Sequence>
			//   ÇØ´ç 󸮴 ÇöÀç µ¥ÀÌÅÍ ·ÎµùÀ» ¿äûÇÑ ÀÌÈÄ¿¡ ´ëÇÑ Ã¹¹ø° ÀÀ´ä¿¡ ´ëÇÑ ¹ÝÀÀÀÌ´Ù.
			// <1> ÇØ´ç ½ºÅ©¸³Æ® Äڵ尡 ¿Ã¹Ù¸¥ Áö °Ë»ç -> F : NAK
			// <2> T : ÇØ´ç ½ºÅ©¸³Æ® Äڵ忡 ¹öÆÛ¸¦ ÇÒ´çÇÑ´Ù.
			//     DataStreamCommand (SET blah~
			// <3> ±âŸ ŸÀӾƿôµîµîÀÇ º¸¾ÈÁ¤Ã¥À» °­±¸ÇÒ °Í

			//printf( "\n\tHEADER {Data Type=%u, Buffer Size = %u\n", dwDataType, dwBufferSize );

			BYTE* pSTREAM;

			eSCRIPT_DATA_CMD cmdSTREAM =
				SCRIPT_DATA_CMD::SET | SCRIPT_DATA_CMD::BUFFERINFO::BUFFER_SIZE;
			ScriptDataManager::DataStreamCommand( cmdSTREAM, (eSCRIPT_CODE)dwDataType, pSTREAM, dwBufferSize );

			eSCRIPT_DATA_CMD cmdSTATUS =
				SCRIPT_DATA_CMD::SET | SCRIPT_DATA_CMD::RANGE::ONENODE | SCRIPT_DATA_CMD::STATUS::MOVE2LOADING;
			ScriptDataManager::DataStatusCommand( cmdSTATUS, (eSCRIPT_CODE)dwDataType );
		}
		break;

	case MSG_SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_DATA:
		{
			DWORD dwDataType = (DWORD)pMsgCMD->m_TOKEN_INFO.m_Header.m_wDataType;
			DWORD dwTokenNo = (DWORD)pMsgCMD->m_TOKEN_INFO.m_Header.m_wTokenNo;
			DWORD dwBufferSize = (DWORD)pMsgCMD->m_TOKEN_INFO.m_Header.m_wBufferSize;

			// <Work><Sequence>
			//   ÇØ´ç 󸮴 ÇöÀç µ¥ÀÌÅÍ ·ÎµùÀ» ¿äû¿¡ ´ëÇÑ ÀÀ´äÀ» ó¸®Çϸç, ½ÇÀç µ¥ÀÌÅÍ°¡ ÀÔ·ÂµÇ¾î ¿Â´Ù.
			//   Á¾°áÀÚ°¡ ¿Ã¶§±îÁö ÇØ´ç ÅäÅ«¿¡ ÇØ´çÇÏ´Â À§Ä¡¿¡
			//   (ÇØ´ç ½ºÅ©¸³¿¡ ÇÒ´çµÈ ¹öÆÛ¸¦ ¾ò¾î¼­ ±× À§Ä¡¿¡) µ¥ÀÌÅ͸¦ º¹»çÇØ °£´Ù.
			//   DataStreamCommand (SET blah~

			ScriptDataManager::SaveDataStreamToken(
				(eSCRIPT_CODE)dwDataType,
				dwTokenNo,
				dwBufferSize,
				pMsgCMD->m_TOKEN_INFO.m_pSTREAM
				);

			//if( SCRIPT_CODE_KEY(FIELD) == dwDataType )
			//{
			//	//printf( "\n\tDATA {Data Type=%u, Token no = %u, Buffer Size = %u\n", dwDataType, dwTokenNo, dwBufferSize );
			//	printf( (CHAR*)pMsgCMD->m_TOKEN_INFO.m_pSTREAM );
			//	printf( "\n\nDELIM %u\n\n", pMsgCMD->m_TOKEN_INFO.m_pSTREAM[dwBufferSize-1] );
			//}
			//printf( "\n\tDATA {Data Type=%u, Token no = %u, Buffer Size = %u\n", dwDataType, dwTokenNo, dwBufferSize );

		}
		break;

	case MSG_SERVERCOMMON_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_CLOSURE:
		// ÀÌ°ÍÀ¸·Î Á¾·áÇϵµ·Ï ¼öÇàÇÏÀÚ.
		// ¿Ï·áµÇ¸é, ÇØ´ç ½ºÅ©¸³Æ® µ¥ÀÌÅÍ ¿Ï·á Äݹé(³»ºÎ ¿¬»ê ¸ñÀû)À» ¼öÇàÇÑ´Ù.
		//AsyncReloadData
		{
			DWORD dwDataType = (DWORD)pMsgCMD->m_FILE_CLOSURE.m_wDataType;
			DWORD dwCRC = (DWORD)pMsgCMD->m_FILE_CLOSURE.m_dwCRC;

			printf( "SCRIPT %u\t RECEIVED\n", dwDataType );

			eSCRIPT_DATA_CMD cmdSTATUS =
				SCRIPT_DATA_CMD::SET | SCRIPT_DATA_CMD::RANGE::ONENODE | SCRIPT_DATA_CMD::STATUS::MOVE2LOADED;

			ScriptDataManager::DataStatusCommand( cmdSTATUS, (eSCRIPT_CODE)dwDataType/*, dwCRC*/ );
			ScriptDataManager::ProcessLoadedData( (eSCRIPT_CODE)dwDataType );
		}
		break;
	};
}

//HANDLER_AM_IMPL( AM_DATA_TRANSFER_SENDDATA_ACK )
//HANDLER_AM_IMPL( AM_DATA_TRANSFER_SENDDATA_NAK )

#endif //__WAVERIX_SOLAR_AUTH_SERVER_IMPLEMENTATION__
//-------------------------------------------------------------------------------------------------

HANDLER_AM_IMPL(AM_OPERATION_CHAR_DISCONNECT_SYN)
{
    __TOUCHED((pServerSession, pMsg, wSize));
	MSG_AM_OPERATION_CHAR_DISCONNECT_SYN* pRecvMsg = (MSG_AM_OPERATION_CHAR_DISCONNECT_SYN*)pMsg;

	//1. Agent ¼­¹ö¿¡¼­ ÇØ´ç ij¸¯Å͸íÀÇ À¯Àú°¡ ÀÖ´ÂÁö °Ë»çÇÏ°í,
	//   À¯Àú°¡ ÀÖ´Ù¸é, ÇØ´ç ij¸¯Å͸¦ Á¾·á½ÃŲ´Ù.
	FINDnALIGN_USER( pUser, pRecvMsg->m_dwUserGuid );

	MSG_CG_CONNECTION_DISCONNECT_CMD msgCMD;
	msgCMD.m_dwErrorCode = RC::RC_CONNECTION_REQUESTFROMGAMESERVER;
	pUser->SendPacket( &msgCMD, sizeof(msgCMD) );

	// ÇØ´ç À¯Àú¸¦ Á¾·á½ÃŲ´Ù.
	pUser->SetDisconnectCode( RC::RC_DISCONNECT_REQ_MASTER );
	pUser->DisconnectUser();

	//¸¸ÀÏ °ÔÀÓ¼­¹ö¿¡¼­ Á¾·á½ÃÅ°Áö ¾Ê°í, Agent¿¡¼­ Á¾·á½ÃŲ´Ù¸é..
	MSG_AM_OPERATION_CHAR_DISCONNECT_ACK msgACK;
	msgACK.m_dwUserGuid = pRecvMsg->m_dwUserGuid;

	if( pServerSession )
		pServerSession->Send( (BYTE*)&msgACK, sizeof(msgACK) );
}

HANDLER_AM_IMPL(AM_OPERATION_CHAR_DISCONNECT_ACK)
{
    __TOUCHED((pServerSession, pMsg, wSize));
	MSG_AM_OPERATION_CHAR_DISCONNECT_ACK* pRecvMsg = (MSG_AM_OPERATION_CHAR_DISCONNECT_ACK*)pMsg;

	//1. °ÔÀÓ¼­¹ö¿¡¼­ ÇØ´ç À¯Àú¸¦ Á¾·á ½ÃÄ×À¸¹Ç·Î, ÀÌ °á°ú¸¦ MASTER¿¡°Ô Å뺸ÇÑ´Ù.
}

HANDLER_AM_IMPL(AM_OPERATION_LOGIC_VIOLATION_DISCONNECT_CMD)
{
    __TOUCHED((pServerSession, pMsg, wSize));
	MSG_AM_OPERATION_LOGIC_VIOLATION_DISCONNECT_CMD* pMsgCMD = (MSG_AM_OPERATION_LOGIC_VIOLATION_DISCONNECT_CMD*)pMsg;

	User* pUser = UserManager::Instance()->GetUser( pMsgCMD->UserGUID() );
	if( pUser )
	{
		SUNLOG( eCRITICAL_LOG, "User(%d) Abusing Forced Disconnect!", pMsgCMD->UserGUID() );

		// ÇØ´ç À¯ÀúÀÇ Disconnect
		SecurePackNode4User& rSECURE = pUser->GetSecureNode();
		rSECURE.ForcedDisconnectProcess( pUser );
	}
}