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

move lobby to Sapphire::Lobby, move common lib to Sapphire::Common

Browse source
This commit is contained in:
NotAdam 2019-06-02 23:28:19 +10:00
parent bee58c445f
commit eb5431a80e
40 changed files with 208 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/common/Config/ConfigMgr.cpp
View file

@ -5,12 +5,14 @@
namespace fs = std::experimental::filesystem;
using namespace Sapphire::Common;
/**
* Loads an ini file and parses it
* @param configName the name of ini file relative to m_configFolderRoot to load alongside global.ini
* @return true if loading was successful
*/
bool Sapphire::ConfigMgr::loadConfig( const std::string& configName )
bool ConfigMgr::loadConfig( const std::string& configName )
{
// get global config
auto configFile = fs::path( fs::path( m_configFolderRoot ) / configName );
@ -29,7 +31,7 @@ bool Sapphire::ConfigMgr::loadConfig( const std::string& configName )
return true;
}
bool Sapphire::ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config, const std::string& configName )
bool ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config, const std::string& configName )
{
auto configFile = fs::path( fs::path( m_configFolderRoot ) / configName );
@ -71,7 +73,7 @@ bool Sapphire::ConfigMgr::loadGlobalConfig( Common::Config::GlobalConfig& config
return true;
}
bool Sapphire::ConfigMgr::copyDefaultConfig( const std::string& configName )
bool ConfigMgr::copyDefaultConfig( const std::string& configName )
{
fs::path configPath( m_configFolderRoot );
configPath /= configName;

2
src/common/Config/ConfigMgr.h
View file

@ -8,7 +8,7 @@
#include <stdint.h>
#include "ConfigDef.h"
namespace Sapphire
namespace Sapphire::Common
{
class ConfigMgr
{

4
src/common/Crypt/base64.cpp
View file

@ -41,7 +41,7 @@ static inline bool is_base64( uint8_t c )
return ( isalnum( c ) || ( c == '+' ) || ( c == '/' ) );
}
std::string Sapphire::Util::base64Encode( uint8_t const* bytes_to_encode, uint32_t in_len )
std::string Sapphire::Common::Util::base64Encode( uint8_t const* bytes_to_encode, uint32_t in_len )
{
std::string ret;
int32_t i = 0;
@ -87,7 +87,7 @@ std::string Sapphire::Util::base64Encode( uint8_t const* bytes_to_encode, uint32
}
std::string Sapphire::Util::base64Decode( std::string const& encoded_string )
std::string Sapphire::Common::Util::base64Decode( std::string const& encoded_string )
{
int32_t in_len = encoded_string.size();
int32_t i = 0;

2
src/common/Crypt/base64.h
View file

@ -1,6 +1,6 @@
#include <string>
namespace Sapphire::Util
namespace Sapphire::Common::Util
{
std::string base64Encode( uint8_t const*, uint32_t len );

10
src/common/Crypt/md5.cpp
View file

@ -37,7 +37,7 @@
(b)[(i) + 3] = (uint8_t) ( (n) >> 24 ); \
}
void Sapphire::Util::md5_starts( md5_context* ctx )
void Sapphire::Common::Util::md5_starts( md5_context* ctx )
{
ctx->total[ 0 ] = 0;
ctx->total[ 1 ] = 0;
@ -48,7 +48,7 @@ void Sapphire::Util::md5_starts( md5_context* ctx )
ctx->state[ 3 ] = 0x10325476;
}
void md5_process( Sapphire::Util::md5_context* ctx, uint8_t data[64] )
void md5_process( Sapphire::Common::Util::md5_context* ctx, uint8_t data[64] )
{
uint32_t X[16], A, B, C, D;
@ -171,7 +171,7 @@ void md5_process( Sapphire::Util::md5_context* ctx, uint8_t data[64] )
ctx->state[ 3 ] += D;
}
void Sapphire::Util::md5_update( md5_context* ctx, uint8_t* input, uint32_t length )
void Sapphire::Common::Util::md5_update( md5_context* ctx, uint8_t* input, uint32_t length )
{
uint32_t left, fill;
@ -219,7 +219,7 @@ static uint8_t md5_padding[64] =
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void Sapphire::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
void Sapphire::Common::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
{
uint32_t last, padn;
uint32_t high, low;
@ -248,7 +248,7 @@ void Sapphire::Util::md5_finish( md5_context* ctx, uint8_t digest[16] )
* those are the standard RFC 1321 test vectors
*/
void Sapphire::Util::md5( uint8_t* text, uint8_t* hash, int32_t size )
void Sapphire::Common::Util::md5( uint8_t* text, uint8_t* hash, int32_t size )
{
md5_context ctx;
md5_starts( &ctx );

2
src/common/Crypt/md5.h
View file

@ -3,7 +3,7 @@
#include <stdint.h>
namespace Sapphire::Util
namespace Sapphire::Common::Util
{
using md5_context = struct
{

6
src/common/Forwards.h
View file

@ -3,7 +3,7 @@
#include <memory>
namespace Sapphire
namespace Sapphire::Common
{
class ConfigMgr;
class Framework;
@ -11,7 +11,7 @@ namespace Sapphire
using FrameworkPtr = std::shared_ptr< Framework >;
}
namespace Sapphire::Network
namespace Sapphire::Common::Network
{
class Hive;
class Acceptor;
@ -21,7 +21,7 @@ namespace Sapphire::Network
using ConnectionPtr = std::shared_ptr< Connection >;
}
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
class GamePacket;
class FFXIVPacketBase;

2
src/common/Framework.h
View file

@ -7,7 +7,7 @@
#include <memory>
#include <cassert>
namespace Sapphire
namespace Sapphire::Common
{
class Framework

29
src/common/Network/Acceptor.cpp
View file

@ -2,7 +2,10 @@
#include "Acceptor.h"
#include "Connection.h"
Sapphire::Network::Acceptor::Acceptor( HivePtr hive ) :
using namespace Sapphire::Common;
Network::Acceptor::Acceptor( HivePtr hive ) :
m_hive( hive ),
m_acceptor( hive->getService() ),
m_io_strand( hive->getService() ),
@ -10,21 +13,21 @@ Sapphire::Network::Acceptor::Acceptor( HivePtr hive ) :
{
}
Sapphire::Network::Acceptor::~Acceptor()
Network::Acceptor::~Acceptor()
{
}
bool Sapphire::Network::Acceptor::onAccept( ConnectionPtr connection, const std::string& host, uint16_t port )
bool Network::Acceptor::onAccept( ConnectionPtr connection, const std::string& host, uint16_t port )
{
return true;
}
void Sapphire::Network::Acceptor::onError( const asio::error_code& error )
void Network::Acceptor::onError( const asio::error_code& error )
{
}
void Sapphire::Network::Acceptor::startError( const asio::error_code& error )
void Network::Acceptor::startError( const asio::error_code& error )
{
uint32_t v1 = 1;
uint32_t v2 = 0;
@ -37,7 +40,7 @@ void Sapphire::Network::Acceptor::startError( const asio::error_code& error )
}
}
void Sapphire::Network::Acceptor::dispatchAccept( ConnectionPtr connection )
void Network::Acceptor::dispatchAccept( ConnectionPtr connection )
{
m_acceptor.async_accept( connection->getSocket(),
connection->getStrand().wrap( std::bind( &Acceptor::handleAccept,
@ -46,7 +49,7 @@ void Sapphire::Network::Acceptor::dispatchAccept( ConnectionPtr connection )
connection ) ) );
}
void Sapphire::Network::Acceptor::handleAccept( const asio::error_code& error, ConnectionPtr connection )
void Network::Acceptor::handleAccept( const asio::error_code& error, ConnectionPtr connection )
{
if( error || hasError() || m_hive->hasStopped() )
{
@ -72,17 +75,17 @@ void Sapphire::Network::Acceptor::handleAccept( const asio::error_code& error, C
}
}
void Sapphire::Network::Acceptor::stop()
void Network::Acceptor::stop()
{
}
void Sapphire::Network::Acceptor::accept( ConnectionPtr connection )
void Network::Acceptor::accept( ConnectionPtr connection )
{
m_io_strand.post( std::bind( &Acceptor::dispatchAccept, shared_from_this(), connection ) );
}
void Sapphire::Network::Acceptor::listen( const std::string& host, const uint16_t& port )
void Network::Acceptor::listen( const std::string& host, const uint16_t& port )
{
try
{
@ -103,17 +106,17 @@ void Sapphire::Network::Acceptor::listen( const std::string& host, const uint16_
}
Sapphire::Network::HivePtr Sapphire::Network::Acceptor::getHive()
Network::HivePtr Network::Acceptor::getHive()
{
return m_hive;
}
asio::ip::tcp::acceptor& Sapphire::Network::Acceptor::getAcceptor()
asio::ip::tcp::acceptor& Network::Acceptor::getAcceptor()
{
return m_acceptor;
}
bool Sapphire::Network::Acceptor::hasError()
bool Network::Acceptor::hasError()
{
uint32_t v1 = 1;
uint32_t v2 = 1;

2
src/common/Network/Acceptor.h
View file

@ -13,7 +13,7 @@
#include <vector>
namespace Sapphire::Network
namespace Sapphire::Common::Network
{
class Connection;

2
src/common/Network/CommonActorControl.h
View file

@ -10,7 +10,7 @@
// The following enumerations are structures to require their type be included.
// They are also defined within the Sapphire::Common namespace to avoid collisions.
// +---------------------------------------------------------------------------
namespace Sapphire::Network::ActorControl
namespace Sapphire::Common::Network::ActorControl
{
enum ActorControlType : uint16_t

2
src/common/Network/CommonNetwork.h
View file

@ -5,7 +5,7 @@
#include <vector>
#include "PacketDef/Ipcs.h"
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
/**

48
src/common/Network/Connection.cpp
View file

@ -3,7 +3,9 @@
#include <functional>
#include "Framework.h"
Sapphire::Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
using namespace Sapphire::Common;
Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
m_hive( hive ),
m_socket( hive->getService() ),
m_io_strand( hive->getService() ),
@ -13,11 +15,9 @@ Sapphire::Network::Connection::Connection( HivePtr hive, FrameworkPtr pFw ) :
{
}
Sapphire::Network::Connection::~Connection()
{
}
Network::Connection::~Connection() = default;
void Sapphire::Network::Connection::bind( const std::string& ip, uint16_t port )
void Network::Connection::bind( const std::string& ip, uint16_t port )
{
asio::ip::tcp::endpoint endpoint( asio::ip::address::from_string( ip ), port );
m_socket.open( endpoint.protocol() );
@ -25,7 +25,7 @@ void Sapphire::Network::Connection::bind( const std::string& ip, uint16_t port )
m_socket.bind( endpoint );
}
void Sapphire::Network::Connection::startSend()
void Network::Connection::startSend()
{
if( !m_pending_sends.empty() )
{
@ -38,7 +38,7 @@ void Sapphire::Network::Connection::startSend()
}
}
void Sapphire::Network::Connection::startRecv( int32_t total_bytes )
void Network::Connection::startRecv( int32_t total_bytes )
{
if( total_bytes > 0 )
{
@ -61,7 +61,7 @@ void Sapphire::Network::Connection::startRecv( int32_t total_bytes )
}
}
void Sapphire::Network::Connection::startError( const asio::error_code& error )
void Network::Connection::startError( const asio::error_code& error )
{
uint32_t v1 = 1;
uint32_t v2 = 0;
@ -74,7 +74,7 @@ void Sapphire::Network::Connection::startError( const asio::error_code& error )
}
}
void Sapphire::Network::Connection::handleConnect( const asio::error_code& error )
void Network::Connection::handleConnect( const asio::error_code& error )
{
if( error || hasError() || m_hive->hasStopped() )
{
@ -94,8 +94,8 @@ void Sapphire::Network::Connection::handleConnect( const asio::error_code& error
}
}
void Sapphire::Network::Connection::handleSend( const asio::error_code& error,
std::list< std::vector< uint8_t > >::iterator itr )
void Network::Connection::handleSend( const asio::error_code& error,
std::list< std::vector< uint8_t > >::iterator itr )
{
if( error || hasError() || m_hive->hasStopped() )
{
@ -109,7 +109,7 @@ void Sapphire::Network::Connection::handleSend( const asio::error_code& error,
}
}
void Sapphire::Network::Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
void Network::Connection::handleRecv( const asio::error_code& error, int32_t actual_bytes )
{
if( error || hasError() || m_hive->hasStopped() )
{
@ -128,7 +128,7 @@ void Sapphire::Network::Connection::handleRecv( const asio::error_code& error, i
}
}
void Sapphire::Network::Connection::dispatchSend( std::vector< uint8_t > buffer )
void Network::Connection::dispatchSend( std::vector< uint8_t > buffer )
{
bool should_start_send = m_pending_sends.empty();
m_pending_sends.push_back( buffer );
@ -138,7 +138,7 @@ void Sapphire::Network::Connection::dispatchSend( std::vector< uint8_t > buffer
}
}
void Sapphire::Network::Connection::dispatchRecv( int32_t total_bytes )
void Network::Connection::dispatchRecv( int32_t total_bytes )
{
bool should_start_receive = m_pending_recvs.empty();
m_pending_recvs.push_back( total_bytes );
@ -149,7 +149,7 @@ void Sapphire::Network::Connection::dispatchRecv( int32_t total_bytes )
}
void Sapphire::Network::Connection::connect( const std::string& host, uint16_t port )
void Network::Connection::connect( const std::string& host, uint16_t port )
{
asio::ip::tcp::resolver resolver( m_hive->getService() );
asio::ip::tcp::resolver::query query( host, std::to_string( port ) );
@ -160,48 +160,48 @@ void Sapphire::Network::Connection::connect( const std::string& host, uint16_t p
}
void Sapphire::Network::Connection::disconnect()
void Network::Connection::disconnect()
{
onDisconnect();
m_socket.close();
}
void Sapphire::Network::Connection::recv( int32_t total_bytes )
void Network::Connection::recv( int32_t total_bytes )
{
m_io_strand.post( std::bind( &Connection::dispatchRecv, shared_from_this(), total_bytes ) );
}
void Sapphire::Network::Connection::send( const std::vector< uint8_t >& buffer )
void Network::Connection::send( const std::vector< uint8_t >& buffer )
{
m_io_strand.post( std::bind( &Connection::dispatchSend, shared_from_this(), buffer ) );
}
asio::ip::tcp::socket& Sapphire::Network::Connection::getSocket()
asio::ip::tcp::socket& Network::Connection::getSocket()
{
return m_socket;
}
asio::strand& Sapphire::Network::Connection::getStrand()
asio::strand& Network::Connection::getStrand()
{
return m_io_strand;
}
Sapphire::Network::HivePtr Sapphire::Network::Connection::getHive()
Network::HivePtr Network::Connection::getHive()
{
return m_hive;
}
void Sapphire::Network::Connection::setReceiveBufferSize( int32_t size )
void Network::Connection::setReceiveBufferSize( int32_t size )
{
m_receive_buffer_size = size;
}
int32_t Sapphire::Network::Connection::getReceiveBufferSize() const
int32_t Network::Connection::getReceiveBufferSize() const
{
return m_receive_buffer_size;
}
bool Sapphire::Network::Connection::hasError()
bool Network::Connection::hasError()
{
uint32_t v1 = 1;
uint32_t v2 = 1;

6
src/common/Network/Connection.h
View file

@ -12,13 +12,13 @@
#include "Acceptor.h"
#include <memory>
namespace Sapphire
namespace Sapphire::Common
{
class Framework;
using FrameworkPtr = std::shared_ptr< Framework >;
}
namespace Sapphire::Network
namespace Sapphire::Common::Network
{
class Hive;
@ -41,7 +41,7 @@ namespace Sapphire::Network
std::list< std::vector< uint8_t > > m_pending_sends;
int32_t m_receive_buffer_size;
std::atomic< uint32_t > m_error_state;
Sapphire::FrameworkPtr m_pFw;
FrameworkPtr m_pFw;
Connection( HivePtr hive, FrameworkPtr pFw );

2
src/common/Network/GamePacket.h
View file

@ -14,7 +14,7 @@
#include "CommonNetwork.h"
#include "PacketDef/Ipcs.h"
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
// Must forward define these in order to enable the compiler to produce the

15
src/common/Network/GamePacketParser.cpp
View file

@ -3,9 +3,10 @@
#include <string.h> // memcpy
using namespace Sapphire::Network::Packets;
using namespace Sapphire::Common;
using namespace Sapphire::Common::Network::Packets;
PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint8_t >& buffer,
PacketParseResult Network::Packets::getHeader( const std::vector< uint8_t >& buffer,
const uint32_t offset,
FFXIVARR_PACKET_HEADER& header )
{
@ -25,7 +26,7 @@ PacketParseResult Sapphire::Network::Packets::getHeader( const std::vector< uint
return Success;
}
PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer,
PacketParseResult Network::Packets::getSegmentHeader( const std::vector< uint8_t >& buffer,
const uint32_t offset,
FFXIVARR_PACKET_SEGMENT_HEADER& header )
{
@ -42,7 +43,7 @@ PacketParseResult Sapphire::Network::Packets::getSegmentHeader( const std::vecto
return Success;
}
PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uint8_t >& buffer,
PacketParseResult Network::Packets::getPackets( const std::vector< uint8_t >& buffer,
const uint32_t offset,
const FFXIVARR_PACKET_HEADER& packetHeader,
std::vector< FFXIVARR_PACKET_RAW >& packets )
@ -81,7 +82,7 @@ PacketParseResult Sapphire::Network::Packets::getPackets( const std::vector< uin
return Success;
}
PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset,
PacketParseResult Network::Packets::getPacket( const std::vector< uint8_t >& buffer, const uint32_t offset,
FFXIVARR_PACKET_RAW& packet )
{
// Copy segment header
@ -103,7 +104,7 @@ PacketParseResult Sapphire::Network::Packets::getPacket( const std::vector< uint
return Success;
}
bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header )
bool Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& header )
{
// Max size of the packet is capped at 1MB for now.
if( header.size > 1 * 1024 * 1024 )
@ -116,7 +117,7 @@ bool Sapphire::Network::Packets::checkHeader( const FFXIVARR_PACKET_HEADER& head
return true;
}
bool Sapphire::Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header )
bool Network::Packets::checkSegmentHeader( const FFXIVARR_PACKET_SEGMENT_HEADER& header )
{
// Max size of individual message is capped at 256KB for now.
if( header.size > 256 * 1024 )

2
src/common/Network/GamePacketParser.h
View file

@ -3,7 +3,7 @@
#include "CommonNetwork.h"
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
enum PacketParseResult

18
src/common/Network/Hive.cpp
View file

@ -2,41 +2,43 @@
#include <functional>
#include "Hive.h"
using namespace Sapphire::Common;
//-----------------------------------------------------------------------------
Sapphire::Network::Hive::Hive() :
Network::Hive::Hive() :
m_work_ptr( new asio::io_service::work( m_io_service ) ),
m_shutdown( 0 )
{
}
Sapphire::Network::Hive::~Hive()
Network::Hive::~Hive()
{
}
asio::io_service& Sapphire::Network::Hive::getService()
asio::io_service& Network::Hive::getService()
{
return m_io_service;
}
bool Sapphire::Network::Hive::hasStopped()
bool Network::Hive::hasStopped()
{
uint32_t v1 = 1;
uint32_t v2 = 1;
return m_shutdown.compare_exchange_strong( v1, v2 );
}
void Sapphire::Network::Hive::poll()
void Network::Hive::poll()
{
m_io_service.poll();
}
void Sapphire::Network::Hive::run()
void Network::Hive::run()
{
m_io_service.run();
}
void Sapphire::Network::Hive::stop()
void Network::Hive::stop()
{
uint32_t v1 = 1;
uint32_t v2 = 0;
@ -48,7 +50,7 @@ void Sapphire::Network::Hive::stop()
}
}
void Sapphire::Network::Hive::reset()
void Network::Hive::reset()
{
uint32_t v1 = 0;
uint32_t v2 = 1;

2
src/common/Network/Hive.h
View file

@ -5,7 +5,7 @@
#include <atomic>
#include <memory>
namespace Sapphire:: Network
namespace Sapphire::Common::Network
{
class Hive : public std::enable_shared_from_this< Hive >

12
src/common/Network/PacketContainer.cpp
View file

@ -7,7 +7,9 @@
#include <string.h>
#include <memory>
Sapphire::Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTargetOverride ) :
using namespace Sapphire::Common;
Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTargetOverride ) :
m_segmentTargetOverride( segmentTargetOverride )
{
memset( &m_ipcHdr, 0, sizeof( FFXIVARR_PACKET_HEADER ) );
@ -15,12 +17,12 @@ Sapphire::Network::Packets::PacketContainer::PacketContainer( uint32_t segmentTa
m_ipcHdr.count = 0;
}
Sapphire::Network::Packets::PacketContainer::~PacketContainer()
Network::Packets::PacketContainer::~PacketContainer()
{
m_entryList.clear();
}
void Sapphire::Network::Packets::PacketContainer::addPacket( Sapphire::Network::Packets::FFXIVPacketBasePtr entry )
void Network::Packets::PacketContainer::addPacket( Network::Packets::FFXIVPacketBasePtr entry )
{
m_entryList.push_back( entry );
@ -28,7 +30,7 @@ void Sapphire::Network::Packets::PacketContainer::addPacket( Sapphire::Network::
m_ipcHdr.count++;
}
void Sapphire::Network::Packets::PacketContainer::fillSendBuffer( std::vector< uint8_t >& sendBuffer )
void Network::Packets::PacketContainer::fillSendBuffer( std::vector< uint8_t >& sendBuffer )
{
std::vector< uint8_t > tempBuffer( m_ipcHdr.size );
memset( &tempBuffer[ 0 ], 0, m_ipcHdr.size );
@ -67,7 +69,7 @@ void Sapphire::Network::Packets::PacketContainer::fillSendBuffer( std::vector< u
}
std::string Sapphire::Network::Packets::PacketContainer::toString()
std::string Network::Packets::PacketContainer::toString()
{
std::vector< uint8_t > tmpBuffer;

2
src/common/Network/PacketContainer.h
View file

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

11
src/common/Network/PacketDef/Chat/ServerChatDef.h
View file

@ -4,10 +4,8 @@
#include <Common.h>
#include <Network/CommonNetwork.h>
namespace Sapphire {
namespace Network {
namespace Packets {
namespace Server {
namespace Sapphire::Common::Network::Packets::Server
{
/**
* Structural representation of the packet sent by the server as response
@ -31,10 +29,7 @@ struct FFXIVIpcTellErrNotFound : FFXIVIpcBasePacket< TellErrNotFound >
char receipientName[32];
};
} /* Server */
} /* Packets */
} /* Network */
} /* Sapphire */
} /* Sapphire::Common::Network::Packets::Server */

2
src/common/Network/PacketDef/Ipcs.h
View file

@ -3,7 +3,7 @@
#include <stdint.h>
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
////////////////////////////////////////////////////////////////////////////////

9
src/common/Network/PacketDef/Lobby/ServerLobbyDef.h
View file

@ -4,10 +4,7 @@
#include <Common.h>
#include <Network/CommonNetwork.h>
namespace Sapphire {
namespace Network {
namespace Packets {
namespace Server {
namespace Sapphire::Common::Network::Packets::Server {
struct FFXIVIpcRetainerList :
FFXIVIpcBasePacket< LobbyRetainerList >
@ -152,7 +149,5 @@ struct FFXIVIpcLobbyError : FFXIVIpcBasePacket< LobbyError >
};
}
}
}
}
#endif

9
src/common/Network/PacketDef/Zone/ClientZoneDef.h
View file

@ -4,10 +4,8 @@
#include <Common.h>
#include <Network/CommonNetwork.h>
namespace Sapphire {
namespace Network {
namespace Packets {
namespace Client {
namespace Sapphire::Common::Network::Packets::Client
{
struct FFXIVIpcGmCommand1 :
FFXIVIpcBasePacket< GMCommand1 >
@ -325,9 +323,6 @@ struct FFXIVIpcMarketBoardRequestItemListingInfo :
/* 0000 */ uint32_t requestId;
};
}
}
}
}
#endif //_CORE_NETWORK_PACKETS_ZONE_CLIENT_IPC_H

2
src/common/Network/PacketDef/Zone/ServerZoneDef.h
View file

@ -10,7 +10,7 @@
#include <Common.h>
#include <Network/CommonNetwork.h>
namespace Sapphire::Network::Packets::Server
namespace Sapphire::Common::Network::Packets::Server
{
/**

12
src/lobby/Forwards.h
View file

@ -12,20 +12,24 @@ x ## Ptr make_ ## x( Args &&...args ) { \
return std::make_shared< x >( std::forward< Args >( args ) ... ); }\
typedef std::vector< x > x ## PtrList;
namespace Sapphire
namespace Sapphire::Lobby
{
TYPE_FORWARD( LobbySession );
}
namespace Sapphire::Network
namespace Sapphire::Lobby::Network
{
TYPE_FORWARD( GameConnection );
}
namespace Sapphire::Common::Network
{
TYPE_FORWARD( Hive );
TYPE_FORWARD( Acceptor );
TYPE_FORWARD( Connection );
TYPE_FORWARD( GameConnection );
}
namespace Sapphire::Network::Packets
namespace Sapphire::Common::Network::Packets
{
TYPE_FORWARD( GamePacket );
TYPE_FORWARD( FFXIVPacketBase );

64
src/lobby/GameConnection.cpp
View file

@ -15,30 +15,30 @@
#include "RestConnector.h"
#include "LobbySession.h"
extern Sapphire::ServerLobby g_serverLobby;
extern Sapphire::Network::RestConnector g_restConnector;
using namespace Sapphire;
using namespace Sapphire::Common::Network::Packets;
using namespace Sapphire::Common::Network::Packets::Server;
using namespace Sapphire::Common;
using namespace Sapphire::Network::Packets;
using namespace Sapphire::Network::Packets::Server;
extern Lobby::ServerLobby g_serverLobby;
extern Lobby::Network::RestConnector g_restConnector;
Sapphire::Network::GameConnection::GameConnection( Sapphire::Network::HivePtr pHive,
Sapphire::Network::AcceptorPtr pAcceptor,
FrameworkPtr pFw ) :
Connection( pHive, pFw ),
Lobby::Network::GameConnection::GameConnection( Common::Network::HivePtr pHive,
Common::Network::AcceptorPtr pAcceptor,
Common::FrameworkPtr pFw ) :
Common::Network::Connection( pHive, pFw ),
m_pAcceptor( pAcceptor ),
m_bEncryptionInitialized( false )
{
}
Sapphire::Network::GameConnection::~GameConnection()
Lobby::Network::GameConnection::~GameConnection()
{
}
// overwrite the parents onConnect for our game socket needs
void Sapphire::Network::GameConnection::onAccept( const std::string& host, uint16_t port )
void Lobby::Network::GameConnection::onAccept( const std::string& host, uint16_t port )
{
auto connection = make_GameConnection( m_hive, m_pAcceptor, m_pFw );
m_pAcceptor->accept( connection );
@ -47,17 +47,17 @@ void Sapphire::Network::GameConnection::onAccept( const std::string& host, uint1
}
void Sapphire::Network::GameConnection::onDisconnect()
void Lobby::Network::GameConnection::onDisconnect()
{
Logger::debug( "DISCONNECT" );
}
void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
void Lobby::Network::GameConnection::onRecv( std::vector< uint8_t >& 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.
Packets::FFXIVARR_PACKET_HEADER packetHeader{};
const auto headerResult = Packets::getHeader( m_packets, 0, packetHeader );
Common::Network::Packets::FFXIVARR_PACKET_HEADER packetHeader{};
const auto headerResult = Common::Network::Packets::getHeader( m_packets, 0, packetHeader );
if( headerResult == Incomplete )
return;
@ -70,9 +70,9 @@ void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
}
// Dissect packet list
std::vector< Packets::FFXIVARR_PACKET_RAW > packetList;
const auto packetResult = Packets::getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ),
packetHeader, packetList );
std::vector< Common::Network::Packets::FFXIVARR_PACKET_RAW > packetList;
const auto packetResult = Common::Network::Packets::getPackets( m_packets, sizeof( struct FFXIVARR_PACKET_HEADER ),
packetHeader, packetList );
if( packetResult == Incomplete )
return;
@ -90,13 +90,13 @@ void Sapphire::Network::GameConnection::onRecv( std::vector< uint8_t >& buffer )
}
void Sapphire::Network::GameConnection::onError( const asio::error_code& error )
void Lobby::Network::GameConnection::onError( const asio::error_code& error )
{
Logger::info( "GameConnection closed: {0}", error.message() );
}
void
Sapphire::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId )
Lobby::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorcode, uint16_t messageId, uint32_t tmpId )
{
auto errorPacket = makeLobbyPacket< FFXIVIpcLobbyError >( tmpId );
errorPacket->data().seq = sequence;
@ -108,7 +108,7 @@ Sapphire::Network::GameConnection::sendError( uint64_t sequence, uint32_t errorc
sendPacket( pRP );
}
void Sapphire::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
void Lobby::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
Logger::info( "Sequence [{0}]", sequence );
@ -192,7 +192,7 @@ void Sapphire::Network::GameConnection::getCharList( FFXIVARR_PACKET_RAW& packet
}
}
void Sapphire::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
void Lobby::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
Logger::info( "Sequence [{0}]", sequence );
@ -234,7 +234,7 @@ void Sapphire::Network::GameConnection::enterWorld( FFXIVARR_PACKET_RAW& packet,
sendPacket( pRP );
}
bool Sapphire::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
bool Lobby::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{
LobbySessionPtr pSession = g_serverLobby.getSession( ( char* ) &packet.data[ 0 ] + 0x22 );
@ -273,7 +273,7 @@ bool Sapphire::Network::GameConnection::sendServiceAccountList( FFXIVARR_PACKET_
return false;
}
bool Sapphire::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
bool Lobby::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW& packet, uint32_t tmpId )
{
uint64_t sequence = *reinterpret_cast< uint64_t* >( &packet.data[ 0 ] + 0x10 );
uint8_t type = *reinterpret_cast< uint8_t* >( &packet.data[ 0 ] + 0x29 );
@ -381,7 +381,7 @@ bool Sapphire::Network::GameConnection::createOrModifyChar( FFXIVARR_PACKET_RAW&
return false;
}
void Sapphire::Network::GameConnection::handleGamePacket( Packets::FFXIVARR_PACKET_RAW& packet )
void Lobby::Network::GameConnection::handleGamePacket( Common::Network::Packets::FFXIVARR_PACKET_RAW& packet )
{
uint32_t tmpId = packet.segHdr.target_actor;
@ -419,7 +419,7 @@ void Sapphire::Network::GameConnection::handleGamePacket( Packets::FFXIVARR_PACK
}
void Sapphire::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer& pLpc )
void Lobby::Network::GameConnection::sendPacket( Packets::LobbyPacketContainer& pLpc )
{
uint16_t size = pLpc.getSize();
uint8_t* dataPtr = pLpc.getRawData( false );
@ -428,7 +428,7 @@ void Sapphire::Network::GameConnection::sendPacket( Packets::LobbyPacketContaine
send( sendBuffer );
}
void Sapphire::Network::GameConnection::sendPackets( Packets::PacketContainer* pPacket )
void Lobby::Network::GameConnection::sendPackets( Common::Network::Packets::PacketContainer* pPacket )
{
std::vector< uint8_t > sendBuffer;
@ -436,14 +436,14 @@ void Sapphire::Network::GameConnection::sendPackets( Packets::PacketContainer* p
send( sendBuffer );
}
void Sapphire::Network::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket )
void Lobby::Network::GameConnection::sendSinglePacket( FFXIVPacketBasePtr pPacket )
{
PacketContainer pRP = PacketContainer();
pRP.addPacket( pPacket );
sendPackets( &pRP );
}
void Sapphire::Network::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase )
void Lobby::Network::GameConnection::generateEncryptionKey( uint32_t key, const std::string& keyPhrase )
{
memset( m_baseKey, 0, 0x2C );
m_baseKey[ 0 ] = 0x78;
@ -454,11 +454,11 @@ void Sapphire::Network::GameConnection::generateEncryptionKey( uint32_t key, con
m_baseKey[ 8 ] = 0xC6;
m_baseKey[ 9 ] = 0x11;
memcpy( ( char* ) m_baseKey + 0x0C, keyPhrase.c_str(), keyPhrase.size() );
Sapphire::Util::md5( m_baseKey, m_encKey, 0x2C );
Common::Util::md5( m_baseKey, m_encKey, 0x2C );
}
void Sapphire::Network::GameConnection::handlePackets( const Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
const std::vector< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW >& packetData )
void Lobby::Network::GameConnection::handlePackets( const Common::Network::Packets::FFXIVARR_PACKET_HEADER& ipcHeader,
const std::vector< Common::Network::Packets::FFXIVARR_PACKET_RAW >& packetData )
{
for( auto inPacket : packetData )

32
src/lobby/GameConnection.h
View file

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

19
src/lobby/LobbyPacketContainer.cpp
View file

@ -4,25 +4,26 @@
#include <Crypt/blowfish.h>
#include <Common.h>
using namespace Sapphire;
using namespace Sapphire::Common;
using namespace Sapphire::Network::Packets;
using namespace Sapphire::Common::Network::Packets;
Sapphire::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey )
Lobby::Network::Packets::LobbyPacketContainer::LobbyPacketContainer( uint8_t* encKey )
{
memset( &m_header, 0, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) );
m_header.size = sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER );
memset( &m_header, 0, sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER ) );
m_header.size = sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER );
m_encKey = encKey;
memset( m_dataBuf, 0, 0x1570 );
}
Sapphire::Network::Packets::LobbyPacketContainer::~LobbyPacketContainer()
Lobby::Network::Packets::LobbyPacketContainer::~LobbyPacketContainer()
{
m_entryList.clear();
}
void Sapphire::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry )
void Lobby::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBasePtr pEntry )
{
memcpy( m_dataBuf + m_header.size, &pEntry->getData()[ 0 ], pEntry->getSize() );
@ -38,18 +39,18 @@ void Sapphire::Network::Packets::LobbyPacketContainer::addPacket( FFXIVPacketBas
m_header.count++;
}
uint16_t Sapphire::Network::Packets::LobbyPacketContainer::getSize() const
uint16_t Lobby::Network::Packets::LobbyPacketContainer::getSize() const
{
return m_header.size;
}
uint8_t* Sapphire::Network::Packets::LobbyPacketContainer::getRawData( bool addstuff )
uint8_t* Lobby::Network::Packets::LobbyPacketContainer::getRawData( bool addstuff )
{
if( addstuff )
{
m_header.unknown_0 = 0xff41a05252;
m_header.timestamp = Common::Util::getTimeMs();
}
memcpy( m_dataBuf, &m_header, sizeof( Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER ) );
memcpy( m_dataBuf, &m_header, sizeof( Common::Network::Packets::FFXIVARR_PACKET_HEADER ) );
return m_dataBuf;
}

6
src/lobby/LobbyPacketContainer.h
View file

@ -9,10 +9,10 @@
#include "Forwards.h"
namespace Sapphire::Network::Packets
namespace Sapphire::Lobby::Network::Packets
{
using FFXIVPacketBasePtr = std::shared_ptr< FFXIVPacketBase >;
using FFXIVPacketBasePtr = std::shared_ptr< Common::Network::Packets::FFXIVPacketBase >;
class LobbyPacketContainer
{
@ -28,7 +28,7 @@ namespace Sapphire::Network::Packets
uint8_t* getRawData( bool addstuff = true );
private:
Sapphire::Network::Packets::FFXIVARR_PACKET_HEADER m_header;
Common::Network::Packets::FFXIVARR_PACKET_HEADER m_header;
uint8_t* m_encKey;

4
src/lobby/LobbySession.cpp
View file

@ -1,6 +1,7 @@
#include "LobbySession.h"
namespace Sapphire {
using namespace Sapphire::Lobby;
LobbySession::LobbySession( void )
{
//setSocket(NULL);
@ -11,5 +12,4 @@ LobbySession::~LobbySession( void )
{
}
}

2
src/lobby/LobbySession.h
View file

@ -7,7 +7,7 @@
#include <string>
#include <string.h>
namespace Sapphire
namespace Sapphire::Lobby
{
class LobbySession

26
src/lobby/RestConnector.cpp
View file

@ -8,19 +8,21 @@
#include <nlohmann/json.hpp>
using namespace Sapphire;
typedef std::vector< std::tuple< std::string, uint32_t, uint64_t, std::string > > CharList;
Sapphire::Network::RestConnector::RestConnector()
Lobby::Network::RestConnector::RestConnector()
{
}
Sapphire::Network::RestConnector::~RestConnector()
Lobby::Network::RestConnector::~RestConnector()
{
}
HttpResponse Sapphire::Network::RestConnector::requestApi( std::string endpoint, std::string data )
HttpResponse Lobby::Network::RestConnector::requestApi( std::string endpoint, std::string data )
{
HttpClient client( restHost );
@ -39,7 +41,7 @@ HttpResponse Sapphire::Network::RestConnector::requestApi( std::string endpoint,
return r;
}
Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sId )
Lobby::LobbySessionPtr Lobby::Network::RestConnector::getSession( char* sId )
{
std::string json_string = "{\"sId\": \"" + std::string( sId ) + "\",\"secret\": \"" + serverSecret + "\"}";
@ -65,7 +67,7 @@ Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sI
if( content.find( "invalid" ) == std::string::npos )
{
LobbySessionPtr pSession( new Sapphire::LobbySession() );
LobbySessionPtr pSession( new Lobby::LobbySession() );
pSession->setAccountID( json["result"].get< uint32_t >() );
pSession->setSessionId( ( uint8_t* ) sId );
return pSession;
@ -81,7 +83,7 @@ Sapphire::LobbySessionPtr Sapphire::Network::RestConnector::getSession( char* sI
}
}
bool Sapphire::Network::RestConnector::checkNameTaken( std::string name )
bool Lobby::Network::RestConnector::checkNameTaken( std::string name )
{
std::string json_string = "{\"name\": \"" + name + "\",\"secret\": \"" + serverSecret + "\"}";
@ -115,7 +117,7 @@ bool Sapphire::Network::RestConnector::checkNameTaken( std::string name )
}
}
uint32_t Sapphire::Network::RestConnector::getNextCharId()
uint32_t Lobby::Network::RestConnector::getNextCharId()
{
std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
@ -154,7 +156,7 @@ uint32_t Sapphire::Network::RestConnector::getNextCharId()
}
}
uint64_t Sapphire::Network::RestConnector::getNextContentId()
uint64_t Lobby::Network::RestConnector::getNextContentId()
{
std::string json_string = "{\"secret\": \"" + serverSecret + "\"}";
@ -193,7 +195,7 @@ uint64_t Sapphire::Network::RestConnector::getNextContentId()
}
}
CharList Sapphire::Network::RestConnector::getCharList( char* sId )
CharList Lobby::Network::RestConnector::getCharList( char* sId )
{
std::string json_string = "{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\"}";
@ -249,7 +251,7 @@ CharList Sapphire::Network::RestConnector::getCharList( char* sId )
}
}
bool Sapphire::Network::RestConnector::deleteCharacter( char* sId, std::string name )
bool Lobby::Network::RestConnector::deleteCharacter( char* sId, std::string name )
{
std::string json_string =
"{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name + "\"}";
@ -283,11 +285,11 @@ bool Sapphire::Network::RestConnector::deleteCharacter( char* sId, std::string n
}
}
int Sapphire::Network::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson )
int Lobby::Network::RestConnector::createCharacter( char* sId, std::string name, std::string infoJson )
{
std::string json_string =
"{\"sId\": \"" + std::string( sId, 56 ) + "\",\"secret\": \"" + serverSecret + "\",\"name\": \"" + name +
"\",\"infoJson\": \"" + Sapphire::Util::base64Encode( ( uint8_t* ) infoJson.c_str(), infoJson.length() ) + "\"}";
"\",\"infoJson\": \"" + Common::Util::base64Encode( ( uint8_t* ) infoJson.c_str(), infoJson.length() ) + "\"}";
HttpResponse r = requestApi( "createCharacter", json_string );

2
src/lobby/RestConnector.h
View file

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

14
src/lobby/ServerLobby.cpp
View file

@ -21,9 +21,9 @@
#include <thread>
Sapphire::Network::RestConnector g_restConnector;
Sapphire::Lobby::Network::RestConnector g_restConnector;
namespace Sapphire
namespace Sapphire::Lobby
{
@ -31,7 +31,7 @@ namespace Sapphire
m_configPath( configPath ),
m_numConnections( 0 )
{
m_pConfig = std::make_shared< ConfigMgr >();
m_pConfig = std::make_shared< Sapphire::Common::ConfigMgr >();
}
LobbySessionPtr ServerLobby::getSession( char* sessionId )
@ -63,15 +63,15 @@ namespace Sapphire
Logger::setLogLevel( m_config.global.general.logLevel );
auto pFw = std::make_shared< Framework >();
Network::HivePtr hive( new Network::Hive() );
Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive, pFw );
auto pFw = std::make_shared< Common::Framework >();
Common::Network::HivePtr hive( new Common::Network::Hive() );
Common::Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive, pFw );
Logger::info( "Lobby server running on {0}:{1}", m_ip, m_port );
std::vector< std::thread > threadGroup;
threadGroup.emplace_back( std::bind( &Network::Hive::run, hive.get() ) );
threadGroup.emplace_back( std::bind( &Common::Network::Hive::run, hive.get() ) );
for( auto& thread : threadGroup )
if( thread.joinable() )

10
src/lobby/ServerLobby.h
View file

@ -9,10 +9,14 @@
const std::string LOBBY_VERSION = "0.0.5";
namespace Sapphire
namespace Sapphire::Common
{
class ConfigMgr;
}
namespace Sapphire::Lobby
{
class LobbySession;
class ConfigMgr;
using LobbySessionMap = std::map< std::string, LobbySessionPtr >;
@ -29,7 +33,7 @@ namespace Sapphire
uint16_t m_port;
std::string m_ip;
std::shared_ptr< ConfigMgr > m_pConfig;
std::shared_ptr< Sapphire::Common::ConfigMgr > m_pConfig;
public:
ServerLobby( const std::string& configPath );

2
src/lobby/mainLobbyServer.cpp
View file

@ -4,7 +4,7 @@
Sapphire::Common::Util::CrashHandler crashHandler;
Sapphire::ServerLobby g_serverLobby( "lobby.ini" );
Sapphire::Lobby::ServerLobby g_serverLobby( "lobby.ini" );
int main( int32_t argc, char* argv[] )
{

2
src/world/Action/Action.h
View file

@ -130,8 +130,6 @@ namespace Sapphire::World::Action
protected:
void calculateActionCost();
bool primaryCostCheck( bool subtractCosts );
bool secondaryCostCheck( bool subtractCosts );

6
src/world/Network/GameConnection.h
View file

@ -28,12 +28,12 @@ namespace Sapphire::Network
None
};
class GameConnection : public Connection
class GameConnection : public Common::Network::Connection
{
private:
typedef void ( GameConnection::* Handler )( FrameworkPtr pFw,
const Sapphire::Network::Packets::FFXIVARR_PACKET_RAW& inPacket,
const Common::Network::Packets::FFXIVARR_PACKET_RAW& inPacket,
Entity::Player& player );
using HandlerMap = std::map< uint16_t, Handler >;
@ -51,7 +51,7 @@ namespace Sapphire::Network
World::SessionPtr m_pSession;
Common::Util::LockedQueue< Sapphire::Network::Packets::FFXIVARR_PACKET_RAW > m_inQueue;
Common::Util::LockedQueue< Common::Network::Packets::FFXIVARR_PACKET_RAW > m_inQueue;
Common::Util::LockedQueue< Packets::FFXIVPacketBasePtr > m_outQueue;
std::vector< uint8_t > m_packets;