General cleanup.

Discovery Server/DiscoveryServer.cpp

@@ -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 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 )
 		{
@@ -92,172 +73,44 @@ void DiscoveryServer::Run()
 			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 )
 	{
 		Log::Error( "Invalid session id." );
 		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;
 	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();
+		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;
 	}
 
-	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;
 	}
 
 	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();
+	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 )
 {
 	ByteStream response;
@@ -352,3 +170,4 @@ void DiscoveryServer::SendDiscoveryClientPing( sptr_discovery_record record, spt
 
 	record->m_socket->send( response );
 }
+*/

Discovery Server/DiscoveryServer.h

@@ -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:
+	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:
+	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;
 };

Discovery Server/DiscoverySession.cpp

@@ -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 ) );
-}

Discovery Server/DiscoverySession.h

@@ -3,37 +3,3 @@
 #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;

Gateway Server/GatewayServer.cpp

@@ -51,8 +51,7 @@ 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 )
 	{
@@ -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
-			}
 		}
 	}
 }

Gateway Server/GatewayServer.h

@@ -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();

Norrath Server.vcxproj

@@ -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" />

main.cpp

@@ -27,36 +27,43 @@ int main()
 
 	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 )
 	{
-		if( !gateway_server->isRunning() )
+		if( !gateway_server.isRunning() )
 		{
 			Log::Error( "Gateway Server is not running. Exiting." );
 			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 ) );
 		}
 		
-	gateway_server->Stop();
+		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();
+	lobby_server.Stop();
+	discovery_server.Stop();
 
     return 0;
 }

misc/ByteStream.cpp

@@ -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 )

misc/RealmCrypt.h

@@ -47,42 +47,3 @@ 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;
-};*/
-