Big Refactor.

General support for encryption and decryption.
Game Session creation.
Discovery Server.

Still broken as hell, but less so?

Lobby Server/Event/NotifyClientDiscovered.cpp

@@ -0,0 +1,17 @@
+#include "../../global_define.h"
+#include "NotifyClientDiscovered.h"
+
+NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x40 )
+{
+	m_clientIp = clientIp;
+	m_clientPort = clientPort;
+}
+
+ByteStream &NotifyClientDiscovered::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_sz_utf8( m_clientIp );
+	m_stream.write_u32( m_clientPort );
+
+	return m_stream;
+}

Lobby Server/Event/NotifyClientDiscovered.h

@@ -0,0 +1,11 @@
+#pragma once
+
+class NotifyClientDiscovered : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyClientDiscovered( std::string clientIp, int32_t clientPort );
+	ByteStream &Serialize() override;
+};

Lobby Server/Event/NotifyClientReqConnect.cpp

@@ -0,0 +1,17 @@
+#include "../../global_define.h"
+#include "NotifyClientReqConnect.h"
+
+NotifyClientRequestConnect::NotifyClientRequestConnect( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x3F )
+{
+	m_clientIp = clientIp;
+	m_clientPort = clientPort;
+}
+
+ByteStream &NotifyClientRequestConnect::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_sz_utf8( m_clientIp );
+	m_stream.write_u32( m_clientPort );
+
+	return m_stream;
+}

Lobby Server/Event/NotifyClientReqConnect.h

@@ -0,0 +1,12 @@
+#pragma once
+
+class NotifyClientRequestConnect : public GenericMessage
+{
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyClientRequestConnect( std::string clientIp, int32_t clientPort );
+	ByteStream &Serialize() override;
+};

Lobby Server/Event/NotifyGameDiscovered.cpp

@@ -0,0 +1,17 @@
+#include "../../global_define.h"
+#include "NotifyGameDiscovered.h"
+
+NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x3E )
+{
+	m_clientIp = clientIp;
+	m_clientPort = clientPort;
+}
+
+ByteStream &NotifyGameDiscovered::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_sz_utf8( m_clientIp );
+	m_stream.write_u32( m_clientPort );
+
+	return m_stream;
+}

Lobby Server/Event/NotifyGameDiscovered.h

@@ -0,0 +1,11 @@
+#pragma once
+
+class NotifyGameDiscovered : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyGameDiscovered( std::string clientIp, int32_t clientPort );
+	ByteStream &Serialize() override;
+};

Lobby Server/Event/RequestCancelGame.cpp

@@ -0,0 +1,36 @@
+#include "../../global_define.h"
+#include "RequestCancelGame.h"
+
+void RequestCancelGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestCancelGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	// TODO:
+	// Cancel the game
+	// Notify the players via the Discovery Server
+
+	Log::Debug( "RequestCancelGame : %S", m_sessionId.c_str() );
+
+	return std::make_shared< ResultCancelGame >( this );
+}
+
+ResultCancelGame::ResultCancelGame( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultCancelGame::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Lobby Server/Event/RequestCancelGame.h

@@ -0,0 +1,22 @@
+#pragma once
+
+class RequestCancelGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestCancelGame > Create()
+	{
+		return std::make_unique< RequestCancelGame >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultCancelGame : public GenericResponse {
+public:
+	ResultCancelGame( GenericRequest *request );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestCreateAccount.cpp

@@ -0,0 +1,47 @@
+#include "../../global_define.h"
+#include "RequestCreateAccount.h"
+
+void RequestCreateAccount::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	auto username = stream->read_encrypted_utf16();
+	auto password = stream->read_encrypted_utf16();
+	auto emailAddress = stream->read_encrypted_utf16();
+	auto dateOfBirth = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	Log::Debug( "Account creation isn't supported. Random SessionID generated." );
+
+	auto &userMng = RealmUserManager::Get();
+	auto user = userMng.CreateUser( socket, L"foo", L"bar" );
+
+	if( nullptr == user )
+	{
+		Log::Error( "RequestCreateAccount::ProcessRequest() - User not found!" );
+		return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
+	}
+
+	return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::SUCCESS, user->m_sessionId );
+}
+
+ResultCreateAccount::ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_sessionId = sessionId;
+}
+
+ByteStream &ResultCreateAccount::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_encrypted_utf16( m_sessionId );
+
+	return m_stream;
+}

