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

#include "stdafx.h"
#include "SendManagePacket.h"

#include <tchar.h>
#include <Network/Session/Session.h>
#include <Network/Dispatch/Dispatch.h>
#include <Network/Packet/WrapPacket.h>
#include <Network/Packet/ManagePacketCmd.h>
#include <Stream/Buffer/Buffer.h>
#include <Stream/Buffer/BufferFactory.h>
#include <Utility/Compress/MiniLZO/MiniLZOWrapper.h>

#include <UserManage/ToolUserManageTable.h>
#include <Log/ServerLog.h>


/*!
	\brief				관리 패킷 전송
	\param Session		세션
	\param cCmd			커맨드
	\param nMessage 	윈도우 메시지 번호
	\param wParam		WPARAM
	\param lParam		LPARAM
	\param dwRunID		RunID
	\param usDataLen	데이터 길이
	\param usFlags		추가 데이터 플래그
	\param lpData		보낼 데이터
	\param cError		에러 커맨드
	\return				패킷 전송 성공 여부
*/
bool ServerManage::SendManagePacket(CSession& Session,						
                                    unsigned char cCmd,						
                                    unsigned int nMessage,					
                                    WPARAM wParam,							
                                    LPARAM lParam,							
                                    unsigned long dwRunID,                  
                                    unsigned short usDataLen,				
                                    unsigned short usFlags,                 
                                    const void* lpData,						
                                    unsigned char cError)					
{
	CBuffer* lpBuffer = CREATE_BUFFER(Session.GetPolicy().GetBufferFactory(), 
        (sizeof(ManageCommand) + usDataLen));

	if(0 != lpBuffer)
	{
		ManageCommand* lpManageCommand = reinterpret_cast<ManageCommand*>(lpBuffer->wr_ptr());

		lpManageCommand->nMessage			= nMessage;							// 메시지 번호
		lpManageCommand->wParam				= wParam;							// 파라미터1
		lpManageCommand->lParam				= lParam;							// 파라미터2

		lpManageCommand->dwRunID            = dwRunID;						    // 메세지 받을 곳의 IP
		lpManageCommand->usDataLen			= (0 != lpData) ? usDataLen : 0;	// 추가 데이터 길이
        lpManageCommand->usFlags			= usFlags;							// 기타 커맨드 (내용에 따라서 다름)
				
		if(0 != lpData)
		{
			memcpy(reinterpret_cast<char*>(lpManageCommand + 1), lpData, usDataLen);
		}

		if(PacketWrap::WrapCrypt(lpBuffer, sizeof(ManageCommand) + usDataLen, cCmd, 0, cError)
			&& Session.SendPending(lpBuffer))
		{
			return true;
		}

		SAFE_RELEASE_BUFFER(lpBuffer);
	}

	return false;
}

