mosskoi/Champions-Reborn-Server-Mirror
1
0
Fork 0
mirror of https://github.com/HikikoMarmy/Champions-Reborn-Server.git synced 2026-04-05 08:59:54 -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 "../Lobby Server/Event/NotifyClientReqConnect.h"
DiscoveryServer::DiscoveryServer()
{
m_running = false;
m_sessionMap.clear();
m_recvBuffer.resize( 1024 );
}
@@ -24,9 +20,23 @@ DiscoveryServer::~DiscoveryServer()
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;
}
@@ -48,43 +58,14 @@ void DiscoveryServer::Stop()
void DiscoveryServer::Run()
{
FD_SET readSet;
FD_SET writeSet;
timeval timeout = { 0, 1000 };
m_timer.Start();
while( m_running )
{
FD_ZERO( &readSet );
FD_ZERO( &writeSet );
FD_SET( m_socket, &readSet );
FD_SET( m_socket->fd, &readSet );
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 );
auto result = select( 0, &readSet, nullptr, nullptr, &timeout );
if( result == SOCKET_ERROR )
{
@@ -92,172 +73,44 @@ void DiscoveryServer::Run()
break;
}
if( FD_ISSET( m_socket->fd, &readSet ) )
if( FD_ISSET( m_socket, &readSet ) )
{
ReadSocket( m_socket );
}
for( auto &session : m_sessionMap )
{
auto &socket = session.second->m_socket;
if( FD_ISSET( socket->fd, &writeSet ) )
{
WriteSocket( socket );
}
ReadSocket();
}
}
}
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 )
{
Log::Error( "Invalid session id." );
return;
}
auto record = CreateNewDiscoveryRecord( clientAddr, sessionId );
m_userDiscoveryInfo[ sessionId ] = { ip, port, GetTickCount64() };
if( record == nullptr )
{
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 );
Log::Debug( "UpdateDiscoveryInfo : [%S] %s:%d", sessionId.c_str(), ip.c_str(), port );
}
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;
int clientAddrLen = sizeof( clientAddr );
// 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 )
{
@@ -271,70 +124,35 @@ void DiscoveryServer::ReadSocket( sptr_udp_socket socket )
if( bytesReceived > 0 )
{
socket->last_recv_time = m_timer.GetElapsedTimeMilliseconds();
HandleRequest( &clientAddr, std::make_shared< ByteStream >( m_recvBuffer.data(), bytesReceived ) );
HandleDiscoveryUpdate( &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;
}
if( socket->m_pendingWriteQueue.empty() )
auto sessionId = stream->read_encrypted_utf16( false );
if( sessionId.empty() || sessionId.size() != 16 )
{
return;
}
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 );
Log::Error( "Invalid session id." );
return;
}
auto remoteIp = inet_ntoa( clientAddr->sin_addr );
auto remotePort = clientAddr->sin_port;
Log::Debug( "%s:%d", remoteIp, remotePort );
//RealmUserManager::Get().UpdateUserDiscoveryInfo( sessionId, remoteIp, remotePort );
auto state = stream->read_u32();
switch( state )
{
case 12:
{
SendDiscoveryClientPing( record, stream );
} break;
default:
{
Log::Packet( stream->data, stream->data.size(), false );
} break;
}
UpdateDiscoveryInfo( sessionId, remoteIp, remotePort );
}
/*
void DiscoveryServer::SendDiscoveryClientHandshake( sptr_discovery_record record, sptr_byte_stream stream )
{
ByteStream response;
@@ -352,3 +170,4 @@ void DiscoveryServer::SendDiscoveryClientPing( sptr_discovery_record record, spt
record->m_socket->send( response );
}
*/

32
Discovery Server/DiscoveryServer.h
View File

@@ -6,6 +6,12 @@
#include "DiscoverySession.h"
struct UserDiscoveryInfo {
std::string m_ip;
int32_t m_port;
uint64_t m_lastUpdateTime;
};
class DiscoveryServer
{
public:
@@ -33,31 +39,21 @@ public:
return m_running;
}
private:
bool OpenDiscoverySocket( std::string ip, int32_t port );
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 );
void UpdateDiscoveryInfo( std::wstring sessionId, std::string ip, int32_t port );
std::optional<UserDiscoveryInfo> GetDiscoveryInfo( const std::wstring &sessionId ) const;
private:
void ReadSocket();
void HandleDiscoveryUpdate( sockaddr_in *clientAddr, sptr_byte_stream stream );
static inline std::unique_ptr< DiscoveryServer > m_instance;
static inline std::mutex m_mutex;
Timer m_timer;
std::atomic< bool > m_running;
std::thread m_thread;
sptr_udp_socket m_socket;
SOCKET m_socket;
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 "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 ) );
}

36
Discovery Server/DiscoverySession.h
View File

@@ -2,38 +2,4 @@
#include <memory>
#include <array>
#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;
#include <string>

13
Gateway Server/GatewayServer.cpp
View File

@@ -51,9 +51,8 @@ void GatewayServer::Start( std::string ip, int32_t port )
sockaddr_in service;
service.sin_family = AF_INET;
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 )
{
Log::Error( "bind() failed" );
@@ -87,7 +86,6 @@ void GatewayServer::Run()
{
FD_SET readSet;
FD_SET writeSet;
FD_SET exceptSet;
timeval timeout = { 0, 1000 };
@@ -97,7 +95,6 @@ void GatewayServer::Run()
{
FD_ZERO( &readSet );
FD_ZERO( &writeSet );
FD_ZERO( &exceptSet );
FD_SET( m_listenSocket, &readSet );
@@ -106,10 +103,9 @@ void GatewayServer::Run()
{
FD_SET( client->fd, &readSet );
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 )
{
@@ -133,11 +129,6 @@ void GatewayServer::Run()
{
WriteSocket( client );
}
if( FD_ISSET( client->fd, &exceptSet ) )
{
// Handle exception
}
}
}
}

8
Gateway Server/GatewayServer.h
View File

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

4
Norrath Server.vcxproj
View File

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

43
main.cpp
View File

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

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

41
misc/RealmCrypt.h
View File

@@ -46,43 +46,4 @@ public:
// Initializer state for srand.
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;
};*/
};