Lobby Server/Event/RequestCreateAccount.h

@@ -0,0 +1,34 @@
+#pragma once
+
+// Account Creation is used in the Network Beta for CoN
+// but it isn't used or supported here because retail
+// uses "foo" and "bar" to login without user data.
+
+class RequestCreateAccount : public GenericRequest
+{
+	enum CREATE_ACCOUNT_REPLY {
+		SUCCESS = 0,
+		ERROR_FATAL,
+		ERROR_NOT_EXIST
+	};
+public:
+	static std::unique_ptr< RequestCreateAccount > Create()
+	{
+		return std::make_unique< RequestCreateAccount >();
+	}
+
+	CREATE_ACCOUNT_REPLY m_reply;
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultCreateAccount : public GenericResponse {
+private:
+	std::wstring m_sessionId;
+	int32_t m_reply;
+
+public:
+	ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestCreatePrivateGame.cpp

@@ -0,0 +1,58 @@
+#include "../../global_define.h"
+
+#include "RequestCreatePrivateGame.h"
+
+void RequestCreatePrivateGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+	m_gameName = stream->read_utf16();
+}
+
+sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	auto user = RealmUserManager::Get().GetUser( socket );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto &game_manager = GameSessionManager::Get();
+
+	auto result = game_manager.CreatePrivateGameSession( user, m_gameName, 0, 9999 );
+
+	if( !result )
+	{
+		Log::Error( "RequestCreatePrivateGame::ProcessRequest() - Failed to create private game session!" );
+		return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::GENERAL_ERROR, "", 0 );
+	}
+
+	Log::Info( "[%S] Create Private Game: %S", m_sessionId.c_str(), m_gameName.c_str() );
+
+	// Send the discovery server information to the client
+	return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 40820 );
+}
+
+ResultCreatePrivateGame::ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIp = discoveryIp;
+	m_discoveryPort = discoveryPort;
+}
+
+ByteStream &ResultCreatePrivateGame::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_sz_utf8( m_discoveryIp );
+	m_stream.write( m_discoveryPort );
+
+	return m_stream;
+}

Lobby Server/Event/RequestCreatePrivateGame.h

@@ -0,0 +1,33 @@
+#pragma once
+
+class RequestCreatePrivateGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+public:
+	static std::unique_ptr< RequestCreatePrivateGame > Create()
+	{
+		return std::make_unique< RequestCreatePrivateGame >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePrivateGame : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestCreatePublicGame.cpp

@@ -0,0 +1,65 @@
+#include "../../global_define.h"
+
+#include "RequestCreatePublicGame.h"
+
+void RequestCreatePublicGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+
+	// Some kind of match attributes
+	auto unknown_a = stream->read_u16();
+	auto unknown_b = stream->read_u32();
+	auto unknown_c = stream->read_u32();
+	auto unknown_d = stream->read_u32();
+
+	m_gameName = stream->read_utf16();
+}
+
+sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	auto user = RealmUserManager::Get().GetUser( socket );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto &game_manager = GameSessionManager::Get();
+
+	auto result = game_manager.CreatePublicGameSession( user, m_gameName, 0, 9999 );
+
+	if( !result )
+	{
+		Log::Error( "RequestCreatePublicGame::ProcessRequest() - Failed to create public game session!" );
+		return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::GENERAL_ERROR, "", 0 );
+	}
+
+	Log::Info( "[%S] Create Public Game: %S", m_sessionId.c_str(), m_gameName.c_str() );
+
+	// Send the discovery server information to the client
+	return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 40820 );
+}
+
+ResultCreatePublicGame::ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIp = discoveryIp;
+	m_discoveryPort = discoveryPort;
+}
+
+ByteStream &ResultCreatePublicGame::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_sz_utf8( m_discoveryIp );
+	m_stream.write( m_discoveryPort );
+
+	return m_stream;
+}