/*!
	\brief					관리 패킷 전송
	\param bufferFactory	BufferFactory
	\param lpTarget			세션. 0이면 Broadcast
	\param lpUserInfo 		유저 정보 (내부적으로 패스워드만 제거하고 보낸다)
	\param cUserInfoNum		유저 정보 개수
	\param cCommand			커맨드.
	\param cError			에러.	
	\return					패킷 전송 성공 여부
*/
bool ServerManage::SendUserInfo(CBufferFactory& bufferFactory,			
							 CSession* lpTarget,						
							 const ServerManage::UserInfo* lpUserInfo,	
							 unsigned char cUserInfoNum,				
							 unsigned char cCommand,					
							 unsigned char cError)						
{
	// 다른 유저들에게 자신이 추가되었다는 메시지를 던진다.
	CBuffer* lpBuffer = CREATE_BUFFER(bufferFactory,
		sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum);

	CBuffer* lpCompressedBuffer = CREATE_BUFFER(bufferFactory,
		CMiniLZO::GetLeastCompressBuffer(sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum));

	if(0 != lpBuffer && 0 != lpCompressedBuffer)
	{
		ServerManage::UserCommand* lpUserCommand	= reinterpret_cast<ServerManage::UserCommand*>(lpBuffer->wr_ptr());
		ServerManage::UserInfo*	lpFirstUserInfo	= reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);	
		ServerManage::UserInfo*	lpLastUserInfo	= lpFirstUserInfo + cUserInfoNum;

		lpUserCommand->cUserInfoNum = cUserInfoNum;			
		std::copy(lpUserInfo, lpUserInfo + cUserInfoNum, lpFirstUserInfo);

		for(ServerManage::UserInfo* lpTempUserInfo = lpFirstUserInfo;
			lpTempUserInfo != lpLastUserInfo; ++lpTempUserInfo)
		{
			memset(lpTempUserInfo->szPassword, 0, sizeof(ServerManage::UserInfo::PASS_LEN) * sizeof(TCHAR));
		}

		if(PacketWrap::WrapCompress(lpCompressedBuffer, lpBuffer->rd_ptr(), 
			sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * cUserInfoNum,
			cCommand, 0, cError))
		{
			if(lpTarget)
			{
				if(lpTarget->SendPending(lpCompressedBuffer))
				{					
					SAFE_RELEASE_BUFFER(lpBuffer);
					return true;
				}
			}
			else
			{
                CToolUserManager::GetInstance().SendToAllLoginUser(
					lpCompressedBuffer->rd_ptr(), lpCompressedBuffer->length(), lpUserCommand->GetCmd());

				SAFE_RELEASE_BUFFER(lpCompressedBuffer);
				SAFE_RELEASE_BUFFER(lpBuffer);
				return true;
			}
		}
	}

    SAFE_RELEASE_BUFFER(lpCompressedBuffer);
	SAFE_RELEASE_BUFFER(lpBuffer);
	return false;
}

bool ServerManage::CheckUserPacketLength(PktBase* lpPktBase, int nExpectUserInfoNum)
{
	PktBase::LengthType nLength = lpPktBase->GetLen();

	if(nLength < sizeof(ServerManage::UserCommand))
	{
		return false;
	}

	ServerManage::UserCommand*  lpUserCommand   = reinterpret_cast<ServerManage::UserCommand*>(lpPktBase);
	ServerManage::UserInfo*     lpUserInfo      = reinterpret_cast<ServerManage::UserInfo*>(lpUserCommand + 1);

	if(0 < nExpectUserInfoNum)
	{
		if(nExpectUserInfoNum != lpUserCommand->cUserInfoNum ||
			nLength != sizeof(ServerManage::UserCommand) + sizeof(ServerManage::UserInfo) * nExpectUserInfoNum)
		{
            ERRLOG2(g_Log, "Invalid packet size : userinfo num : %d, packet size : %d",
				lpUserCommand->cUserInfoNum, nLength);

			return false;
		}
	}
	else if(nLength != sizeof(ServerManage::UserCommand))
	{
		return false;
	}

	return true;
}


bool ServerManage::CheckManagePacketLength(PktBase* lpPktBase)
{
	unsigned short usPacketLength = lpPktBase->GetLen();

	ServerManage::ManageCommand* lpManageCommand = 
		reinterpret_cast<ServerManage::ManageCommand*>(lpPktBase);

	if(usPacketLength < sizeof(ServerManage::ManageCommand) ||
		(usPacketLength != lpManageCommand->usDataLen + sizeof(ServerManage::ManageCommand)))
	{
		ERRLOG2(g_Log, "Invalid packet size : DataLen : %d, Packet size : %d",
			lpManageCommand->usDataLen, lpPktBase->GetLen());
		return false;
	}

	return true;
}


ServerManage::CSendManagePacketToClient::CSendManagePacketToClient(ManageCommand& manageCommand,
                                                                   const char* lpData)
:	m_ManageCommand(manageCommand),
	m_lpData(lpData)
{

}

bool ServerManage::CSendManagePacketToClient::operator() (CPacketDispatch& dispatch)
{
	return SendManagePacket(dispatch.GetSession(), 
		m_ManageCommand.GetCmd(), m_ManageCommand.nMessage, 
		m_ManageCommand.wParam, m_ManageCommand.lParam,
		m_ManageCommand.dwRunID, m_ManageCommand.usDataLen, m_ManageCommand.usFlags, 
        m_lpData, static_cast<unsigned char>(m_ManageCommand.GetError()));
}