mosskoi/Champions-Reborn-Server-Mirror
1
0
Fork 0
mirror of https://github.com/HikikoMarmy/Champions-Reborn-Server.git synced 2026-04-11 11:29:47 -03:00
Code Issues Packages Projects Releases Wiki Activity

General cleanup.

Browse Source
This commit is contained in:
HikikoMarmy
2025-01-06 08:32:12 +00:00
parent ffbd9d802d
commit 2e82805920
10 changed files with 98 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

271
Discovery Server/DiscoveryServer.cpp
View File

@@ -5,15 +5,11 @@
// ║║║╚═╗║ ║ ║╚╗╔╝║╣ ╠╦╝╚╦╝ ╚═╗║╣ ╠╦╝╚╗╔╝║╣ ╠╦╝ // ║║║╚═╗║ ║ ║╚╗╔╝║╣ ╠╦╝╚╦╝ ╚═╗║╣ ╠╦╝╚╗╔╝║╣ ╠╦╝
// ═╩╝╩╚═╝╚═╝╚═╝ ╚╝ ╚═╝╩╚═ ╩ ╚═╝╚═╝╩╚═ ╚╝ ╚═╝╩╚═ // ═╩╝╩╚═╝╚═╝╚═╝ ╚╝ ╚═╝╩╚═ ╩ ╚═╝╚═╝╩╚═ ╚╝ ╚═╝╩╚═
#include "../global_define.h" #include "../global_define.h"
#include "../Lobby Server/Event/NotifyClientReqConnect.h"
DiscoveryServer::DiscoveryServer() DiscoveryServer::DiscoveryServer()
{ {
m_running = false; m_running = false;
m_sessionMap.clear();
m_recvBuffer.resize( 1024 ); m_recvBuffer.resize( 1024 );
} }
@@ -24,9 +20,23 @@ DiscoveryServer::~DiscoveryServer()
void DiscoveryServer::Start( std::string ip, int32_t port ) void DiscoveryServer::Start( std::string ip, int32_t port )
{ {
if( false == OpenDiscoverySocket( ip, port ) ) m_socket = socket( AF_INET, SOCK_DGRAM, 0 );
if( m_socket == INVALID_SOCKET )
{ {
Log::Error( "Failed to open discovery socket." ); Log::Error( "Failed to create socket." );
return;
}
sockaddr_in serverInfo;
serverInfo.sin_family = AF_INET;
serverInfo.sin_addr.s_addr = ADDR_ANY;// inet_addr( ip.c_str() );
serverInfo.sin_port = htons( port );
if( bind( m_socket, ( SOCKADDR * )&serverInfo, sizeof( serverInfo ) ) == SOCKET_ERROR )
{
Log::Error( "Failed to bind socket." );
closesocket( m_socket );
return; return;
} }
@@ -48,43 +58,14 @@ void DiscoveryServer::Stop()
void DiscoveryServer::Run() void DiscoveryServer::Run()
{ {
FD_SET readSet; FD_SET readSet;
FD_SET writeSet;
timeval timeout = { 0, 1000 }; timeval timeout = { 0, 1000 };
m_timer.Start();
while( m_running ) while( m_running )
{ {
FD_ZERO( &readSet ); FD_ZERO( &readSet );
FD_ZERO( &writeSet ); FD_SET( m_socket, &readSet );
FD_SET( m_socket->fd, &readSet ); auto result = select( 0, &readSet, nullptr, nullptr, &timeout );
auto it = m_sessionMap.begin();
for( it; it != m_sessionMap.end(); )
{
auto &socket = it->second->m_socket;
//if( ::GetTickCount64() - socket->last_recv_time > 5001 )
//{
// Log::Debug( "Disconnect timeout socket." );
// it = m_sessionMap.erase( it );
// continue;
//}
if( socket->m_pendingWriteQueue.empty() )
{
it++;
continue;
}
FD_SET( socket->fd, &writeSet );
it++;
}
auto result = select( 0, &readSet, &writeSet, nullptr, &timeout );
if( result == SOCKET_ERROR ) if( result == SOCKET_ERROR )
{ {
@@ -92,172 +73,44 @@ void DiscoveryServer::Run()
break; break;
} }
if( FD_ISSET( m_socket->fd, &readSet ) ) if( FD_ISSET( m_socket, &readSet ) )
{ {
ReadSocket( m_socket ); ReadSocket();
}
for( auto &session : m_sessionMap )
{
auto &socket = session.second->m_socket;
if( FD_ISSET( socket->fd, &writeSet ) )
{
WriteSocket( socket );
}
} }
} }
} }
bool DiscoveryServer::OpenDiscoverySocket( std::string ip, int32_t port ) void DiscoveryServer::UpdateDiscoveryInfo( std::wstring sessionId, std::string ip, int32_t port )
{ {
SOCKET fd = socket( AF_INET, SOCK_DGRAM, 0 );
if( fd == INVALID_SOCKET )
{
Log::Error( "Failed to create socket." );
return false;
}
sockaddr_in serverInfo;
serverInfo.sin_family = AF_INET;
serverInfo.sin_addr.s_addr = inet_addr( ip.c_str() );
serverInfo.sin_port = htons( port );
if( bind( fd, ( SOCKADDR * )&serverInfo, sizeof( serverInfo ) ) == SOCKET_ERROR )
{
Log::Error( "Failed to bind socket." );
closesocket( fd );
return false;
}
m_socket = std::make_shared< RealmUDPSocket >();
m_socket->local_address = serverInfo;
m_socket->fd = fd;
m_socket->port = port;
m_socket->flag.is_listener = true;
return true;
}
sptr_udp_socket DiscoveryServer::CreateDiscoverySocket( sockaddr_in *remoteAddr )
{
auto socket = std::make_shared< RealmUDPSocket >();
socket->fd = m_socket->fd;
socket->local_address = m_socket->local_address;
socket->remote_address = *remoteAddr;
socket->peer_ip_address = inet_ntoa( remoteAddr->sin_addr );
socket->peer_port = ntohs( remoteAddr->sin_port );
socket->last_recv_time = ::GetTickCount64();
Log::Debug( "Create new session socket for %s:%d", socket->peer_ip_address.c_str(), socket->peer_port );
return socket;
}
sptr_discovery_record DiscoveryServer::CreateNewDiscoveryRecord( sockaddr_in *clientAddr, std::wstring sessionId )
{
auto user = RealmUserManager::Get().GetUser( sessionId );
if( user == nullptr )
{
Log::Error( "User not found for discovery! [%S]", sessionId.c_str() );
return nullptr;
}
auto discoverySocket = CreateDiscoverySocket( clientAddr );
auto session = DiscoverySession::Create( discoverySocket );
session->m_ownerSessionId = sessionId;
m_sessionMap[ *clientAddr ] = session;
user->m_discoverySocket = discoverySocket;
Log::Debug( "Create new session for %s:%d", inet_ntoa( clientAddr->sin_addr ), clientAddr->sin_port );
return session;
}
sptr_discovery_record DiscoveryServer::GetDiscoveryRecord( sockaddr_in *clientAddr )
{
auto it = m_sessionMap.find( *clientAddr );
if( it == m_sessionMap.end() )
{
return nullptr;
}
return it->second;
}
std::wstring DiscoveryServer::GetSessionId( sptr_byte_stream stream )
{
uint32_t length = stream->read<uint32_t>();
auto decryptedBuffer = stream->read_encrypted_bytes( length );
std::wstring sessionId( length, '\0' );
std::memcpy( sessionId.data(), decryptedBuffer.data(), decryptedBuffer.size() );
return sessionId;
}
void DiscoveryServer::AcceptNewClient( sockaddr_in *clientAddr, sptr_byte_stream stream )
{
if( stream->data.size() < 36 )
{
Log::Error( "Invalid Discovery Handshake Packet" );
return;
}
//auto sessionId = GetSessionId( stream );
auto sessionId = stream->read_encrypted_utf16( false );
if( sessionId.empty() || sessionId.size() != 16 ) if( sessionId.empty() || sessionId.size() != 16 )
{ {
Log::Error( "Invalid session id." ); Log::Error( "Invalid session id." );
return; return;
} }
auto record = CreateNewDiscoveryRecord( clientAddr, sessionId ); m_userDiscoveryInfo[ sessionId ] = { ip, port, GetTickCount64() };
if( record == nullptr ) Log::Debug( "UpdateDiscoveryInfo : [%S] %s:%d", sessionId.c_str(), ip.c_str(), port );
{
Log::Error( "Failed to create new discovery record." );
return;
}
auto game = GameSessionManager::Get().FindGame( 0 );
auto &roomOwner = game->m_userList[ 0 ];
auto ipAddr = inet_ntoa( clientAddr->sin_addr );
auto port = ntohs( clientAddr->sin_port );
NotifyClientRequestConnect msg( ipAddr, port );
roomOwner->m_realmSocket->send( msg.Serialize() );
//auto &discovery = DiscoveryServer::Get();
SendDiscoveryClientHandshake( record, stream );
} }
void DiscoveryServer::ReadSocket( sptr_udp_socket socket ) std::optional<UserDiscoveryInfo> DiscoveryServer::GetDiscoveryInfo( const std::wstring &sessionId ) const
{ {
if( socket->flag.disconnected ) auto it = m_userDiscoveryInfo.find( sessionId );
if( it == m_userDiscoveryInfo.end() )
{ {
return; return std::nullopt;
} }
return it->second;
}
void DiscoveryServer::ReadSocket()
{
sockaddr_in clientAddr; sockaddr_in clientAddr;
int clientAddrLen = sizeof( clientAddr ); int clientAddrLen = sizeof( clientAddr );
// Receive data from the client // Receive data from the client
auto bytesReceived = recvfrom( socket->fd, ( char * )m_recvBuffer.data(), ( int )m_recvBuffer.size(), 0, ( struct sockaddr * )&clientAddr, &clientAddrLen ); auto bytesReceived = recvfrom( m_socket, ( char * )m_recvBuffer.data(), ( int )m_recvBuffer.size(), 0, ( struct sockaddr * )&clientAddr, &clientAddrLen );
if( bytesReceived == SOCKET_ERROR ) if( bytesReceived == SOCKET_ERROR )
{ {
@@ -271,70 +124,35 @@ void DiscoveryServer::ReadSocket( sptr_udp_socket socket )
if( bytesReceived > 0 ) if( bytesReceived > 0 )
{ {
socket->last_recv_time = m_timer.GetElapsedTimeMilliseconds(); HandleDiscoveryUpdate( &clientAddr, std::make_shared< ByteStream >( m_recvBuffer.data(), bytesReceived ) );
HandleRequest( &clientAddr, std::make_shared< ByteStream >( m_recvBuffer.data(), bytesReceived ) );
} }
} }
void DiscoveryServer::WriteSocket( sptr_udp_socket socket ) void DiscoveryServer::HandleDiscoveryUpdate( sockaddr_in *clientAddr, sptr_byte_stream stream )
{ {
if( socket->flag.disconnected ) if( stream->get_length() != 52 )
{ {
Log::Error( "Invalid discovery update." );
return; return;
} }
if( socket->m_pendingWriteQueue.empty() ) auto sessionId = stream->read_encrypted_utf16( false );
if( sessionId.empty() || sessionId.size() != 16 )
{ {
return; Log::Error( "Invalid session id." );
}
auto &stream = socket->m_pendingWriteQueue.front();
auto bytesSent = sendto( socket->fd, ( char * )stream->data.data(), ( int )stream->data.size(), 0, ( struct sockaddr * )&socket->remote_address, sizeof(socket->remote_address));
if( bytesSent == SOCKET_ERROR )
{
return;
}
if( bytesSent > 0 )
{
socket->m_pendingWriteQueue.pop();
}
}
void DiscoveryServer::HandleRequest( sockaddr_in *clientAddr, sptr_byte_stream stream )
{
auto record = GetDiscoveryRecord( clientAddr );
if( record == nullptr )
{
AcceptNewClient( clientAddr, stream );
return; return;
} }
auto remoteIp = inet_ntoa( clientAddr->sin_addr ); auto remoteIp = inet_ntoa( clientAddr->sin_addr );
auto remotePort = clientAddr->sin_port; auto remotePort = clientAddr->sin_port;
Log::Debug( "%s:%d", remoteIp, remotePort ); //RealmUserManager::Get().UpdateUserDiscoveryInfo( sessionId, remoteIp, remotePort );
auto state = stream->read_u32(); UpdateDiscoveryInfo( sessionId, remoteIp, remotePort );
switch( state )
{
case 12:
{
SendDiscoveryClientPing( record, stream );
} break;
default:
{
Log::Packet( stream->data, stream->data.size(), false );
} break;
}
} }
/*
void DiscoveryServer::SendDiscoveryClientHandshake( sptr_discovery_record record, sptr_byte_stream stream ) void DiscoveryServer::SendDiscoveryClientHandshake( sptr_discovery_record record, sptr_byte_stream stream )
{ {
ByteStream response; ByteStream response;
@@ -352,3 +170,4 @@ void DiscoveryServer::SendDiscoveryClientPing( sptr_discovery_record record, spt
record->m_socket->send( response ); record->m_socket->send( response );
} }
*/

32
Discovery Server/DiscoveryServer.h
View File

@@ -6,6 +6,12 @@
#include "DiscoverySession.h" #include "DiscoverySession.h"
struct UserDiscoveryInfo {
std::string m_ip;
int32_t m_port;
uint64_t m_lastUpdateTime;
};
class DiscoveryServer class DiscoveryServer
{ {
public: public:
@@ -33,31 +39,21 @@ public:
return m_running; return m_running;
} }
private: void UpdateDiscoveryInfo( std::wstring sessionId, std::string ip, int32_t port );
bool OpenDiscoverySocket( std::string ip, int32_t port ); std::optional<UserDiscoveryInfo> GetDiscoveryInfo( const std::wstring &sessionId ) const;
sptr_udp_socket CreateDiscoverySocket( sockaddr_in *clientAddr );
sptr_discovery_record CreateNewDiscoveryRecord( sockaddr_in *clientAddr, std::wstring sessionId );
sptr_discovery_record GetDiscoveryRecord( sockaddr_in *clientAddr );
std::wstring GetSessionId( sptr_byte_stream stream );
void AcceptNewClient( sockaddr_in *clientAddr, sptr_byte_stream stream );
void ReadSocket( sptr_udp_socket socket );
void WriteSocket( sptr_udp_socket socket );
void HandleRequest( sockaddr_in *clientAddr, sptr_byte_stream stream );
void SendDiscoveryClientHandshake( sptr_discovery_record record, sptr_byte_stream stream );
void SendDiscoveryClientPing( sptr_discovery_record record, sptr_byte_stream stream );
private: private:
void ReadSocket();
void HandleDiscoveryUpdate( sockaddr_in *clientAddr, sptr_byte_stream stream );
static inline std::unique_ptr< DiscoveryServer > m_instance; static inline std::unique_ptr< DiscoveryServer > m_instance;
static inline std::mutex m_mutex; static inline std::mutex m_mutex;
Timer m_timer;
std::atomic< bool > m_running; std::atomic< bool > m_running;
std::thread m_thread; std::thread m_thread;
sptr_udp_socket m_socket; SOCKET m_socket;
std::vector< uint8_t > m_recvBuffer; std::vector< uint8_t > m_recvBuffer;
std::unordered_map< sockaddr_in, sptr_discovery_record, sockaddr_in_hash, sockaddr_in_equal> m_sessionMap;
std::unordered_map< std::wstring, UserDiscoveryInfo > m_userDiscoveryInfo;
}; };

20
Discovery Server/DiscoverySession.cpp
View File

@@ -1,21 +1 @@
#include "../global_define.h" #include "../global_define.h"
#include "DiscoverySession.h"
DiscoverySession::DiscoverySession( sptr_udp_socket socket )
{
m_socket = socket;
m_ownerSessionId = L"";
m_userSessionIds.fill( L"" );
}
DiscoverySession::~DiscoverySession()
{
m_socket.reset();
m_ownerSessionId.clear();
m_userSessionIds.fill( L"" );
}
sptr_discovery_record DiscoverySession::Create( sptr_udp_socket socket )
{
return std::shared_ptr<DiscoverySession>( new DiscoverySession( socket ) );
}

34
Discovery Server/DiscoverySession.h
View File

@@ -3,37 +3,3 @@
#include <memory> #include <memory>
#include <array> #include <array>
#include <string> #include <string>
struct sockaddr_in_hash {
std::size_t operator()( const sockaddr_in &addr ) const
{
std::size_t h1 = std::hash<int>()( addr.sin_family );
std::size_t h2 = std::hash<unsigned short>()( addr.sin_port );
std::size_t h3 = std::hash<unsigned long>()( addr.sin_addr.s_addr );
return h1 ^ ( h2 << 1 ) ^ ( h3 << 2 );
}
};
struct sockaddr_in_equal {
bool operator()( const sockaddr_in &lhs, const sockaddr_in &rhs ) const
{
return lhs.sin_family == rhs.sin_family &&
lhs.sin_port == rhs.sin_port &&
lhs.sin_addr.s_addr == rhs.sin_addr.s_addr;
}
};
class DiscoverySession {
public:
static std::shared_ptr< DiscoverySession > Create( sptr_udp_socket socket );
DiscoverySession( sptr_udp_socket socket );
~DiscoverySession();
sptr_udp_socket m_socket;
std::wstring m_ownerSessionId;
std::array< std::wstring, 4 > m_userSessionIds;
};
typedef std::shared_ptr< DiscoverySession > sptr_discovery_record;

13
Gateway Server/GatewayServer.cpp
View File

@@ -51,8 +51,7 @@ void GatewayServer::Start( std::string ip, int32_t port )
sockaddr_in service; sockaddr_in service;
service.sin_family = AF_INET; service.sin_family = AF_INET;
service.sin_port = htons( port ); service.sin_port = htons( port );
service.sin_addr.s_addr = inet_addr( ip.c_str() ); service.sin_addr.s_addr = ADDR_ANY;
if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR ) if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
{ {
@@ -87,7 +86,6 @@ void GatewayServer::Run()
{ {
FD_SET readSet; FD_SET readSet;
FD_SET writeSet; FD_SET writeSet;
FD_SET exceptSet;
timeval timeout = { 0, 1000 }; timeval timeout = { 0, 1000 };
@@ -97,7 +95,6 @@ void GatewayServer::Run()
{ {
FD_ZERO( &readSet ); FD_ZERO( &readSet );
FD_ZERO( &writeSet ); FD_ZERO( &writeSet );
FD_ZERO( &exceptSet );
FD_SET( m_listenSocket, &readSet ); FD_SET( m_listenSocket, &readSet );
@@ -106,10 +103,9 @@ void GatewayServer::Run()
{ {
FD_SET( client->fd, &readSet ); FD_SET( client->fd, &readSet );
FD_SET( client->fd, &writeSet ); FD_SET( client->fd, &writeSet );
FD_SET( client->fd, &exceptSet );
} }
auto result = select( 0, &readSet, &writeSet, &exceptSet, &timeout ); auto result = select( 0, &readSet, &writeSet, NULL, &timeout );
if( result == SOCKET_ERROR ) if( result == SOCKET_ERROR )
{ {
@@ -133,11 +129,6 @@ void GatewayServer::Run()
{ {
WriteSocket( client ); WriteSocket( client );
} }
if( FD_ISSET( client->fd, &exceptSet ) )
{
// Handle exception
}
} }
} }
} }

8
Gateway Server/GatewayServer.h
View File

@@ -4,17 +4,17 @@
class GatewayServer class GatewayServer
{ {
static inline std::shared_ptr< GatewayServer > m_instance; static inline std::unique_ptr< GatewayServer > m_instance;
public: public:
static std::shared_ptr< GatewayServer > Get() static GatewayServer& Get()
{ {
if( m_instance == nullptr ) if( m_instance == nullptr )
{ {
m_instance = std::make_shared< GatewayServer >(); m_instance.reset( new GatewayServer() );
} }
return m_instance; return *m_instance;
} }
GatewayServer(); GatewayServer();

4
Norrath Server.vcxproj
View File

@@ -206,11 +206,13 @@
<ClInclude Include="Lobby Server\Event\RequestCreatePublicGame.h" /> <ClInclude Include="Lobby Server\Event\RequestCreatePublicGame.h" />
<ClInclude Include="Lobby Server\Event\RequestDoClientDiscovery.h" /> <ClInclude Include="Lobby Server\Event\RequestDoClientDiscovery.h" />
<ClInclude Include="Lobby Server\Event\RequestGetEncryptionKey.h" /> <ClInclude Include="Lobby Server\Event\RequestGetEncryptionKey.h" />
<ClInclude Include="Lobby Server\Event\RequestGetRealmStats.h" />
<ClInclude Include="Lobby Server\Event\RequestGetRules.h" /> <ClInclude Include="Lobby Server\Event\RequestGetRules.h" />
<ClInclude Include="Lobby Server\Event\RequestLogin.h" /> <ClInclude Include="Lobby Server\Event\RequestLogin.h" />
<ClInclude Include="Lobby Server\Event\RequestLogout.h" /> <ClInclude Include="Lobby Server\Event\RequestLogout.h" />
<ClInclude Include="Lobby Server\Event\RequestMatchGame.h" /> <ClInclude Include="Lobby Server\Event\RequestMatchGame.h" />
<ClInclude Include="Lobby Server\Event\RequestTouchSession.h" /> <ClInclude Include="Lobby Server\Event\RequestTouchSession.h" />
<ClInclude Include="Lobby Server\Event\RequestUpdateGameData.h" />
<ClInclude Include="Lobby Server\LobbyServer.h" /> <ClInclude Include="Lobby Server\LobbyServer.h" />
<ClInclude Include="logging.h" /> <ClInclude Include="logging.h" />
<ClInclude Include="misc\ByteStream.h" /> <ClInclude Include="misc\ByteStream.h" />
@@ -246,11 +248,13 @@
<ClCompile Include="Lobby Server\Event\RequestCreatePublicGame.cpp" /> <ClCompile Include="Lobby Server\Event\RequestCreatePublicGame.cpp" />
<ClCompile Include="Lobby Server\Event\RequestDoClientDiscovery.cpp" /> <ClCompile Include="Lobby Server\Event\RequestDoClientDiscovery.cpp" />
<ClCompile Include="Lobby Server\Event\RequestGetEncryptionKey.cpp" /> <ClCompile Include="Lobby Server\Event\RequestGetEncryptionKey.cpp" />
<ClCompile Include="Lobby Server\Event\RequestGetRealmStats.cpp" />
<ClCompile Include="Lobby Server\Event\RequestGetRules.cpp" /> <ClCompile Include="Lobby Server\Event\RequestGetRules.cpp" />
<ClCompile Include="Lobby Server\Event\RequestLogin.cpp" /> <ClCompile Include="Lobby Server\Event\RequestLogin.cpp" />
<ClCompile Include="Lobby Server\Event\RequestLogout.cpp" /> <ClCompile Include="Lobby Server\Event\RequestLogout.cpp" />
<ClCompile Include="Lobby Server\Event\RequestMatchGame.cpp" /> <ClCompile Include="Lobby Server\Event\RequestMatchGame.cpp" />
<ClCompile Include="Lobby Server\Event\RequestTouchSession.cpp" /> <ClCompile Include="Lobby Server\Event\RequestTouchSession.cpp" />
<ClCompile Include="Lobby Server\Event\RequestUpdateGameData.cpp" />
<ClCompile Include="Lobby Server\LobbyServer.cpp" /> <ClCompile Include="Lobby Server\LobbyServer.cpp" />
<ClCompile Include="logging.cpp" /> <ClCompile Include="logging.cpp" />
<ClCompile Include="misc\ByteStream.cpp" /> <ClCompile Include="misc\ByteStream.cpp" />

43
main.cpp
View File

@@ -27,36 +27,43 @@ int main()
Log::Info( "Server Start..." ); Log::Info( "Server Start..." );
auto gateway_server = GatewayServer::Get(); auto &gateway_server = GatewayServer::Get();
gateway_server->Start( "192.168.1.248", 40801 ); gateway_server.Start( "192.168.1.248", 40801 );
LobbyServer::Get().Start( "192.168.1.248", 40810 ); auto &lobby_server = LobbyServer::Get();
DiscoveryServer::Get().Start( "192.168.1.248", 40820 ); lobby_server.Start( "192.168.1.248", 40810 );
auto &discovery_server = DiscoveryServer::Get();
discovery_server.Start( "192.168.1.248", 40820 );
while( true ) while( true )
{ {
if( !gateway_server->isRunning() ) if( !gateway_server.isRunning() )
{ {
Log::Error( "Gateway Server is not running. Exiting." ); Log::Error( "Gateway Server is not running. Exiting." );
break; break;
} }
//if( !lobby_server.isRunning() ) if( !lobby_server.isRunning() )
//{ {
// Log::Error( "Lobby Server is not running. Exiting." ); Log::Error( "Lobby Server is not running. Exiting." );
// break; break;
//} }
//
//if( !discovery_server.isRunning() )
//{
// Log::Error( "Discovery Server is not running. Exiting." );
// break;
//}
std::this_thread::sleep_for( std::chrono::milliseconds( 1 ) ); if( !discovery_server.isRunning() )
{
Log::Error( "Discovery Server is not running. Exiting." );
break;
}
GameSessionManager::Get().Process();
std::this_thread::sleep_for( std::chrono::milliseconds( 250 ) );
} }
gateway_server->Stop(); gateway_server.Stop();
lobby_server.Stop();
discovery_server.Stop();
return 0; return 0;
} }

3
misc/ByteStream.cpp
View File

@@ -69,7 +69,7 @@ void ByteStream::write_utf8( const std::string &value )
void ByteStream::write_utf16( const std::wstring &value ) void ByteStream::write_utf16( const std::wstring &value )
{ {
write_u32( value.size() ); write_u32( value.size() + 1 );
std::vector< uint8_t > utf16; std::vector< uint8_t > utf16;
for( auto c : value ) for( auto c : value )
@@ -79,6 +79,7 @@ void ByteStream::write_utf16( const std::wstring &value )
} }
write_bytes( utf16 ); write_bytes( utf16 );
write_u16( 0 );
} }
void ByteStream::write_sz_utf8( const std::string &value ) void ByteStream::write_sz_utf8( const std::string &value )

39
misc/RealmCrypt.h
View File

@@ -47,42 +47,3 @@ public:
// Initializer state for srand. // Initializer state for srand.
static bool ms_initialized; static bool ms_initialized;
}; };
/*class Encryptor {
private:
// "dlfk qs';r+t iqe4t9ueerjKDJ wdaj";
const static inline std::vector< uint8_t > default_sym_key =
{
0x64, 0x6c, 0x66, 0x6b, 0x20, 0x71, 0x73, 0x27,
0x3b, 0x72, 0x2b, 0x74, 0x20, 0x69, 0x71, 0x65,
0x34, 0x74, 0x39, 0x75, 0x65, 0x65, 0x72, 0x6a,
0x4b, 0x44, 0x4a, 0x20, 0x77, 0x64, 0x61, 0x6a
};
public:
Encryptor();
std::vector< uint8_t > generateSymmetricKey( void );
std::string encryptString( std::string &input );
std::string decryptString( std::string &input );
std::wstring encryptString( std::wstring &input );
std::wstring decryptString( std::wstring &input );
std::vector< uint8_t > encryptSymmetric( std::vector< const uint8_t > &input );
std::vector< uint8_t > decryptSymmetric( std::vector< const uint8_t > &input );
std::vector< uint8_t > encryptSymmetric( std::span< const uint8_t > input );
std::vector< uint8_t > decryptSymmetric( std::span< const uint8_t > input );
void setSymmetricKey( const std::vector< uint8_t > &input );
std::vector< uint8_t > getSymmetricKey( void ) const;
void test();
std::vector< uint8_t > m_symKey;
static bool ms_initialized;
};*/