Lobby Server/Event/RequestCreatePublicGame.h

@@ -0,0 +1,35 @@
+#pragma once
+
+class RequestCreatePublicGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+
+	int32_t m_minimumLevel;
+	int32_t m_maximumLevel;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+public:
+	static std::unique_ptr< RequestCreatePublicGame > Create()
+	{
+		return std::make_unique< RequestCreatePublicGame >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePublicGame : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestDoClientDiscovery.cpp

@@ -0,0 +1,59 @@
+#include "../../global_define.h"
+#include "RequestDoClientDiscovery.h"
+#include "NotifyClientReqConnect.h"
+
+void RequestDoClientDiscovery::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+	m_gameId = stream->read_u32();
+}
+
+sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	auto user = RealmUserManager::Get().GetUser( socket );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%s]", m_sessionId.c_str() );
+		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	if( user->m_sessionId != m_sessionId )
+	{
+		Log::Error( "Session ID mismatch! [%s]", m_sessionId.c_str() );
+		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto result = GameSessionManager::Get().UserJoinGame( m_gameId, user );
+
+	if( result == false )
+	{
+		Log::Error( "Failed to join game! [%d]", m_gameId );
+		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::GAME_FULL, "", 0 );
+	}
+
+	return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::SUCCESS, "192.168.1.248", 40820 );
+}
+
+ResultDoClientDiscovery::ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip, int32_t port ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIP = ip;
+	m_discoveryPort = port;
+}
+
+ByteStream &ResultDoClientDiscovery::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_sz_utf8( m_discoveryIP );
+	m_stream.write( m_discoveryPort );
+
+	return m_stream;
+}

Lobby Server/Event/RequestDoClientDiscovery.h

@@ -0,0 +1,34 @@
+#pragma once
+
+class RequestDoClientDiscovery : public GenericRequest
+{
+private:
+	enum DISCOVERY_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR = 1,
+		GAME_FULL = 2,
+	};
+
+	std::wstring m_sessionId;
+	int32_t m_gameId;
+
+public:
+	static std::unique_ptr< RequestDoClientDiscovery > Create()
+	{
+		return std::make_unique< RequestDoClientDiscovery >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultDoClientDiscovery : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIP;
+	int32_t m_discoveryPort;
+
+public:
+	ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip = "", int32_t port = 0);
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestGetEncryptionKey.cpp

@@ -0,0 +1,33 @@
+#include "../../global_define.h"
+#include "RequestGetEncryptionKey.h"
+
+void RequestGetEncryptionKey::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestGetEncryptionKey::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	auto publicKey = stream->read_utf8();
+	auto unknown = stream->read_u32();
+
+	return std::make_shared< ResultGetEncryptionKey >( this );
+}
+
+ResultGetEncryptionKey::ResultGetEncryptionKey( GenericRequest *request ) : GenericResponse( *request )
+{
+	m_symKey = RealmCrypt::getSymmetricKey();
+}
+
+ByteStream& ResultGetEncryptionKey::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_encrypted_bytes( m_symKey );
+
+	return m_stream;
+}

Lobby Server/Event/RequestGetEncryptionKey.h

