444 lines
16 KiB
C++
444 lines
16 KiB
C++
|
|
#include "stdafx.h"
|
|
|
|
#include <PacketStruct_SM.h>
|
|
|
|
#include <SolarAuthServer.h>
|
|
|
|
#include "PacketHandler.h"
|
|
#include "HandlerFromMasterServer.h"
|
|
|
|
#include "Sessions/MasterServerSession.h"
|
|
|
|
#include <Information/SolarAcceptableMasterServerListLoader.h>
|
|
#include <Information/ScriptLoadManager.h>
|
|
#include <Information/ScriptListLoader.h>
|
|
#include <Information/ScriptLoader.h>
|
|
#include <Information/ServerList/ServerInfo.h>
|
|
|
|
#include <WorkLoad/WorkLoadManager.h>
|
|
|
|
|
|
// WorkLoad Handlers
|
|
#include "HandlerFromMasterServer.WorkLoad.hxx"
|
|
|
|
|
|
#define SM_HANDLER_INFO_EOR() { MAKEWORD(0, 0), PHASE_NOACTION, (PH_fnHandler)NULL }
|
|
#define SM_HANDLER_INFO( c, p, accptablePHASE ) \
|
|
{ MAKEWORD(c, p), accptablePHASE, (PH_fnHandler)&HandlerFromMasterServer::On##p }
|
|
|
|
|
|
|
|
sPACKET_HANDLER_INFO* HandlerFromMasterServer::GetHandlerInfo()
|
|
{
|
|
static sPACKET_HANDLER_INFO s_pHandlerInfo[] =
|
|
{
|
|
//
|
|
SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_HEARTBEAT, (ePHASE_SHIFT)(PHASE_UNKNOWN|PHASE_SERVICE)),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_CONNECTION_SYN, PHASE_UNKNOWN ),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_CONNECTION_ACK, PHASE_UNKNOWN ),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_CONNECTION_NAK, PHASE_UNKNOWN ),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_DISCONNECT_CMD, PHASE_UNLIMITED),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_PHASE_SHIFT_CMD, PHASE_UNLIMITED),
|
|
//SM_HANDLER_INFO(SM_CONNECTION, SM_CONNECTION_BLOCK_CMD, PHASE_UNLIMITED),
|
|
//
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_DESTINATION_KEY_SYN, PHASE_EXCHANGE ),
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_DESTINATION_KEY_ACK, PHASE_EXCHANGE ),
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_DESTINATION_KEY_NAK, PHASE_EXCHANGE ),
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_QUERY_SYN, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_QUERY_ACK, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_QUERY_CMD, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_QUERY_NAK, PHASE_SERVICE),
|
|
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_AUTHENTICATION_SYN, PHASE_SERVICE ),
|
|
//SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_AUTHENTICATION_ACK, PHASE_SERVICE ),
|
|
//SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_AUTHENTICATION_NAK, PHASE_SERVICE ),
|
|
SM_HANDLER_INFO(SM_SERVER_INFO, SM_SERVER_INFO_CACHEITEM_REPORT_NTF, PHASE_SERVICE ),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_KEY, PHASE_EXCHANGE ),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_ACK, PHASE_EXCHANGE ),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_NAK, PHASE_EXCHANGE ),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_CMD, PHASE_EXCHANGE ),
|
|
SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_PACKET_ENCODED, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_PACKET_ENCODING, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_SNK_KEY, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_SNK_CMD, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_SNK_ACK, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_CRYPTOGRAPHY, SM_CRYPTOGRAPHY_SNK_NAK, PHASE_SERVICE),
|
|
//
|
|
SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_PLZ_GIVEME_DATA_ACK, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_PLZ_GIVEME_DATA_NAK, PHASE_SERVICE),
|
|
//SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_SENDDATA_CMD, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_SENDDATA_ACK, PHASE_SERVICE),
|
|
SM_HANDLER_INFO(SM_DATA_TRANSFER, SM_DATA_TRANSFER_SENDDATA_NAK, PHASE_SERVICE),
|
|
|
|
SM_HANDLER_INFO_EOR(),
|
|
};
|
|
|
|
return s_pHandlerInfo;
|
|
}
|
|
|
|
VOID HandlerFromMasterServer::RegisterHandler_ALL( PACKET_HANDLER_DELEGATOR pInstance )
|
|
{
|
|
//BOOL bResult =
|
|
pInstance->RegisterHandler_<MASTER_SERVER>( GetHandlerInfo() );
|
|
//
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_CONNECTION_HEARTBEAT )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
//
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_CONNECTION_SYN )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_CONNECTION_ACK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_CONNECTION_NAK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_DISCONNECT_CMD )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_PHASE_SHIFT_CMD )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CONNECTION_BLOCK_CMD )
|
|
|
|
//
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_DESTINATION_KEY_SYN )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_DESTINATION_KEY_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_DESTINATION_KEY_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_QUERY_SYN )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
// 마스터별 서버정보 목록은 이미 로딩한 상태가 전제된다.
|
|
// 서버 인증관련 매크로가 적용되지 않은 상태에서는 기존 루틴에 추가된 flow가 추가된 것으로 처리하라.
|
|
#ifdef __WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
SolarAcceptableMasterServerListLoaderDelegator& rMasterInfoManager =
|
|
ScriptLoadManager::Instance()->SolarAcceptableMasterServerListLoaderHandle;
|
|
ACCEPTABLE_MASTER_SERVER_INFO_DELEGATOR& rINFO = rMasterInfoManager->GetMasterServerByIP( pServerSession->GetIPAddress() );
|
|
ServerTreeINFO* pTREE = rINFO->GetServerTree();
|
|
|
|
MSG_SM_SERVER_INFO_QUERY_ACK* pMsgACK = NULL;
|
|
|
|
if( !pTREE )
|
|
{
|
|
MessageOut( eCRITICAL_LOG, _T("해당 마스터 서버 {%s}에 서버 목록이 존재하지 않습니다."), pServerSession->GetIP() );
|
|
return;
|
|
}
|
|
|
|
if( pTREE )
|
|
{
|
|
DWORD rdwUpper;
|
|
PSERVER_INFO_GENERIC pINFOs = pTREE->GetServerArrayList( rdwUpper );
|
|
PSERVER_INFO_GENERIC pINFO = pINFOs;
|
|
|
|
DWORD dwIdx = 0;
|
|
while( dwIdx < rdwUpper )
|
|
{
|
|
DWORD dwCount = 0;
|
|
pMsgACK = new (PACKET_CONTROL_SM::GetBasePacketPtr4Send()) MSG_SM_SERVER_INFO_QUERY_ACK;
|
|
|
|
sSERVER_INFO_GENERIC* pServerINFO = pMsgACK->m_ServerInfos;
|
|
for( ; dwIdx<rdwUpper ; ++dwIdx, ++pINFO )
|
|
{
|
|
if( pINFO->m_ServerType == UNKNOWN_SERVER )
|
|
continue;
|
|
|
|
*pServerINFO = *pINFO;
|
|
++dwCount;
|
|
++pServerINFO;
|
|
|
|
if( MSG_SM_SERVER_INFO_QUERY_ACK::_MAX_SERVERINFO_ARRAY_COUNT == dwCount )
|
|
{
|
|
++dwIdx;
|
|
++pINFO;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( dwCount )
|
|
{
|
|
pMsgACK->m_wCounts = (WORD)dwCount;
|
|
pServerSession->SendPacket( pMsgACK, pMsgACK->GetSize() );
|
|
dwCount = 0;
|
|
}
|
|
}
|
|
|
|
MSG_SM_SERVER_INFO_QUERY_CMD pMsgCMD[1];
|
|
pServerSession->SendPacket( pMsgCMD, sizeof(MSG_SM_SERVER_INFO_QUERY_CMD) );
|
|
|
|
MSG_SM_CONNECTION_PHASE_SHIFT_CMD pMsgCMD_SHIFT[1];
|
|
pMsgCMD_SHIFT->m_dwPHASE_SHIFT = (DWORD)PHASE_SERVICE;
|
|
|
|
pServerSession->SendPacket( pMsgCMD_SHIFT, sizeof(MSG_SM_CONNECTION_PHASE_SHIFT_CMD) );
|
|
printf( "SEND {MSG_SM_CONNECTION_PHASE_SHIFT_CMD} EXCHANGE->SERVICE\n" );
|
|
}
|
|
#else //__WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
#endif //__WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
}
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_SERVER_INFO_QUERY_ACK )
|
|
//HandlerFromMasterServer_IMPL( SM_SERVER_INFO_QUERY_CMD )
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_QUERY_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
// 서버 인증관련 매크로가 적용되지 않은 상태에서는 기존 루틴에 추가된 flow가 추가된 것으로 처리하라.
|
|
#ifdef __WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
#else //__WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
#endif //__WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL(SM_SERVER_INFO_AUTHENTICATION_SYN)
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_SM_SERVER_INFO_AUTHENTICATION_SYN* pMsgSYN = (MSG_SM_SERVER_INFO_AUTHENTICATION_SYN*)pMsg;
|
|
|
|
#ifdef __WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
SolarAcceptableMasterServerListLoaderDelegator& rMasterInfoManager =
|
|
ScriptLoadManager::Instance()->SolarAcceptableMasterServerListLoaderHandle;
|
|
ACCEPTABLE_MASTER_SERVER_INFO_DELEGATOR& rINFO = rMasterInfoManager->GetMasterServerByIP( pServerSession->GetIPAddress() );
|
|
ServerTreeINFO* pTREE = rINFO->GetServerTree();
|
|
|
|
if( !pTREE )
|
|
{
|
|
MessageOut( eCRITICAL_LOG, _T("해당 마스터 서버 {%s}에 서버 목록이 존재하지 않습니다."), pServerSession->GetIP() );
|
|
return;
|
|
}
|
|
|
|
SERVER_KEY skKey = pMsgSYN->m_ServerKey;
|
|
if( sSERVER_INFO_GENERIC* pSERVER_INFO = pTREE->FindServer( skKey ) )
|
|
{
|
|
if( pSERVER_INFO )
|
|
{
|
|
MSG_SM_SERVER_INFO_AUTHENTICATION_ACK pMsgACK[1];
|
|
pMsgACK->m_dwInnerIP = pMsgSYN->m_dwInnerIP;
|
|
pMsgACK->m_ServerInfo = *pSERVER_INFO;
|
|
pServerSession->SendPacket( pMsgACK, sizeof(MSG_SM_SERVER_INFO_AUTHENTICATION_ACK) );
|
|
|
|
CHAR strIP[2][MAX_IP_STRING_LEN+1];
|
|
CHAR* pIP = IPOperation::ConvertDWORD2StrIP(pSERVER_INFO->m_dwMasterIP);
|
|
memcpy( strIP[0], pIP, MAX_IP_STRING_LEN ); strIP[0][MAX_IP_STRING_LEN] = '\0';
|
|
pIP = IPOperation::ConvertDWORD2StrIP(pSERVER_INFO->m_dwInnerIP);
|
|
memcpy( strIP[1], pIP, MAX_IP_STRING_LEN ); strIP[1][MAX_IP_STRING_LEN] = '\0';
|
|
SERVER_KEY& rKey = pSERVER_INFO->m_ServerKey;
|
|
|
|
MessageOut( eCRITICAL_LOG,
|
|
_T("서버 인증 MasterIP {%s}\t인증된 서버 {%s}-[%02u][%02u][%s][%02u]"),
|
|
strIP[0], strIP[1], rKey.GetWorldID(), rKey.GetChannelID(),
|
|
GetServerType2String( pSERVER_INFO->m_ServerType ), rKey.GetServerID() );
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
MessageOut( eCRITICAL_LOG,
|
|
_T("해당 마스터 서버 {%s}에 인증 요청한 서버 정보[%02u:%02u:%02u:%02u]가 존재하지 않습니다."),
|
|
pServerSession->GetIP(), skKey.GetWorldID(), skKey.GetChannelID(), skKey.GetServerType(), skKey.GetServerID() );
|
|
|
|
return;
|
|
|
|
#endif //__WAVERIX_SERVER_AUTHENTICATION_BY_SOLARAUTH__
|
|
}
|
|
|
|
//HandlerFromMasterServer_IMPL(SM_SERVER_INFO_AUTHENTICATION_ACK)
|
|
//HandlerFromMasterServer_IMPL(SM_SERVER_INFO_AUTHENTICATION_NAK)
|
|
|
|
//
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_KEY )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_ACK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_NAK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_CMD )
|
|
|
|
HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_PACKET_ENCODED )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_PACKET_ENCODING )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_SNK_KEY )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_SNK_CMD )
|
|
|
|
HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_SNK_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_CRYPTOGRAPHY_SNK_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
}
|
|
|
|
//
|
|
HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_SM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN* pMsgSYN = (MSG_SM_DATA_TRANSFER_PLZ_GIVEME_DATA_SYN*)pMsg;
|
|
ScriptLoadManager* pLoadManager = ScriptLoadManager::Instance();
|
|
|
|
eSCRIPT_CODE scriptCode = (eSCRIPT_CODE)pMsgSYN->m_wDataType;
|
|
|
|
if( !(SCRIPT_CONTROL_FLAG_UPPERBOUNDARY > scriptCode) )
|
|
{
|
|
SCRIPT_RECORD_INFO_DELEGATOR& rRecord =
|
|
pLoadManager->ScriptListLoaderHandle->GetScriptInfo( scriptCode );
|
|
|
|
if( rRecord != NULL )
|
|
{
|
|
MSG_SM_DATA_TRANSFER_PLZ_GIVEME_DATA_ACK msgACK;
|
|
pServerSession->SendPacket( &msgACK, sizeof(msgACK) );
|
|
|
|
PROCESS_SM_DATA_TRANSFER_SENDDATA_CMD* pWorkCMD = new PROCESS_SM_DATA_TRANSFER_SENDDATA_CMD();
|
|
|
|
SCRIPT_DATA_STREAM_DELEGATOR rSTREAM_INFO =
|
|
ScriptLoadManager::GetScriptDataByIP( pServerSession->GetIPAddress(), scriptCode );
|
|
|
|
// (WAVERIX) (0807XX) (BUG-FIX) WorkKey의 중복 가능성 낮추기 위한 버그 수정
|
|
const DWORD ipaddress = pServerSession->GetIPAddress();
|
|
const WORK_KEY regWorkKey = (WORD)(
|
|
( (LOBYTE(LOWORD(ipaddress))+HIBYTE(LOWORD(ipaddress))) << 8 ) +
|
|
( (LOBYTE(HIWORD(ipaddress))+HIBYTE(HIWORD(ipaddress))) << 4 ) +
|
|
scriptCode);
|
|
|
|
Services4Session& rServices = pServerSession->Services();
|
|
if(rSTREAM_INFO != NULL &&
|
|
WorkLoadManager::c_NotExistKey == rServices.GetWorkLoadContainer().FindWorkKey( regWorkKey ) )
|
|
{
|
|
pWorkCMD->SetServerSession( pServerSession );
|
|
|
|
pWorkCMD->SetInformation(
|
|
rSTREAM_INFO->m_pDataStream, rSTREAM_INFO->m_CompressSize,rSTREAM_INFO->m_dwFileSize,
|
|
0, (WORD)scriptCode
|
|
);
|
|
|
|
WORK_KEY workKey = WorkLoadManager::RegisterTask( pWorkCMD, TRUE, regWorkKey );
|
|
if( WorkLoadManager::c_NotExistKey != workKey )
|
|
{
|
|
rServices.GetWorkLoadContainer().RegisterWork( workKey, (DWORD)(__int64)pWorkCMD );
|
|
MessageOut( eCRITICAL_LOG, _T("[%-16s] DATA_SYN(%u) -> ACCEPT -> SEND PROC"), pServerSession->GetIP(), scriptCode );
|
|
return;
|
|
}
|
|
}
|
|
|
|
SAFE_DELETE( pWorkCMD );
|
|
}
|
|
|
|
MessageOut( eCRITICAL_LOG, _T("[%-16s] DATA_SYN(%u) -> REJECT -> Already SendWorking or Can't Find Script"),
|
|
pServerSession->GetIP(), scriptCode );
|
|
}
|
|
else if( SCRIPT_NOTIFY_SIGNAL == scriptCode )
|
|
{
|
|
// NOTIFY_SIGNAL
|
|
MSG_SM_DATA_TRANSFER_SENDDATA_CMD* pMsgCMD =
|
|
new ( PACKET_CONTROL_SM::GetBasePacketPtr4Send() ) MSG_SM_DATA_TRANSFER_SENDDATA_CMD();
|
|
|
|
pMsgCMD->m_wControlCmd = MSG_SM_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_HEADER;
|
|
pMsgCMD->m_FILE_INFO.m_wDataType = SCRIPT_NOTIFY_SIGNAL;
|
|
pMsgCMD->m_FILE_INFO.m_dwBufferSize = 4;
|
|
pMsgCMD->m_FILE_INFO.m_dwCRC = 0;
|
|
pServerSession->SendPacket( pMsgCMD, pMsgCMD->GetSize() );
|
|
|
|
new ( PACKET_CONTROL_SM::GetBasePacketPtr4Send() ) MSG_SM_DATA_TRANSFER_SENDDATA_CMD();
|
|
pMsgCMD->m_wControlCmd = MSG_SM_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_DATA;
|
|
pMsgCMD->m_TOKEN_INFO.m_Header.m_wDataType = SCRIPT_NOTIFY_SIGNAL;
|
|
pMsgCMD->m_TOKEN_INFO.m_Header.m_wBufferSize = 4;
|
|
pMsgCMD->m_TOKEN_INFO.m_Header.m_wTokenNo = 0;
|
|
pMsgCMD->m_TOKEN_INFO.m_pSTREAM[0] = '0';
|
|
pMsgCMD->m_TOKEN_INFO.m_pSTREAM[1] = '0';
|
|
pMsgCMD->m_TOKEN_INFO.m_pSTREAM[2] = '0';
|
|
pMsgCMD->m_TOKEN_INFO.m_pSTREAM[3] = '\0';
|
|
pServerSession->SendPacket( pMsgCMD, pMsgCMD->GetSize() );
|
|
|
|
new ( PACKET_CONTROL_SM::GetBasePacketPtr4Send() ) MSG_SM_DATA_TRANSFER_SENDDATA_CMD();
|
|
pMsgCMD->m_wControlCmd = MSG_SM_DATA_TRANSFER_SENDDATA_CMD::TRANS_CMD_SEND_CLOSURE;
|
|
pMsgCMD->m_FILE_CLOSURE.m_wDataType = SCRIPT_NOTIFY_SIGNAL;
|
|
pMsgCMD->m_FILE_CLOSURE.m_dwCRC = 0;
|
|
pServerSession->SendPacket( pMsgCMD, pMsgCMD->GetSize() );
|
|
|
|
MessageOut( eCRITICAL_LOG, _T("[%-16s] NTF_SYN(%u) -> ACCEPT -> RAISE NEXT PROCESS"), pServerSession->GetIP(), scriptCode );
|
|
return;
|
|
}
|
|
|
|
MSG_SM_DATA_TRANSFER_PLZ_GIVEME_DATA_NAK msgNAK;
|
|
pServerSession->SendPacket( &msgNAK, sizeof(msgNAK) );
|
|
return;
|
|
|
|
|
|
|
|
|
|
//MSG_SM_DATA_TRANSFER_SENDDATA_CMD msgCMD;
|
|
//pServerSession->SendPacket( &msgCMD, sizeof(msgCMD) );
|
|
//printf( "SEND {SM_DATA_TRANSFER_SENDDATA_CMD}\n" );
|
|
}
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_PLZ_GIVEME_DATA_ACK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_PLZ_GIVEME_DATA_NAK )
|
|
|
|
//HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_SENDDATA_CMD )
|
|
|
|
HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_SENDDATA_ACK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
printf( "RECEIVED {SM_DATA_TRANSFER_SENDDATA_ACK}\n" );
|
|
}
|
|
|
|
HandlerFromMasterServer_IMPL( SM_DATA_TRANSFER_SENDDATA_NAK )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
printf( "RECEIVED {SM_DATA_TRANSFER_SENDDATA_ACK}\n" );
|
|
}
|
|
|
|
|
|
HandlerFromMasterServer_IMPL( SM_SERVER_INFO_CACHEITEM_REPORT_NTF )
|
|
{
|
|
__TOUCHED((pServerSession, pMsg, wSize));
|
|
MSG_SM_SERVER_INFO_CACHEITEM_REPORT_NTF* pNTF = (MSG_SM_SERVER_INFO_CACHEITEM_REPORT_NTF*)pMsg;
|
|
if( sizeof(*pNTF) != (SIZE_T)wSize )
|
|
{
|
|
MessageOut( eCRITICAL_LOG, _T("INVALID REPORT INFO") );
|
|
return;
|
|
}
|
|
//INFO.dwPriceGuid,
|
|
//rINFO.wItemCode,
|
|
//rINFO.wCategoryID,
|
|
//rINFO.dwPrice
|
|
sCACHEITEM_REPORT_INFO_MINORVER& rINFO = pNTF->m_INFO;
|
|
|
|
sSIG_REPORTFROMMASTERS SIG;
|
|
//SIG.MasterIP() = this->GetMaster
|
|
SIG.SessionRef() = pServerSession;
|
|
memset( &SIG.INFO(), 0, sizeof(SIG.INFO()) );
|
|
SIG.INFO().dwPriceGuid = rINFO.dwPriceGuid;
|
|
SIG.INFO().wItemCode = rINFO.wItemCode;
|
|
SIG.INFO().byCategoryID = rINFO.byCategoryID;
|
|
SIG.INFO().dwPrice = rINFO.dwPrice;
|
|
|
|
WORK_KEY wkKEY = SolarAuthServer::GetMainFrame()->GetReportWorkKey();
|
|
WorkLoadManager::OnMsg( &SIG, wkKEY );
|
|
|
|
//MessageOut( eCRITICAL_LOG, _T( "Received CacheItem Purchase Info" ) );
|
|
}
|
|
|