Cleanup includes

src/client/component/demonware.cpp

@@ -5,7 +5,9 @@
 #include <utils/thread.hpp>
 
 #include "game/game.hpp"
-#include "game/demonware/demonware.hpp"
+#include "game/demonware/servers/lobby_server.hpp"
+#include "game/demonware/servers/auth3_server.hpp"
+#include "game/demonware/servers/stun_server.hpp"
 #include "game/demonware/server_registry.hpp"
 
 #define TCP_BLOCKING true

src/client/game/demonware/bit_buffer.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "demonware.hpp"
+#include "bit_buffer.hpp"
 
 namespace demonware
 {
@@ -100,7 +100,7 @@ namespace demonware
 		auto cur_out = 0;
 
 		const char* bytes = this->buffer_.data();
-		const auto output_bytes = reinterpret_cast<unsigned char*>(output);
+		const auto output_bytes = static_cast<unsigned char*>(output);
 
 		while (bits > 0)
 		{
@@ -133,7 +133,7 @@ namespace demonware
 
 		int bit = bits;
 		const auto bytes = const_cast<char*>(this->buffer_.data());
-		const auto* input_bytes = reinterpret_cast<const unsigned char*>(data);
+		const auto* input_bytes = static_cast<const unsigned char*>(data);
 
 		while (bit > 0)
 		{

src/client/game/demonware/byte_buffer.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "demonware.hpp"
+#include "byte_buffer.hpp"
 
 namespace demonware
 {
@@ -266,7 +266,7 @@ namespace demonware
 
 	bool byte_buffer::write(const int bytes, const void* data)
 	{
-		this->buffer_.append(reinterpret_cast<const char*>(data), bytes);
+		this->buffer_.append(static_cast<const char*>(data), bytes);
 		this->current_byte_ += bytes;
 		return true;
 	}

src/client/game/demonware/byte_buffer.hpp

@@ -28,7 +28,7 @@ namespace demonware
 		bool read_data_type(char expected);
 
 		bool read_array_header(unsigned char expected, unsigned int* element_count,
-			unsigned int* element_size = nullptr);
+		                       unsigned int* element_size = nullptr);
 
 		bool write_byte(char data);
 		bool write_bool(bool data);

src/client/game/demonware/data_types.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "byte_buffer.hpp"
+
 namespace demonware
 {
 

src/client/game/demonware/demonware.cpp

@@ -1,2 +0,0 @@
-#include <std_include.hpp>
-#include "demonware.hpp"

src/client/game/demonware/keys.cpp

@@ -1,130 +1,134 @@
 #include <std_include.hpp>
-#include "demonware.hpp"
+#include "keys.hpp"
+
 #include <utils/cryptography.hpp>
 #include <utils/string.hpp>
 
 namespace demonware
 {
-    struct data_t
-    {
-        char m_session_key[24];
-        char m_response[8];
-        char m_hmac_key[20];
-        char m_enc_key[16];
-        char m_dec_key[16];
-    }data{};
+	struct data_t
+	{
+		char m_session_key[24];
+		char m_response[8];
+		char m_hmac_key[20];
+		char m_enc_key[16];
+		char m_dec_key[16];
+	} data{};
 
-    std::string packet_buffer;
+	std::string packet_buffer;
 
-    void calculate_hmacs_s1(const char* data_, unsigned int data_size, const char* key, unsigned int key_size, char* dst, unsigned int dst_size)
-    {
-        char buffer[64];
-        unsigned int pos = 0;
-        unsigned int out_offset = 0;
-        char count = 1;
-        std::string result;
+	void calculate_hmacs_s1(const char* data_, unsigned int data_size, const char* key, unsigned int key_size,
+	                        char* dst, unsigned int dst_size)
+	{
+		char buffer[64];
+		unsigned int pos = 0;
+		unsigned int out_offset = 0;
+		char count = 1;
+		std::string result;
 
-        // buffer add key
-        std::memcpy(&buffer[pos], key, key_size);
-        pos += key_size;
+		// buffer add key
+		std::memcpy(&buffer[pos], key, key_size);
+		pos += key_size;
 
-        // buffer add count
-        buffer[pos] = count;
-        pos++;
+		// buffer add count
+		buffer[pos] = count;
+		pos++;
 
-        // calculate hmac
-        unsigned int outlen = 20;
-        result = utils::cryptography::hmac_sha1::process(std::string(buffer, pos), std::string(data_, data_size), &outlen);
+		// calculate hmac
+		unsigned int out_len = 20;
+		result = utils::cryptography::hmac_sha1::process(std::string(buffer, pos), std::string(data_, data_size),
+		                                                 &out_len);
 
-        // save output
-        std::memcpy(dst, result.data(), std::min(20u, (dst_size - out_offset)));
-        out_offset = 20;
+		// save output
+		std::memcpy(dst, result.data(), std::min(20u, (dst_size - out_offset)));
+		out_offset = 20;
 
-        // second loop
-        while (1)
-        {
-            // if we filled the output buffer, exit
-            if (out_offset >= dst_size)
-                break;
+		// second loop
+		while (true)
+		{
+			// if we filled the output buffer, exit
+			if (out_offset >= dst_size)
+				break;
 
-            // buffer add last result
-            pos = 0;
-            std::memcpy(&buffer[pos], result.data(), 20);
-            pos += 20;
+			// buffer add last result
+			pos = 0;
+			std::memcpy(&buffer[pos], result.data(), 20);
+			pos += 20;
 
-            // buffer add key
-            std::memcpy(&buffer[pos], key, key_size);
-            pos += key_size;
+			// buffer add key
+			std::memcpy(&buffer[pos], key, key_size);
+			pos += key_size;
 
-            // buffer add count
-            count++;
-            buffer[pos] = count;
-            pos++;
+			// buffer add count
+			count++;
+			buffer[pos] = count;
+			pos++;
 
-            // calculate hmac
-            unsigned int outlen_ = 20;
-            result = utils::cryptography::hmac_sha1::process(std::string(buffer, pos), std::string(data_, data_size), &outlen_);
+			// calculate hmac
+			unsigned int outlen = 20;
+			result = utils::cryptography::hmac_sha1::process(std::string(buffer, pos), std::string(data_, data_size),
+			                                                 &outlen);
 
-            // save output
-            std::memcpy(&((char*)dst)[out_offset], result.data(), std::min(20u, (dst_size - out_offset)));
-            out_offset += 20;
-        }
-    }
+			// save output
+			std::memcpy(dst + out_offset, result.data(), std::min(20u, (dst_size - out_offset)));
+			out_offset += 20;
+		}
+	}
 
-    void derive_keys_s1()
-    {
-        std::string out_1 = utils::cryptography::sha1::compute(packet_buffer); // out_1 size 20
+	void derive_keys_s1()
+	{
+		const auto out_1 = utils::cryptography::sha1::compute(packet_buffer); // out_1 size 20
 
-        unsigned int len = 20;
-        std::string data_3 = utils::cryptography::hmac_sha1::process(data.m_session_key, out_1, &len);
+		unsigned int len = 20;
+		auto data_3 = utils::cryptography::hmac_sha1::process(data.m_session_key, out_1, &len);
 
-        char out_2[16];
-        calculate_hmacs_s1(data_3.data(), 20, "CLIENTCHAL", 10, out_2, 16);
+		char out_2[16];
+		calculate_hmacs_s1(data_3.data(), 20, "CLIENTCHAL", 10, out_2, 16);
 
-        char out_3[72];
-        calculate_hmacs_s1(data_3.data(), 20, "BDDATA", 6, out_3, 72);
+		char out_3[72];
+		calculate_hmacs_s1(data_3.data(), 20, "BDDATA", 6, out_3, 72);
 
-        std::memcpy(data.m_response, &out_2[8], 8);
-        std::memcpy(data.m_hmac_key, &out_3[20], 20);
-        std::memcpy(data.m_dec_key, &out_3[40], 16);
-        std::memcpy(data.m_enc_key, &out_3[56], 16);
+		std::memcpy(data.m_response, &out_2[8], 8);
+		std::memcpy(data.m_hmac_key, &out_3[20], 20);
+		std::memcpy(data.m_dec_key, &out_3[40], 16);
+		std::memcpy(data.m_enc_key, &out_3[56], 16);
 
 #ifdef DEBUG
-        printf("[demonware] Response id: %s\n", utils::string::dump_hex(std::string(&out_2[8], 8)).data());
-        printf("[demonware] Hash verify: %s\n", utils::string::dump_hex(std::string(&out_3[20], 20)).data());
-        printf("[demonware] AES dec key: %s\n", utils::string::dump_hex(std::string(&out_3[40], 16)).data());
-        printf("[demonware] AES enc key: %s\n", utils::string::dump_hex(std::string(&out_3[56], 16)).data());
-        printf("[demonware] Bravo 6, going dark.\n");
+		printf("[DW] Response id: %s\n", utils::string::dump_hex(std::string(&out_2[8], 8)).data());
+		printf("[DW] Hash verify: %s\n", utils::string::dump_hex(std::string(&out_3[20], 20)).data());
+		printf("[DW] AES dec key: %s\n", utils::string::dump_hex(std::string(&out_3[40], 16)).data());
+		printf("[DW] AES enc key: %s\n", utils::string::dump_hex(std::string(&out_3[56], 16)).data());
+		printf("[DW] Bravo 6, going dark.\n");
 #endif
-    }
+	}
 
-    void queue_packet_to_hash(const std::string& packet)
-    {
-        packet_buffer.append(packet);
-    }
+	void queue_packet_to_hash(const std::string& packet)
+	{
+		packet_buffer.append(packet);
+	}
 
-    void set_session_key(const std::string& key)
-    {
-        std::memcpy(data.m_session_key, key.data(), 24);
-    }
+	void set_session_key(const std::string& key)
+	{
+		std::memcpy(data.m_session_key, key.data(), 24);
+	}
 
-    std::string get_decrypt_key()
-    {
-        return std::string(data.m_dec_key, 16);
-    }
+	std::string get_decrypt_key()
+	{
+		return std::string(data.m_dec_key, 16);
+	}
 
-    std::string get_encrypt_key()
-    {
-        return std::string(data.m_enc_key, 16);
-    }
+	std::string get_encrypt_key()
+	{
+		return std::string(data.m_enc_key, 16);
+	}
 
-    std::string get_hmac_key()
-    {
-        return std::string(data.m_hmac_key, 20);
-    }
+	std::string get_hmac_key()
+	{
+		return std::string(data.m_hmac_key, 20);
+	}
 
-    std::string get_response_id()
-    {
-        return std::string(data.m_response, 8);
-    }
+	std::string get_response_id()
+	{
+		return std::string(data.m_response, 8);
+	}
 }

src/client/game/demonware/keys.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace demonware
+{
+	void derive_keys_s1();
+	void queue_packet_to_hash(const std::string& packet);
+	void set_session_key(const std::string& key);
+	std::string get_decrypt_key();
+	std::string get_encrypt_key();
+	std::string get_hmac_key();
+	std::string get_response_id();
+}

src/client/game/demonware/reply.cpp

@@ -1,5 +1,8 @@
 #include <std_include.hpp>
-#include "demonware.hpp"
+#include "keys.hpp"
+#include "reply.hpp"
+#include "servers/service_server.hpp"
+
 #include <utils/cryptography.hpp>
 
 namespace demonware
@@ -39,7 +42,7 @@ namespace demonware
 		std::string seed("\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED\x5E\xED", 16);
 
 		// encrypt
-		auto enc_data = utils::cryptography::aes::encrypt(aligned_data, seed, demonware::get_encrypt_key());
+		const auto enc_data = utils::cryptography::aes::encrypt(aligned_data, seed, demonware::get_encrypt_key());
 
 		// header : encrypted service data : hash
 		static std::int32_t msg_count = 0;

src/client/game/demonware/reply.hpp

@@ -1,5 +1,9 @@
 #pragma once
 
+#include "bit_buffer.hpp"
+#include "byte_buffer.hpp"
+#include "data_types.hpp"
+
 namespace demonware
 {
 	class reply
@@ -89,8 +93,8 @@ namespace demonware
 		{
 		}
 
-		void send(bit_buffer* buffer, const bool encrypted);
-		void send(byte_buffer* buffer, const bool encrypted);
+		void send(bit_buffer* buffer, bool encrypted);
+		void send(byte_buffer* buffer, bool encrypted);
 
 		uint8_t type() const { return this->type_; }
 

src/client/game/demonware/server_registry.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "servers/base_server.hpp"
+#include <utils/cryptography.hpp>
 
 namespace demonware
 {

src/client/game/demonware/servers/auth3_server.cpp

@@ -1,8 +1,33 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+
+#include "auth3_server.hpp"
+#include "../keys.hpp"
+
+#include <utils/cryptography.hpp>
+#include <utils/string.hpp>
 
 namespace demonware
 {
+	namespace
+	{
+#pragma pack(push, 1)
+		struct auth_ticket
+		{
+			unsigned int m_magicNumber;
+			char m_type;
+			unsigned int m_titleID;
+			unsigned int m_timeIssued;
+			unsigned int m_timeExpires;
+			unsigned __int64 m_licenseID;
+			unsigned __int64 m_userID;
+			char m_username[64];
+			char m_sessionKey[24];
+			char m_usingHashMagicNumber[3];
+			char m_hash[4];
+		};
+#pragma pack(pop)
+	}
+
 	void auth3_server::send_reply(reply* data)
 	{
 		if (!data) return;
@@ -14,7 +39,7 @@ namespace demonware
 		if (packet.starts_with("POST /auth/"))
 		{
 #ifdef DEBUG
-			printf("[demonware]: [auth]: user requested authentication.\n");
+			printf("[DW]: [auth]: user requested authentication.\n");
 #endif
 			return;
 		}
@@ -52,7 +77,7 @@ namespace demonware
 		}
 
 #ifdef DEBUG
-		printf("[demonware]: [auth]: authenticating user %s\n", token.data() + 64);
+		printf("[DW]: [auth]: authenticating user %s\n", token.data() + 64);
 #endif
 
 		std::string auth_key(reinterpret_cast<char*>(token.data() + 32), 24);
@@ -60,7 +85,7 @@ namespace demonware
 			"\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37\x13\x37", 24);
 
 		// client_ticket
-		auth_ticket_t ticket{};
+		auth_ticket ticket{};
 		std::memset(&ticket, 0x0, sizeof ticket);
 		ticket.m_magicNumber = 0x0EFBDADDE;
 		ticket.m_type = 0;
@@ -131,7 +156,7 @@ namespace demonware
 		this->send_reply(&reply);
 
 #ifdef DEBUG
-		printf("[demonware]: [auth]: user successfully authenticated.\n");
+		printf("[DW]: [auth]: user successfully authenticated.\n");
 #endif
 	}
 }

src/client/game/demonware/servers/auth3_server.hpp

@@ -1,25 +1,9 @@
 #pragma once
-#include <utils/cryptography.hpp>
+#include "tcp_server.hpp"
+#include "../reply.hpp"
 
 namespace demonware
 {
-#pragma pack(push, 1)
-	struct auth_ticket_t
-	{
-		unsigned int m_magicNumber;
-		char m_type;
-		unsigned int m_titleID;
-		unsigned int m_timeIssued;
-		unsigned int m_timeExpires;
-		unsigned __int64 m_licenseID;
-		unsigned __int64 m_userID;
-		char m_username[64];
-		char m_sessionKey[24];
-		char m_usingHashMagicNumber[3];
-		char m_hash[4];
-	};
-#pragma pack(pop)
-
 	class auth3_server : public tcp_server
 	{
 	public:

src/client/game/demonware/servers/lobby_server.cpp

@@ -1,6 +1,10 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
-#include "tcp_server.hpp"
+#include "lobby_server.hpp"
+
+#include "../services.hpp"
+#include "../keys.hpp"
+
+#include <utils/cryptography.hpp>
 
 namespace demonware
 {
@@ -54,7 +58,7 @@ namespace demonware
 				else if (size == 0xC8)
 				{
 #ifdef DEBUG
-					printf("[demonware]: [lobby]: received client_header_ack.\n");
+					printf("[DW]: [lobby]: received client_header_ack.\n");
 #endif
 
 					int c8;
@@ -68,7 +72,7 @@ namespace demonware
 					raw_reply reply(packet_2);
 					this->send_reply(&reply);
 #ifdef DEBUG
-					printf("[demonware]: [lobby]: sending server_header_ack.\n");
+					printf("[DW]: [lobby]: sending server_header_ack.\n");
 #endif
 					return;
 				}
@@ -85,7 +89,7 @@ namespace demonware
 					if (type == 0x82)
 					{
 #ifdef DEBUG
-						printf("[demonware]: [lobby]: received client_auth.\n");
+						printf("[DW]: [lobby]: received client_auth.\n");
 #endif
 						std::string packet_3(packet.data(), packet.size() - 8); // this 8 are client hash check?
 
@@ -100,7 +104,7 @@ namespace demonware
 						this->send_reply(&reply);
 
 #ifdef DEBUG
-						printf("[demonware]: [lobby]: sending server_auth_done.\n");
+						printf("[DW]: [lobby]: sending server_auth_done.\n");
 #endif
 						return;
 					}
@@ -137,7 +141,7 @@ namespace demonware
 					}
 				}
 
-				printf("[demonware]: [lobby]: ERROR! received unk message.\n");
+				printf("[DW]: [lobby]: ERROR! received unk message.\n");
 				return;
 			}
 		}
@@ -146,7 +150,7 @@ namespace demonware
 		}
 	}
 
-	void lobby_server::call_service(const std::uint8_t id, const std::string& data)
+	void lobby_server::call_service(const uint8_t id, const std::string& data)
 	{
 		const auto& it = this->services_.find(id);
 
@@ -156,11 +160,11 @@ namespace demonware
 		}
 		else
 		{
-			printf("[demonware]: [lobby]: missing service '%s'\n", utils::string::va("%d", id));
+			printf("[DW]: [lobby]: missing service '%s'\n", utils::string::va("%d", id));
 
 			// return no error
 			byte_buffer buffer(data);
-			std::uint8_t task_id;
+			uint8_t task_id;
 			buffer.read_byte(&task_id);
 
 			this->create_reply(task_id)->send();

src/client/game/demonware/servers/lobby_server.hpp

@@ -1,11 +1,15 @@
 #pragma once
 
+#include "tcp_server.hpp"
+#include "service_server.hpp"
+#include "../service.hpp"
+
 namespace demonware
 {
 	class lobby_server : public tcp_server, service_server
 	{
 	public:
-		 lobby_server(std::string name);
+		lobby_server(std::string name);
 
 		template <typename T>
 		void register_service()
@@ -21,9 +25,9 @@ namespace demonware
 		void send_reply(reply* data) override;
 
 	private:
-		std::unordered_map<std::uint8_t, std::unique_ptr<service>> services_;
+		std::unordered_map<uint8_t, std::unique_ptr<service>> services_;
 
 		void handle(const std::string& packet) override;
-		void call_service(const std::uint8_t id, const std::string& data);
+		void call_service(uint8_t id, const std::string& data);
 	};
 }

src/client/game/demonware/servers/service_server.hpp

@@ -1,8 +1,9 @@
 #pragma once
 
+#include "../reply.hpp"
+
 namespace demonware
 {
-
 	class service_server
 	{
 	public:

src/client/game/demonware/service.hpp

@@ -1,76 +1,89 @@
 #pragma once
 #include <utils/string.hpp>
+#include "servers/service_server.hpp"
 
 namespace demonware
 {
+	class service
+	{
+		using callback_t = std::function<void(service_server*, byte_buffer*)>;
 
-class service
-{
-    using callback_t = std::function<void(service_server*, byte_buffer*)>;
+		uint8_t id_;
+		std::string name_;
+		std::mutex mutex_;
+		uint8_t task_id_;
+		std::map<uint8_t, callback_t> tasks_;
 
-    std::uint8_t id_;
-    std::string name_;
-    std::mutex mutex_;
-    std::uint8_t task_id_;
-    std::map<std::uint8_t, callback_t> tasks_;
+	public:
+		virtual ~service() = default;
+		service(service&&) = delete;
+		service(const service&) = delete;
+		service& operator=(const service&) = delete;
 
-public:
-    virtual ~service() = default;
-    service(service&&) = delete;
-    service(const service&) = delete;
-    service& operator=(const service&) = delete;
-    service(std::uint8_t id, std::string name) : id_(id), task_id_(0), name_(std::move(name)) { }
+		service(const uint8_t id, std::string name) : id_(id), name_(std::move(name)), task_id_(0)
+		{
+		}
 
-    auto id() const -> std::uint8_t { return this->id_; }
-    auto name() const -> std::string { return this->name_; }
-    auto task_id() const -> std::uint8_t { return this->task_id_; }
+		uint8_t id() const
+		{
+			return this->id_;
+		}
 
-    virtual void exec_task(service_server* server, const std::string& data)
-    {
-        std::lock_guard $(this->mutex_);
+		const std::string& name() const
+		{
+			return this->name_;
+		}
 
-        byte_buffer buffer(data);
+		uint8_t task_id() const
+		{
+			return this->task_id_;
+		}
 
-        buffer.read_byte(&this->task_id_);
+		virtual void exec_task(service_server* server, const std::string& data)
+		{
+			std::lock_guard $(this->mutex_);
 
-        const auto& it = this->tasks_.find(this->task_id_);
+			byte_buffer buffer(data);
 
-        if (it != this->tasks_.end())
-        {
+			buffer.read_byte(&this->task_id_);
+
+			const auto& it = this->tasks_.find(this->task_id_);
+
+			if (it != this->tasks_.end())
+			{
 #ifdef DEBUG
-            printf("demonware::%s: executing task '%d'\n", name_.data(), this->task_id_);
+				printf("demonware::%s: executing task '%d'\n", name_.data(), this->task_id_);
 #endif
 
-            it->second(server, &buffer);
-        }
-        else
-        {
-            printf("demonware::%s: missing task '%d'\n", name_.data(), this->task_id_);
+				it->second(server, &buffer);
+			}
+			else
+			{
+				printf("demonware::%s: missing task '%d'\n", name_.data(), this->task_id_);
 
-            // return no error
-            server->create_reply(this->task_id_)->send();
-        }
-    }
+				// return no error
+				server->create_reply(this->task_id_)->send();
+			}
+		}
 
-protected:
+	protected:
 
-    template <typename Class, typename T, typename... Args>
-    void register_task(const uint8_t id, T(Class::* callback)(Args ...) const)
-    {
-        this->tasks_[id] = [this, callback](Args ... args) -> T
-        {
-            return (reinterpret_cast<Class*>(this)->*callback)(args...);
-        };
-    }
+		template <typename Class, typename T, typename... Args>
+		void register_task(const uint8_t id, T (Class::* callback)(Args ...) const)
+		{
+			this->tasks_[id] = [this, callback](Args ... args) -> T
+			{
+				return (reinterpret_cast<Class*>(this)->*callback)(args...);
+			};
+		}
 
-    template <typename Class, typename T, typename... Args>
-    void register_task(const uint8_t id, T(Class::* callback)(Args ...))
-    {
-        this->tasks_[id] = [this, callback](Args ... args) -> T
-        {
-            return (reinterpret_cast<Class*>(this)->*callback)(args...);
-        };
-    }
-};
-
-} // namespace demonware
+		template <typename Class, typename T, typename... Args>
+		void register_task(const uint8_t id, T (Class::* callback)(Args ...))
+		{
+			this->tasks_[id] = [this, callback](Args ... args) -> T
+			{
+				return (reinterpret_cast<Class*>(this)->*callback)(args...);
+			};
+		}
+	};
+}

src/client/game/demonware/services.hpp

@@ -1,13 +1,11 @@
 #pragma once
 
-#include <std_include.hpp>
-
 #include "bit_buffer.hpp"
 #include "byte_buffer.hpp"
 #include "data_types.hpp"
 #include "reply.hpp"
-#include "server.hpp"
 #include "service.hpp"
+#include "servers/service_server.hpp"
 
 //#include "services/bdTeams.hpp"           //  3
 #include "services/bdStats.hpp"             //  4
@@ -35,23 +33,3 @@
 #include "services/bdUNK104.hpp"            //104 Marketing
 #include "services/bdMatchMaking2.hpp"      //138
 #include "services/bdMarketing.hpp"         //139
-
-// servers
-#include "servers/base_server.hpp"
-#include "servers/tcp_server.hpp"
-#include "servers/udp_server.hpp"
-
-#include "servers/auth3_server.hpp"
-#include "servers/lobby_server.hpp"
-#include "servers/stun_server.hpp"
-
-namespace demonware
-{
-	void derive_keys_s1();
-	void queue_packet_to_hash(const std::string& packet);
-	void set_session_key(const std::string& key);
-	std::string get_decrypt_key();
-	std::string get_encrypt_key();
-	std::string get_hmac_key();
-	std::string get_response_id();
-}

src/client/game/demonware/services/bdAnticheat.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdBandwidthTest.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdContentStreaming.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdCounters.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdDML.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdEventLog.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdFacebook.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdGroups.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdMarketing.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdMatchMaking2.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdPresence.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdProfiles.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdRichPresence.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdStats.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdStorage.cpp

@@ -1,7 +1,10 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
-#include "utils/nt.hpp"
-#include "utils/io.hpp"
+#include "../services.hpp"
+
+#include <utils/nt.hpp>
+#include <utils/io.hpp>
+#include <utils/cryptography.hpp>
+
 #include "game/game.hpp"
 
 namespace demonware
@@ -42,7 +45,7 @@ namespace demonware
         }
 
 #ifdef DEBUG
-        printf("[demonware]: [bdStorage]: missing publisher file: %s\n", name.data());
+        printf("[DW]: [bdStorage]: missing publisher file: %s\n", name.data());
 #endif
 
         return false;
@@ -85,7 +88,7 @@ namespace demonware
         buffer->read_string(&filename);
 
 #ifdef DEBUG
-        printf("[demonware]: [bdStorage]: loading publisher file: %s\n", filename.data());
+        printf("[DW]: [bdStorage]: loading publisher file: %s\n", filename.data());
 #endif
 
         std::string data;
@@ -93,7 +96,7 @@ namespace demonware
         if (this->load_publisher_resource(filename, data))
         {
 #ifdef DEBUG
-            printf("[demonware]: [bdStorage]: sending publisher file: %s, size: %lld\n", filename.data(), data.size());
+            printf("[DW]: [bdStorage]: sending publisher file: %s, size: %lld\n", filename.data(), data.size());
 #endif
 
             auto reply = server->create_reply(this->task_id());
@@ -152,7 +155,7 @@ namespace demonware
         buffer->read_string(&platform);
 
 #ifdef DEBUG
-        printf("[demonware]: [bdStorage]: user file: %s, %s, %s\n", game.data(), filename.data(), platform.data());
+        printf("[DW]: [bdStorage]: user file: %s, %s, %s\n", game.data(), filename.data(), platform.data());
 #endif
 
         const auto path = get_user_file_path(filename);

src/client/game/demonware/services/bdTitleUtilities.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdUNK104.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdUNK63.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {

src/client/game/demonware/services/bdUNK80.cpp

@@ -1,5 +1,5 @@
 #include <std_include.hpp>
-#include "../demonware.hpp"
+#include "../services.hpp"
 
 namespace demonware
 {