@@ -0,0 +1,21 @@
+#pragma once
+
+class RequestGetEncryptionKey : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetEncryptionKey > Create()
+	{
+		return std::make_unique< RequestGetEncryptionKey >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultGetEncryptionKey : public GenericResponse {
+public:
+	std::vector< uint8_t > m_symKey;
+
+	ResultGetEncryptionKey( GenericRequest *request );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestGetRules.cpp

@@ -0,0 +1,35 @@
+#include "../../global_define.h"
+#include "RequestGetRules.h"
+
+void RequestGetRules::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_language = stream->read_sz_utf8();
+}
+
+sptr_generic_response RequestGetRules::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	// TODO: Get rules/eula based on language
+	std::wstring rules = L"Welcome to the Norrath Emulated Server!\n\n";
+
+	 return std::make_shared< ResultGetRules >( this, rules );
+}
+
+ResultGetRules::ResultGetRules( GenericRequest *request, std::wstring rules ) : GenericResponse( *request )
+{
+	m_rules = rules;
+}
+
+ByteStream &ResultGetRules::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_utf16( m_rules );
+
+	return m_stream;
+}

Lobby Server/Event/RequestGetRules.h

@@ -0,0 +1,25 @@
+#pragma once
+
+class RequestGetRules : public GenericRequest
+{
+private:
+	std::string m_language;
+
+public:
+	static std::unique_ptr< RequestGetRules > Create()
+	{
+		return std::make_unique< RequestGetRules >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultGetRules : public GenericResponse {
+private:
+	std::wstring m_rules;
+
+public:
+	ResultGetRules( GenericRequest *request, std::wstring rules );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestLogin.cpp

@@ -0,0 +1,56 @@
+#include "../../global_define.h"
+
+#include "RequestLogin.h"
+
+void RequestLogin::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_username = stream->read_encrypted_utf16();
+	m_password = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestLogin::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	if( m_username.empty() || m_password.empty() )
+	{
+		Log::Error( "RequestLogin::ProcessRequest() - Username or password is empty" );
+		return std::make_shared< ResultLogin >( this, LOGIN_REPLY::NOT_EXIST, L"" );
+	}
+
+	if( m_username == L"foo" && m_password == L"bar" )
+	{
+		// Retail CoN does not use any login information.
+		Log::Debug( "RequestLogin : Champions of Norrath v2.0" );
+	}
+	else
+	{
+		// Network Beta CoN uses login information, but it's invalid because of version 2.0.
+		Log::Debug( "RequestLogin : Champions of Norrath v1.0" );
+	}
+
+	auto &userMng = RealmUserManager::Get();
+
+	auto user = userMng.CreateUser( socket, m_username, m_password );
+
+	return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->m_sessionId );
+}
+
+ResultLogin::ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_sessionId = sessionId;
+}
+
+ByteStream &ResultLogin::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_encrypted_utf16( m_sessionId );
+
+	return m_stream;
+}

Lobby Server/Event/RequestLogin.h

@@ -0,0 +1,40 @@
+#pragma once
+
+// Account Login is used in the Network Beta for CoN.
+// In the retail version, the game simply logs in with
+// "foo" and "bar" as the username and password.
+//
+// A unique Session ID is generated and assigned to the player.
+
+class RequestLogin : public GenericRequest
+{
+private:
+	enum LOGIN_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		NOT_EXIST,
+	};
+
+	std::wstring m_username;
+	std::wstring m_password;
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestLogin > Create()
+	{
+		return std::make_unique< RequestLogin >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultLogin : public GenericResponse {
+private:
+	std::wstring m_sessionId;
+	int32_t m_reply;
+
+public:
+	ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestLogout.cpp

@@ -0,0 +1,44 @@
+#include "../../global_define.h"
+#include "RequestLogout.h"
+
+void RequestLogout::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+	m_sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestLogout::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	auto &userMng = RealmUserManager::Get();
+
+	auto user = userMng.GetUser( m_sessionId );
+
+	if( nullptr == user )
+	{
+		Log::Error( "RequestLogout::ProcessRequest() - User not found!" );
+		return std::make_shared< ResultLogout >( this, 1 );
+	}
+
+	// TODO: Any other cleanup here?
+	Log::Debug( "[%S] Logout", m_sessionId.c_str() );
+
+	userMng.RemoveUser( m_sessionId );
+
+	return std::make_shared< ResultLogout >( this, 0 );
+}
+
+ResultLogout::ResultLogout( GenericRequest *request, int32_t reply ) : GenericResponse( *request )
+{
+	m_reply = reply;
+}
+
+ByteStream &ResultLogout::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	return m_stream;
+}

