mirrors/sapphire
1
Fork 0
mirror of https://github.com/SapphireServer/Sapphire.git synced 2025-04-26 06:27:45 +00:00
Code Activity

clean up unnecessary namespace specialisation, flatten namespaces a bit

Browse source
This commit is contained in:
NotAdam 2019-06-07 18:12:35 +10:00
parent 6c176eb61d
commit fff6847e98
16 changed files with 97 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/api/PlayerMinimal.cpp
View file

@ -8,7 +8,7 @@
extern Sapphire::Data::ExdDataGenerated g_exdDataGen; extern Sapphire::Data::ExdDataGenerated g_exdDataGen;
namespace Sapphire::API { namespace Sapphire::Api {
using namespace Common; using namespace Common;

2
src/api/PlayerMinimal.h
View file

@ -5,7 +5,7 @@
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
namespace Sapphire::API namespace Sapphire::Api
{ {
class PlayerMinimal class PlayerMinimal

36
src/api/SapphireAPI.cpp → src/api/SapphireApi.cpp
View file

@ -1,4 +1,4 @@
#include "SapphireAPI.h" #include "SapphireApi.h"
#include <Crypt/base64.h> #include <Crypt/base64.h>
#include "Session.h" #include "Session.h"
#include "PlayerMinimal.h" #include "PlayerMinimal.h"
@ -10,9 +10,9 @@
#include <Database/DatabaseDef.h> #include <Database/DatabaseDef.h>
using namespace Sapphire::API; using namespace Sapphire::Api;
bool SapphireAPI::login( const std::string& username, const std::string& pass, std::string& sId ) bool SapphireApi::login( const std::string& username, const std::string& pass, std::string& sId )
{ {
std::string query = std::string query =
"SELECT account_id FROM accounts WHERE account_name = '" + username + "' AND account_pass = '" + pass + "';"; "SELECT account_id FROM accounts WHERE account_name = '" + username + "' AND account_pass = '" + pass + "';";
@ -55,7 +55,7 @@ bool SapphireAPI::login( const std::string& username, const std::string& pass, s
} }
bool SapphireAPI::insertSession( const uint32_t accountId, std::string& sId ) bool SapphireApi::insertSession( const uint32_t accountId, std::string& sId )
{ {
// create session for the new sessionid and store to sessionlist // create session for the new sessionid and store to sessionlist
auto pSession = std::make_shared< Session >(); auto pSession = std::make_shared< Session >();
@ -68,7 +68,7 @@ bool SapphireAPI::insertSession( const uint32_t accountId, std::string& sId )
} }
bool SapphireAPI::createAccount( const std::string& username, const std::string& pass, std::string& sId ) bool SapphireApi::createAccount( const std::string& username, const std::string& pass, std::string& sId )
{ {
// get account from login name // get account from login name
auto pQR = g_charaDb.query( "SELECT account_id FROM accounts WHERE account_name = '" + username + "';" ); auto pQR = g_charaDb.query( "SELECT account_id FROM accounts WHERE account_name = '" + username + "';" );
@ -98,11 +98,11 @@ bool SapphireAPI::createAccount( const std::string& username, const std::string&
} }
int SapphireAPI::createCharacter( const uint32_t accountId, const std::string& name, int SapphireApi::createCharacter( const uint32_t accountId, const std::string& name,
const std::string& infoJson, const std::string& infoJson,
const uint32_t gmRank ) const uint32_t gmRank )
{ {
API::PlayerMinimal newPlayer; Api::PlayerMinimal newPlayer;
newPlayer.setAccountId( accountId ); newPlayer.setAccountId( accountId );
newPlayer.setId( getNextCharId() ); newPlayer.setId( getNextCharId() );
@ -171,7 +171,7 @@ int SapphireAPI::createCharacter( const uint32_t accountId, const std::string& n
return newPlayer.getAccountId(); return newPlayer.getAccountId();
} }
void SapphireAPI::deleteCharacter( std::string name, const uint32_t accountId ) void SapphireApi::deleteCharacter( std::string name, const uint32_t accountId )
{ {
PlayerMinimal deletePlayer; PlayerMinimal deletePlayer;
auto charList = getCharList( accountId ); auto charList = getCharList( accountId );
@ -201,17 +201,17 @@ void SapphireAPI::deleteCharacter( std::string name, const uint32_t accountId )
g_charaDb.execute( "DELETE FROM charaquest WHERE CharacterId LIKE '" + std::to_string( id ) + "';" ); g_charaDb.execute( "DELETE FROM charaquest WHERE CharacterId LIKE '" + std::to_string( id ) + "';" );
} }
std::vector< PlayerMinimal > SapphireAPI::getCharList( uint32_t accountId ) std::vector< PlayerMinimal > SapphireApi::getCharList( uint32_t accountId )
{ {
std::vector< API::PlayerMinimal > charList; std::vector< Api::PlayerMinimal > charList;
auto pQR = g_charaDb.query( auto pQR = g_charaDb.query(
"SELECT CharacterId, ContentId FROM charainfo WHERE AccountId = " + std::to_string( accountId ) + ";" ); "SELECT CharacterId, ContentId FROM charainfo WHERE AccountId = " + std::to_string( accountId ) + ";" );
while( pQR->next() ) while( pQR->next() )
{ {
API::PlayerMinimal player; Api::PlayerMinimal player;
uint32_t charId = pQR->getUInt( 1 ); uint32_t charId = pQR->getUInt( 1 );
@ -222,7 +222,7 @@ std::vector< PlayerMinimal > SapphireAPI::getCharList( uint32_t accountId )
return charList; return charList;
} }
bool SapphireAPI::checkNameTaken( std::string name ) bool SapphireApi::checkNameTaken( std::string name )
{ {
g_charaDb.escapeString( name ); g_charaDb.escapeString( name );
@ -236,7 +236,7 @@ bool SapphireAPI::checkNameTaken( std::string name )
return true; return true;
} }
uint32_t SapphireAPI::getNextCharId() uint32_t SapphireApi::getNextCharId()
{ {
uint32_t charId = 0; uint32_t charId = 0;
@ -252,7 +252,7 @@ uint32_t SapphireAPI::getNextCharId()
return charId; return charId;
} }
uint64_t SapphireAPI::getNextContentId() uint64_t SapphireApi::getNextContentId()
{ {
uint64_t contentId = 0; uint64_t contentId = 0;
@ -268,7 +268,7 @@ uint64_t SapphireAPI::getNextContentId()
return contentId; return contentId;
} }
int SapphireAPI::checkSession( const std::string& sId ) int SapphireApi::checkSession( const std::string& sId )
{ {
auto it = m_sessionMap.find( sId ); auto it = m_sessionMap.find( sId );
@ -279,7 +279,7 @@ int SapphireAPI::checkSession( const std::string& sId )
} }
bool SapphireAPI::removeSession( const std::string& sId ) bool SapphireApi::removeSession( const std::string& sId )
{ {
auto it = m_sessionMap.find( sId ); auto it = m_sessionMap.find( sId );

10
src/api/SapphireAPI.h → src/api/SapphireApi.h
View file

@ -7,15 +7,15 @@
#include <memory> #include <memory>
#include "PlayerMinimal.h" #include "PlayerMinimal.h"
namespace Sapphire::API namespace Sapphire::Api
{ {
class Session; class Session;
class SapphireAPI class SapphireApi
{ {
public: public:
SapphireAPI() = default; SapphireApi() = default;
~SapphireAPI() = default; ~SapphireApi() = default;
using SessionMap = std::map< std::string, std::shared_ptr< Session > >; using SessionMap = std::map< std::string, std::shared_ptr< Session > >;
@ -30,7 +30,7 @@ namespace Sapphire::API
bool insertSession( uint32_t accountId, std::string& sId ); bool insertSession( uint32_t accountId, std::string& sId );
std::vector< API::PlayerMinimal > getCharList( uint32_t accountId ); std::vector< Api::PlayerMinimal > getCharList( uint32_t accountId );
bool checkNameTaken( std::string name ); bool checkNameTaken( std::string name );

2
src/api/Session.cpp
View file

@ -1,6 +1,6 @@
#include "Session.h" #include "Session.h"
using namespace Sapphire::API; using namespace Sapphire::Api;
Session::Session() Session::Session()
{ {

2
src/api/Session.h
View file

@ -5,7 +5,7 @@
#include <string> #include <string>
#include <string.h> #include <string.h>
namespace Sapphire::API namespace Sapphire::Api
{ {
class Session class Session

4
src/api/main.cpp
View file

@ -29,7 +29,7 @@
#include <Framework.h> #include <Framework.h>
#include <Logging/Logger.h> #include <Logging/Logger.h>
#include "SapphireAPI.h" #include "SapphireApi.h"
#include <Util/CrashHandler.h> #include <Util/CrashHandler.h>
@ -37,7 +37,7 @@ Sapphire::Common::Util::CrashHandler crashHandler;
Sapphire::Db::DbWorkerPool< Sapphire::Db::ZoneDbConnection > g_charaDb; Sapphire::Db::DbWorkerPool< Sapphire::Db::ZoneDbConnection > g_charaDb;
Sapphire::Data::ExdDataGenerated g_exdDataGen; Sapphire::Data::ExdDataGenerated g_exdDataGen;
Sapphire::API::SapphireAPI g_sapphireAPI; Sapphire::Api::SapphireApi g_sapphireAPI;
namespace fs = std::experimental::filesystem; namespace fs = std::experimental::filesystem;

2
src/common/Util/UtilMath.h
View file

@ -11,7 +11,7 @@ namespace Sapphire::Common::Util
float distanceSq( float x, float y, float z, float x1, float y1, float z1 ); float distanceSq( float x, float y, float z, float x1, float y1, float z1 );
float distance( float x, float y, float z, float x1, float y1, float z1 ); float distance( float x, float y, float z, float x1, float y1, float z1 );
float distance( const Sapphire::Common::FFXIVARR_POSITION3& pos1, const Sapphire::Common::FFXIVARR_POSITION3& pos2 ); float distance( const Common::FFXIVARR_POSITION3& pos1, const Common::FFXIVARR_POSITION3& pos2 );
float distance2DSq( float x, float y, float x1, float y1 ); float distance2DSq( float x, float y, float x1, float y1 );

4
src/lobby/Forwards.h
View file

@ -20,10 +20,6 @@ namespace Sapphire
namespace Sapphire::Lobby namespace Sapphire::Lobby
{ {
TYPE_FORWARD( LobbySession ); TYPE_FORWARD( LobbySession );
}
namespace Sapphire::Lobby::Network
{
TYPE_FORWARD( GameConnection ); TYPE_FORWARD( GameConnection );
} }

58
src/lobby/GameConnection.cpp
View file

@ -22,9 +22,9 @@ using namespace Sapphire::Network::Packets;
using namespace Sapphire::Network::Packets::Server; using namespace Sapphire::Network::Packets::Server;
extern Lobby::ServerLobby g_serverLobby; extern Lobby::ServerLobby g_serverLobby;
extern Lobby::Network::RestConnector g_restConnector; extern Lobby::RestConnector g_restConnector;
Lobby::Network::GameConnection::GameConnection( Sapphire::Network::HivePtr pHive, Lobby::GameConnection::GameConnection( Sapphire::Network::HivePtr pHive,
Sapphire::Network::AcceptorPtr pAcceptor, Sapphire::Network::AcceptorPtr pAcceptor,
FrameworkPtr pFw ) : FrameworkPtr pFw ) :
Sapphire::Network::Connection( pHive, pFw ), Sapphire::Network::Connection( pHive, pFw ),
@ -33,14 +33,14 @@ Lobby::Network::GameConnection::GameConnection( Sapphire::Network::HivePtr pHive
{ {
} }
Lobby::Network::GameConnection::~GameConnection() Lobby::GameConnection::~GameConnection()
{ {
} }
// overwrite the parents onConnect for our game socket needs // overwrite the parents onConnect for our game socket needs
void Lobby::Network::GameConnection::onAccept( const std::string& host, uint16_t port ) void Lobby::GameConnection::onAccept( const std::string& host, uint16_t port )
{ {
auto connection = make_GameConnection( m_hive, m_pAcceptor, m_pFw ); auto connection = make_GameConnection( m_hive, m_pAcceptor, m_pFw );
m_pAcceptor->accept( connection ); m_pAcceptor->accept( connection );
@ -49,12 +49,12 @@ void Lobby::Network::GameConnection::onAccept( const std::string& host, uint16_t
} }
void Lobby::Network::GameConnection::onDisconnect() void Lobby::GameConnection::onDisconnect()
{ {
Logger::debug( "DISCONNECT" ); Logger::debug( "DISCONNECT" );
} }
void Lobby::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer ) void Lobby::GameConnection::onRecv( std::vector< uint8_t >& buffer )
{ {
m_packets.insert( std::end( m_packets ), std::begin( buffer ), std::end( buffer ) ); m_packets.insert( std::end( m_packets ), std::begin( buffer ), std::end( buffer ) );
// This is assumed packet always start with valid FFXIVARR_PACKET_HEADER for now. // This is assumed packet always start with valid FFXIVARR_PACKET_HEADER for now.
@ -72,9 +72,9 @@ void Lobby::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
} }
// Dissect packet list // Dissect packet list
std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW > packetList; std::vector< FFXIVARR_PACKET_RAW > packetList;
const auto packetResult = Sapphire::Network::Packets::getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ), const auto packetResult = getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ),
packetHeader, packetList ); packetHeader, packetList );
if( packetResult == Incomplete ) if( packetResult == Incomplete )
return; return;
@ -92,31 +92,31 @@ void Lobby::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
} }
void Lobby::Network::GameConnection::onError( const asio::error_code& error ) void Lobby::GameConnection::onError( const asio::error_code& error )
{ {
Logger::info( "GameConnection closed: {0}", error.message() ); Logger::info( "GameConnection closed: {0}", error.message() );
} }
void void
Lobby::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId ) Lobby::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId )
{ {
auto errorPacket = makeLobbyPacket< FFXIVIpcLobbyError >( tmpId ); auto errorPacket = makeLobbyPacket< FFXIVIpcLobbyError >( tmpId );
errorPacket->data().seq = sequence; errorPacket->data().seq = sequence;
errorPacket->data().error_id = errorcode; errorPacket->data().error_id = errorcode;
errorPacket->data().message_id = messageId; errorPacket->data().message_id = messageId;
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
pRP.addPacket( errorPacket ); pRP.addPacket( errorPacket );
sendPacket( pRP ); sendPacket( pRP );
} }
void Lobby::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ) void Lobby::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{ {
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 ); uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
Logger::info( "Sequence [{0}]", sequence ); Logger::info( "Sequence [{0}]", sequence );
Logger::info( "[{0}] ReqCharList", m_pSession->getAccountID() ); Logger::info( "[{0}] ReqCharList", m_pSession->getAccountID() );
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
auto serverListPacket = makeLobbyPacket< FFXIVIpcServerList >( tmpId ); auto serverListPacket = makeLobbyPacket< FFXIVIpcServerList >( tmpId );
serverListPacket->data().seq = 1; serverListPacket->data().seq = 1;
@ -187,14 +187,14 @@ void Lobby::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, u
charListPacket->data().counter = ( i * 4 ) + 1; charListPacket->data().counter = ( i * 4 ) + 1;
charListPacket->data().unknown4 = 128; charListPacket->data().unknown4 = 128;
} }
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
pRP.addPacket( charListPacket ); pRP.addPacket( charListPacket );
sendPacket( pRP ); sendPacket( pRP );
} }
} }
void Lobby::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ) void Lobby::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{ {
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 ); uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
Logger::info( "Sequence [{0}]", sequence ); Logger::info( "Sequence [{0}]", sequence );
@ -223,7 +223,7 @@ void Lobby::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, ui
Logger::info( "[{0}] Logging in as {1} ({2})", m_pSession->getAccountID(), logInCharName, logInCharId ); Logger::info( "[{0}] Logging in as {1} ({2})", m_pSession->getAccountID(), logInCharName, logInCharId );
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
auto enterWorldPacket = makeLobbyPacket< FFXIVIpcEnterWorld >( tmpId ); auto enterWorldPacket = makeLobbyPacket< FFXIVIpcEnterWorld >( tmpId );
enterWorldPacket->data().contentId = lookupId; enterWorldPacket->data().contentId = lookupId;
@ -236,7 +236,7 @@ void Lobby::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, ui
sendPacket( pRP ); sendPacket( pRP );
} }
bool Lobby::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ) bool Lobby::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{ {
LobbySessionPtr pSession = g_serverLobby.getSession( ( char* ) &packet.data[ 0 ] + 0x22 ); LobbySessionPtr pSession = g_serverLobby.getSession( ( char* ) &packet.data[ 0 ] + 0x22 );
@ -261,7 +261,7 @@ bool Lobby::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW
serviceIdInfoPacket->data().u2 = 0x99; serviceIdInfoPacket->data().u2 = 0x99;
serviceIdInfoPacket->data().serviceAccount[ 0 ].id = 0x002E4A2B; serviceIdInfoPacket->data().serviceAccount[ 0 ].id = 0x002E4A2B;
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
pRP.addPacket( serviceIdInfoPacket ); pRP.addPacket( serviceIdInfoPacket );
sendPacket( pRP ); sendPacket( pRP );
} }
@ -275,7 +275,7 @@ bool Lobby::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW
return false; return false;
} }
bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ) bool Lobby::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{ {
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 ); uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
uint8_t type = *reinterpret_cast< uint8_t* >( &packet.data[ 0 ] + 0x29 ); uint8_t type = *reinterpret_cast< uint8_t* >( &packet.data[ 0 ] + 0x29 );
@ -294,7 +294,7 @@ bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& pa
Logger::info( "[{0}] Type 1: {1}", m_pSession->getAccountID(), name ); Logger::info( "[{0}] Type 1: {1}", m_pSession->getAccountID(), name );
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
m_pSession->newCharName = name; m_pSession->newCharName = name;
@ -325,7 +325,7 @@ bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& pa
if( g_restConnector.createCharacter( ( char* ) m_pSession->getSessionId(), m_pSession->newCharName, charDetails ) != if( g_restConnector.createCharacter( ( char* ) m_pSession->getSessionId(), m_pSession->newCharName, charDetails ) !=
-1 ) -1 )
{ {
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
auto charCreatePacket = makeLobbyPacket< FFXIVIpcCharCreate >( tmpId ); auto charCreatePacket = makeLobbyPacket< FFXIVIpcCharCreate >( tmpId );
charCreatePacket->data().content_id = newContentId; charCreatePacket->data().content_id = newContentId;
@ -367,7 +367,7 @@ bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& pa
charCreatePacket->data().unknown_7 = 1; charCreatePacket->data().unknown_7 = 1;
charCreatePacket->data().unknown_8 = 1; charCreatePacket->data().unknown_8 = 1;
Packets::LobbyPacketContainer pRP( m_encKey ); LobbyPacketContainer pRP( m_encKey );
pRP.addPacket( charCreatePacket ); pRP.addPacket( charCreatePacket );
sendPacket( pRP ); sendPacket( pRP );
} }
@ -383,7 +383,7 @@ bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& pa
return false; return false;
} }
void Lobby::Network::GameConnection::handleGamePacket( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet ) void Lobby::GameConnection::handleGamePacket( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet )
{ {
uint32_t tmpId = packet.segHdr.target_actor; uint32_t tmpId = packet.segHdr.target_actor;
@ -421,7 +421,7 @@ void Lobby::Network::GameConnection::handleGamePacket( Sapphire::Network::Packet
} }
void Lobby::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer& pLpc ) void Lobby::GameConnection::sendPacket( LobbyPacketContainer& pLpc )
{ {
uint16_t size = pLpc.getSize(); uint16_t size = pLpc.getSize();
uint8_t* dataPtr = pLpc.getRawData( false ); uint8_t* dataPtr = pLpc.getRawData( false );
@ -430,7 +430,7 @@ void Lobby::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer&
send( sendBuffer ); send( sendBuffer );
} }
void Lobby::Network::GameConnection::sendPackets( Sapphire::Network::Packets::PacketContainer* pPacket ) void Lobby::GameConnection::sendPackets( Sapphire::Network::Packets::PacketContainer* pPacket )
{ {
std::vector< uint8_t > sendBuffer; std::vector< uint8_t > sendBuffer;
@ -438,14 +438,14 @@ void Lobby::Network::GameConnection::sendPackets( Sapphire::Network::Packets::Pa
send( sendBuffer ); send( sendBuffer );
} }
void Lobby::Network::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket ) void Lobby::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket )
{ {
PacketContainer pRP = PacketContainer(); PacketContainer pRP = PacketContainer();
pRP.addPacket( pPacket ); pRP.addPacket( pPacket );
sendPackets( &pRP ); sendPackets( &pRP );
} }
void Lobby::Network::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase ) void Lobby::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase )
{ {
memset( m_baseKey, 0, 0x2C ); memset( m_baseKey, 0, 0x2C );
m_baseKey[ 0 ] = 0x78; m_baseKey[ 0 ] = 0x78;
@ -459,7 +459,7 @@ void Lobby::Network::GameConnection::generateEncryptionKey( uint32_t key, const
Common::Util::md5( m_baseKey, m_encKey, 0x2C ); Common::Util::md5( m_baseKey, m_encKey, 0x2C );
} }
void Lobby::Network::GameConnection::handlePackets( const Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader, void Lobby::GameConnection::handlePackets( const Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
const std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW >& packetData ) const std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW >& packetData )
{ {

34
src/lobby/GameConnection.h
View file

@ -16,10 +16,10 @@
#define DECLARE_HANDLER( x ) void x( Packets::GamePacketPtr pInPacket, Entity::PlayerPtr pPlayer ) #define DECLARE_HANDLER( x ) void x( Packets::GamePacketPtr pInPacket, Entity::PlayerPtr pPlayer )
namespace Sapphire::Lobby::Network namespace Sapphire::Lobby
{ {
class GameConnection : public Sapphire::Network::Connection class GameConnection : public Network::Connection
{ {
private: private:
@ -32,16 +32,16 @@ namespace Sapphire::Lobby::Network
bool m_bEncryptionInitialized; bool m_bEncryptionInitialized;
Sapphire::Network::AcceptorPtr m_pAcceptor; Network::AcceptorPtr m_pAcceptor;
LobbySessionPtr m_pSession; LobbySessionPtr m_pSession;
Common::Util::LockedQueue< Sapphire::Network::Packets::GamePacketPtr > m_inQueue; Common::Util::LockedQueue< Network::Packets::GamePacketPtr > m_inQueue;
Common::Util::LockedQueue< Sapphire::Network::Packets::GamePacketPtr > m_outQueue; Common::Util::LockedQueue< Network::Packets::GamePacketPtr > m_outQueue;
std::vector< uint8_t > m_packets; std::vector< uint8_t > m_packets;
public: public:
GameConnection( Sapphire::Network::HivePtr pHive, Sapphire::Network::AcceptorPtr pAcceptor, FrameworkPtr pFw ); GameConnection( Network::HivePtr pHive, Network::AcceptorPtr pAcceptor, FrameworkPtr pFw );
~GameConnection(); ~GameConnection();
@ -58,26 +58,26 @@ namespace Sapphire::Lobby::Network
void sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId ); void sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId );
void getCharList( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ); void getCharList( Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
void enterWorld( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ); void enterWorld( Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
bool sendServiceAccountList( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ); bool sendServiceAccountList( Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
bool createOrModifyChar( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId ); bool createOrModifyChar( Network::Packets::FFXIVARR_PACKET_RAW& packet, uint32_t tmpId );
void handlePackets( const Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader, void handlePackets( const Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
const std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW >& packetData ); const std::vector< Network::Packets::FFXIVARR_PACKET_RAW >& packetData );
void handleGamePacket( Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& pPacket ); void handleGamePacket( Network::Packets::FFXIVARR_PACKET_RAW& pPacket );
void handlePacket( Sapphire::Network::Packets::FFXIVPacketBasePtr pPacket ); void handlePacket( Network::Packets::FFXIVPacketBasePtr pPacket );
void sendPackets( Sapphire::Network::Packets::PacketContainer* pPacket ); void sendPackets( Network::Packets::PacketContainer* pPacket );
void sendPacket( Packets::LobbyPacketContainer& pLpc ); void sendPacket( Network::Packets::LobbyPacketContainer& pLpc );
void sendSinglePacket( Sapphire::Network::Packets::FFXIVPacketBasePtr pPacket ); void sendSinglePacket( Network::Packets::FFXIVPacketBasePtr pPacket );
}; };

10
src/lobby/LobbyPacketContainer.cpp
View file

@ -8,7 +8,7 @@ using namespace Sapphire;
using namespace Sapphire::Common; using namespace Sapphire::Common;
using namespace Sapphire::Network::Packets; using namespace Sapphire::Network::Packets;
Lobby::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey ) LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey )
{ {
memset( &m_header, 0, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) ); memset( &m_header, 0, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) );
m_header.size = sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ); m_header.size = sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER );
@ -18,12 +18,12 @@ Lobby::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* en
memset( m_dataBuf, 0, 0x1570 ); memset( m_dataBuf, 0, 0x1570 );
} }
Lobby::Network::Packets::LobbyPacketContainer::~LobbyPacketContainer() LobbyPacketContainer::~LobbyPacketContainer()
{ {
m_entryList.clear(); m_entryList.clear();
} }
void Lobby::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry ) void LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry )
{ {
memcpy( m_dataBuf + m_header.size, &pEntry->getData()[ 0 ], pEntry->getSize() ); memcpy( m_dataBuf + m_header.size, &pEntry->getData()[ 0 ], pEntry->getSize() );
@ -39,12 +39,12 @@ void Lobby::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePt
m_header.count++; m_header.count++;
} }
uint16_t Lobby::Network::Packets::LobbyPacketContainer::getSize() const uint16_t LobbyPacketContainer::getSize() const
{ {
return m_header.size; return m_header.size;
} }
uint8_t* Lobby::Network::Packets::LobbyPacketContainer::getRawData( bool addstuff ) uint8_t* LobbyPacketContainer::getRawData( bool addstuff )
{ {
if( addstuff ) if( addstuff )
{ {

2
src/lobby/LobbyPacketContainer.h
View file

@ -9,7 +9,7 @@
#include "Forwards.h" #include "Forwards.h"
namespace Sapphire::Lobby::Network::Packets namespace Sapphire::Network::Packets
{ {
using FFXIVPacketBasePtr = std::shared_ptr< Sapphire::Network::Packets::FFXIVPacketBase >; using FFXIVPacketBasePtr = std::shared_ptr< Sapphire::Network::Packets::FFXIVPacketBase >;

20
src/lobby/RestConnector.cpp
View file

@ -12,17 +12,17 @@ using namespace Sapphire;
typedef std::vector< std::tuple< std::string, uint32_t, uint64_t, std::string > > CharList; typedef std::vector< std::tuple< std::string, uint32_t, uint64_t, std::string > > CharList;
Lobby::Network::RestConnector::RestConnector() Lobby::RestConnector::RestConnector()
{ {
} }
Lobby::Network::RestConnector::~RestConnector() Lobby::RestConnector::~RestConnector()
{ {
} }
HttpResponse Lobby::Network::RestConnector::requestApi( std::string endpoint, std::string data ) HttpResponse Lobby::RestConnector::requestApi( std::string endpoint, std::string data )
{ {
HttpClient client( restHost ); HttpClient client( restHost );
@ -41,7 +41,7 @@ HttpResponse Lobby::Network::RestConnector::requestApi( std::string endpoint, st
return r; return r;
} }
Lobby::LobbySessionPtr Lobby::Network::RestConnector::getSession( char* sId ) Lobby::LobbySessionPtr Lobby::RestConnector::getSession( char* sId )
{ {
std::string json_string = "{\"sId\": \"" + std::string( sId ) + "\",\"secret\": \"" + serverSecret + "\"}"; std::string json_string = "{\"sId\": \"" + std::string( sId ) + "\",\"secret\": \"" + serverSecret + "\"}";
@ -83,7 +83,7 @@ Lobby::LobbySessionPtr Lobby::Network::RestConnector::getSession( char* sId )
} }
} }
bool Lobby::Network::RestConnector::checkNameTaken( std::string name ) bool Lobby::RestConnector::checkNameTaken( std::string name )
{ {
std::string json_string = "{\"name\": \"" + name + "\",\"secret\": \"" + serverSecret + "\"}"; std::string json_string = "{\"name\": \"" + name + "\",\"secret\": \"" + serverSecret + "\"}";
@ -117,7 +117,7 @@ bool Lobby::Network::RestConnector::checkNameTaken( std::string name )
} }
} }
uint32_t Lobby::Network::RestConnector::getNextCharId() uint32_t Lobby::RestConnector::getNextCharId()
{ {
std::string json_string = "{\"secret\": \"" + serverSecret + "\"}"; std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
@ -156,7 +156,7 @@ uint32_t Lobby::Network::RestConnector::getNextCharId()
} }
} }
uint64_t Lobby::Network::RestConnector::getNextContentId() uint64_t Lobby::RestConnector::getNextContentId()
{ {
std::string json_string = "{\"secret\": \"" + serverSecret + "\"}"; std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
@ -195,7 +195,7 @@ uint64_t Lobby::Network::RestConnector::getNextContentId()
} }
} }
CharList Lobby::Network::RestConnector::getCharList( char* sId ) CharList Lobby::RestConnector::getCharList( char* sId )
{ {
std::string json_string = "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\"}"; std::string json_string = "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\"}";
@ -251,7 +251,7 @@ CharList Lobby::Network::RestConnector::getCharList( char* sId )
} }
} }
bool Lobby::Network::RestConnector::deleteCharacter( char* sId, std::string name ) bool Lobby::RestConnector::deleteCharacter( char* sId, std::string name )
{ {
std::string json_string = std::string json_string =
"{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name + "\"}"; "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name + "\"}";
@ -285,7 +285,7 @@ bool Lobby::Network::RestConnector::deleteCharacter( char* sId, std::string name
} }
} }
int Lobby::Network::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson ) int Lobby::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson )
{ {
std::string json_string = std::string json_string =
"{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name + "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name +

2
src/lobby/RestConnector.h
View file

@ -15,7 +15,7 @@ namespace Sapphire
class Session; class Session;
} }
namespace Sapphire::Lobby::Network namespace Sapphire::Lobby
{ {
class LobbySession; class LobbySession;

8
src/lobby/ServerLobby.cpp
View file

@ -23,7 +23,7 @@
using namespace Sapphire; using namespace Sapphire;
Sapphire::Lobby::Network::RestConnector g_restConnector; Sapphire::Lobby::RestConnector g_restConnector;
namespace Sapphire::Lobby namespace Sapphire::Lobby
{ {
@ -65,9 +65,9 @@ namespace Sapphire::Lobby
Logger::setLogLevel( m_config.global.general.logLevel ); Logger::setLogLevel( m_config.global.general.logLevel );
auto pFw = std::make_shared< Framework >(); auto pFw = make_Framework();
auto hive = Sapphire::Network::make_Hive(); auto hive = Network::make_Hive();
Sapphire::Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive, pFw ); Network::addServerToHive< GameConnection >( m_ip, m_port, hive, pFw );
Logger::info( "Lobby server running on {0}:{1}", m_ip, m_port ); Logger::info( "Lobby server running on {0}:{1}", m_ip, m_port );