khanat-opennel-code/code/ryzom/server/src/frontend_service/uid_impulsions.cpp

334 lines
9.6 KiB
C++
Raw Normal View History

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "uid_impulsions.h"
#include "game_share/generic_xml_msg_mngr.h"
#include "game_share/msg_client_server.h"
#include "game_share/synchronised_message.h"
#include "frontend_service.h"
#include "fe_receive_sub.h"
using namespace std;
using namespace NLMISC;
using namespace NLNET;
extern CGenericXmlMsgHeaderManager GenericXmlMsgHeaderMngr;
void cbImpulsionUidGatewayOpen(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle);
void cbImpulsionUidGatewayMessage(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle);
void cbImpulsionUidGatewayClose(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle);
/*
* Callbacks of messages with special data handling
*/
//-----------------------------------------------
// impulsionSelectChar :
//-----------------------------------------------
static void impulsionSelectChar(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle)
{
// uint64 longUid = uid;
CSelectCharMsg selectCharMsg;
selectCharMsg.serial( bms );
// look for the user datas
CFeReceiveSub *frs = CFrontEndService::instance()->receiveSub();
CClientHost *ch = frs->findClientHostByUid(uid);
if (ch == NULL)
{
nlwarning("SELECT_CHAR: Nothing known about uid %u", uid);
return;
}
// TODO : ring : add character/role checking
//#pragma message (NL_LOC_MSG "Ring TODO : add R2 character/role checking")
// Check authorized character slot
if (((ch->AuthorizedCharSlot != 0xF) && (selectCharMsg.c != ch->AuthorizedCharSlot)) &&
(!CLoginServer::acceptsInvalidCookie()))
{
frs->rejectReceivedMessage( UnauthorizedCharacterSlot, uid );
cbDisconnectClient( uid , "FS impulsionSelectChar");
return;
}
CMessage msgout("SELECT_CHAR");
// msgout.serial( longUid );
msgout.serial( uid );
msgout.serial( selectCharMsg.c );
msgout.serial( ch->InstanceId );
CUnifiedNetwork::getInstance()->send("EGS", msgout);
nldebug( "User %u: SELECT_CHAR %u", uid, selectCharMsg.c );
}
//-----------------------------------------------
// impulsionRetMainland :
//-----------------------------------------------
static void impulsionRetMainland(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle)
{
uint8 charIndex;
bms.serial( charIndex );
TSessionId rejectedSessionId;
bms.serial( rejectedSessionId );
CMessage msgout("RET_MAINLAND" ); // always userId and index, never CEntityId even if client has is ingame
msgout.serial( uid );
msgout.serial( charIndex );
msgout.serial( rejectedSessionId );
CUnifiedNetwork::getInstance()->send("EGS", msgout);
}
//-----------------------------------------------
// impulsionAskChar :
//-----------------------------------------------
static void impulsionAskChar(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle)
{
uint64 longUid = uid;
CCheckNameMsg checkNameMsg;
checkNameMsg.serialBitMemStream( bms );
CMessage msgout("CHECK_NAME");
msgout.serial( longUid );
msgout.serial( checkNameMsg );
CUnifiedNetwork::getInstance()->send("EGS", msgout);
}
//-----------------------------------------------
// impulsionCreateChar :
//-----------------------------------------------
static void impulsionCreateChar(uint32 uid, NLMISC::CBitMemStream &bms, NLMISC::TGameCycle gameCycle)
{
uint64 longUid = uid;
CCreateCharMsg createCharMsg;
createCharMsg.serialBitMemStream( bms );
CMessage msgout("CREATE_CHAR");
msgout.serial( longUid );
msgout.serial( createCharMsg );
CUnifiedNetwork::getInstance()->send("EGS", msgout);
}
//-----------------------------------------------
// impulsionStringRequestUid
//
//-----------------------------------------------
static void impulsionStringRequestUid(uint32 uid, CBitMemStream &bms, TGameCycle gamecycle)
{
uint32 stringId;
try
{
bms.serial(stringId);
}
catch(const Exception &e)
{
nlwarning("<impulsionStringRequestUid> %s", e.what());
return;
}
CMessage msgout( "STRING_RQ_UID" );
msgout.serial( uid );
msgout.serial( stringId );
CUnifiedNetwork::getInstance()->send("IOS", msgout);
}
/*
* General receiving function for impulsions by Uid from client to server
*/
void routeImpulsionUidFromClient( NLMISC::CBitMemStream& bms, const uint32& userId, const NLMISC::TGameCycle& gamecycle )
{
string msgName;
try
{
// Decode XML header
CGenericXmlMsgHeaderManager::CNodeId msgNodeId = GenericXmlMsgHeaderMngr.getNodeId(bms, msgName);
// check if message decoded safely
if (!msgNodeId.isValid())
{
nlwarning("Unable to decode message from client %d", userId);
}
else
{
// get format and sendto of message
const CGenericXmlMsgHeaderManager::TMessageFormat &format = GenericXmlMsgHeaderMngr.getNodeFormat(msgNodeId);
const string &sendto = GenericXmlMsgHeaderMngr.getNodeSendTo(msgNodeId);
// check sendto
if (sendto == "")
{
TImpulsionUidCb cb = (TImpulsionUidCb)(GenericXmlMsgHeaderMngr.getNodeUserData(msgNodeId, 1));
if (cb == NULL)
{
nlwarning( "RTG: Can't route impulsion %s [uid %u], no 'sendto' nor user callback", msgName.c_str(), userId );
}
else
{
cb(userId, bms, gamecycle);
//nldebug( "RTG: Routed impulsion %s via user callback [uid %u]", msgName.c_str(), userId );
}
}
else
{
// create forward message
CMessage msgout("CLIENT:"+msgName);
uint64 longUserId = userId;
msgout.serial(longUserId);
union
{
bool b;
uint8 u8;
uint16 u16;
uint32 u32;
uint64 u64;
sint8 s8;
sint16 s16;
sint32 s32;
sint64 s64;
float f;
double d;
} store;
CEntityId e;
string s;
uint i;
// for each message field, serial in and serial out
for (i=0; i<format.size(); ++i)
{
switch (format[i].Type)
{
case CGenericXmlMsgHeaderManager::Bool:
bms.serial(store.b);
msgout.serial(store.b);
break;
case CGenericXmlMsgHeaderManager::Uint8:
bms.serial(store.u8);
msgout.serial(store.u8);
break;
case CGenericXmlMsgHeaderManager::Uint16:
bms.serial(store.u16);
msgout.serial(store.u16);
break;
case CGenericXmlMsgHeaderManager::Uint32:
bms.serial(store.u32);
msgout.serial(store.u32);
break;
case CGenericXmlMsgHeaderManager::Uint64:
bms.serial(store.u64);
msgout.serial(store.u64);
break;
case CGenericXmlMsgHeaderManager::Sint8:
bms.serial(store.s8);
msgout.serial(store.s8);
break;
case CGenericXmlMsgHeaderManager::Sint16:
bms.serial(store.s16);
msgout.serial(store.s16);
break;
case CGenericXmlMsgHeaderManager::Sint32:
bms.serial(store.s32);
msgout.serial(store.s32);
break;
case CGenericXmlMsgHeaderManager::Sint64:
bms.serial(store.s64);
msgout.serial(store.s64);
break;
case CGenericXmlMsgHeaderManager::BitSizedUint:
bms.serial(store.u32, format[i].BitSize);
if (format[i].BitSize <= 8)
{
store.u8 = (uint8)store.u32;
msgout.serial(store.u8);
}
else if (format[i].BitSize <= 16)
{
store.u16 = (uint16)store.u32;
msgout.serial(store.u16);
}
else
{
msgout.serial(store.u32);
}
break;
case CGenericXmlMsgHeaderManager::Float:
bms.serial(store.f);
msgout.serial(store.f);
break;
case CGenericXmlMsgHeaderManager::Double:
bms.serial(store.d);
msgout.serial(store.d);
break;
case CGenericXmlMsgHeaderManager::EntityId:
bms.serial(e);
msgout.serial(e);
break;
case CGenericXmlMsgHeaderManager::String:
bms.serial(s);
msgout.serial(s);
break;
}
}
// send message to concerned service
sendMessageViaMirror( sendto, msgout ); // because of guild management (ex: cbDeleteChar)
//nldebug( "RTG: Routed impulsion %s to %s [uid %u]", msgName.c_str(), sendto.c_str(), userId );
}
}
}
catch(const Exception &e)
{
nlwarning("<routeImpulsionUidFromClient> %s %s", msgName.c_str(), e.what() );
return;
}
} // cbImpulsionUid //
/*
* Map the callbacks for messages with special data handling
*/
void initImpulsionUid()
{
GenericXmlMsgHeaderMngr.setUserData("CONNECTION:SELECT_CHAR", (uint64)impulsionSelectChar, 1);
GenericXmlMsgHeaderMngr.setUserData("CONNECTION:CREATE_CHAR", (uint64)impulsionCreateChar, 1);
GenericXmlMsgHeaderMngr.setUserData("STRING_MANAGER:STRING_RQ", (uint64)impulsionStringRequestUid, 1);
GenericXmlMsgHeaderMngr.setUserData("CONNECTION:ASK_NAME", (uint64)impulsionAskChar, 1);
GenericXmlMsgHeaderMngr.setUserData("CONNECTION:RET_MAINLAND", (uint64)impulsionRetMainland, 1);
GenericXmlMsgHeaderMngr.setUserData("MODULE_GATEWAY:FEOPEN", (uint64)cbImpulsionUidGatewayOpen, 1);
GenericXmlMsgHeaderMngr.setUserData("MODULE_GATEWAY:GATEWAY_MSG", (uint64)cbImpulsionUidGatewayMessage, 1);
GenericXmlMsgHeaderMngr.setUserData("MODULE_GATEWAY:FECLOSE", (uint64)cbImpulsionUidGatewayClose, 1);
}