Lobby Server/Event/RequestLogout.h

@@ -0,0 +1,23 @@
+#pragma once
+
+class RequestLogout : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestLogout > Create()
+	{
+		return std::make_unique< RequestLogout >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultLogout : public GenericResponse {
+private:
+	int32_t m_reply;
+public:
+	ResultLogout( GenericRequest *request, int32_t reply );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestMatchGame.cpp

@@ -0,0 +1,88 @@
+#include "../../global_define.h"
+#include "RequestMatchGame.h"
+
+void RequestMatchGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+
+	auto unknown_a = stream->read_u16();
+	auto unknown_b = stream->read_u32();
+	auto unknown_c = stream->read_u32();
+	auto unknown_d = stream->read_u32();
+
+	auto unknown_e = stream->read_u32();
+
+	// Match Game Node Count
+	for( int i = 0; i < unknown_e; i++ )
+	{
+		auto node_a = stream->read_u16();
+		auto node_b = stream->read_u32();
+
+		auto node_c = stream->read_utf16();
+
+		auto node_d = stream->read_u32();
+		auto node_e = stream->read_u32();
+		auto node_f = stream->read_u32();
+		auto node_g = stream->read_u16();
+	}
+
+	auto unknown_f = stream->read_u8();
+	auto unknown_g = stream->read_u32();
+	auto unknown_h = stream->read_u32();
+
+	int dbg = 0;
+}
+
+sptr_generic_response RequestMatchGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	Log::Debug( "RequestMatchGame : %S", m_sessionId.c_str() );
+
+	return std::make_shared< ResultMatchGame >( this );
+}
+
+ResultMatchGame::ResultMatchGame( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultMatchGame::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );		// Connection State
+
+	m_stream.write_u32( 5 );
+
+	for( int i = 0; i < 5; i++ )
+	{
+		m_stream.write_utf16( L"Unknown_A " + std::to_wstring( i ) );
+	}
+
+	m_stream.write_u32( 5 );
+
+	for( int i = 0; i < 5; i++ )
+	{
+		m_stream.write_utf16( L"Game Name " + std::to_wstring( i ) );
+	}
+
+	m_stream.write_u32( 5 );
+
+	for( int i = 0; i < 5; i++ )
+	{
+		m_stream.write_utf16( L"Unknown_B " + std::to_wstring( i ) );
+	}
+
+
+	// Room Unique ID (Used when selecting)
+	m_stream.write_u32( 5 );
+	for( int i = 0; i < 5; i++ )
+	{
+		m_stream.write_u32( i );
+	}
+
+	return m_stream;
+}

Lobby Server/Event/RequestMatchGame.h

@@ -0,0 +1,21 @@
+#pragma once
+
+class RequestMatchGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestMatchGame > Create()
+	{
+		return std::make_unique< RequestMatchGame >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultMatchGame : public GenericResponse {
+public:
+	ResultMatchGame( GenericRequest *request );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestTouchSession.cpp

@@ -0,0 +1,32 @@
+#include "../../global_define.h"
+#include "RequestTouchSession.h"
+
+void RequestTouchSession::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestTouchSession::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	Log::Debug( "RequestTouchSession : %S", m_sessionId.c_str() );
+
+	return std::make_shared< ResultTouchSession >( this );
+}
+
+ResultTouchSession::ResultTouchSession( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultTouchSession::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Lobby Server/Event/RequestTouchSession.h

@@ -0,0 +1,21 @@
+#pragma once
+
+class RequestTouchSession : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestTouchSession > Create()
+	{
+		return std::make_unique< RequestTouchSession >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultTouchSession : public GenericResponse {
+public:
+	ResultTouchSession( GenericRequest *request );
+	ByteStream &Serialize();
+};