Change LUBitstream to make more sense and only read what it needs from the bitstream at each level

2025-10-12 10:28:05 +00:00 · 2025-09-12 22:25:55 -05:00
parent b36b440eba
commit 500a72dc11
16 changed files with 217 additions and 101 deletions
--- a/dAuthServer/AuthServer.cpp
+++ b/dAuthServer/AuthServer.cpp
@@ -165,15 +165,12 @@ int main(int argc, char** argv) {
 }

 void HandlePacket(Packet* packet) {
-	if (packet->length < 4) return;
-
 	CINSTREAM;
 	LUBitStream luBitStream;
-	if (!luBitStream.ReadHeader(inStream)) return;
-	
-	if (luBitStream.connectionType == ServiceType::COMMON) {
+	if (!luBitStream.ReadHeader(inStream) && luBitStream.rakNetID != ID_USER_PACKET_ENUM) return;
+	else if (luBitStream.serviceType == ServiceType::COMMON) {
 		CommonPackets::Handle(inStream, packet->systemAddress);
-	} else if (luBitStream.connectionType == ServiceType::AUTH) {
+	} else if (luBitStream.serviceType == ServiceType::AUTH) {
 		AuthPackets::Handle(inStream, packet->systemAddress);
 	}
 }
--- a/dGame/dUtilities/Mail.cpp
+++ b/dGame/dUtilities/Mail.cpp
@@ -34,7 +34,7 @@ namespace {
 }

 namespace Mail {
-	std::map<eMessageID, std::function<std::unique_ptr<MailLUBitStream>()>> g_Handlers = {
+	std::map<eMessageID, std::function<std::unique_ptr<MailClientLUBitStream>()>> g_Handlers = {
 		{eMessageID::SendRequest, []() {
 			return std::make_unique<SendRequest>();
 		}},
@@ -55,11 +55,11 @@ namespace Mail {
 		}},
 	};

-	void MailLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+	void MailClientLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
 		bitStream.Write(messageID);
 	}

-	bool MailLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
+	bool MailClientLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
 		VALIDATE_READ(bitstream.Read(messageID));
 		return true;
 	}
@@ -133,16 +133,16 @@ namespace Mail {
 			response.status = eSendResponse::SenderAccountIsMuted;
 		}
 		LOG("Finished send with status %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}

 	void SendResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 	}

 	void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write<uint64_t>(0); // unused
 		bitStream.Write<uint64_t>(0); // unused
@@ -158,12 +158,12 @@ namespace Mail {
 		auto playerMail = Database::Get()->GetMailForPlayer(character->GetID(), 20);
 		DataResponse response;
 		response.playerMail = playerMail;
-		response.Send(sysAddr);
+		response.Send();
 		LOG("DataRequest");
 	}

 	void DataResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(this->throttled);
 	
 		bitStream.Write<uint16_t>(this->playerMail.size());
@@ -199,11 +199,11 @@ namespace Mail {
 			}
 		}
 		LOG("AttachmentCollectResponse %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}

 	void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -230,11 +230,11 @@ namespace Mail {
 			response.status = eDeleteResponse::NotFound;
 		}
 		LOG("DeleteRequest status %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}

 	void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -256,11 +256,11 @@ namespace Mail {
 		}

 		LOG("ReadRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}

 	void ReadResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -275,13 +275,13 @@ namespace Mail {
 		}

 		LOG("NotificationRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 }

 // Non Stuct Functions
-void Mail::HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
-	MailLUBitStream data;
+void Mail::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
+	MailClientLUBitStream data;
 	if (!data.Deserialize(inStream)) {
 		LOG_DEBUG("Error Reading Mail header");
 		return;
@@ -368,5 +368,5 @@ void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, LWOOBJ
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) return; // TODO: Echo to chat server
 	NotificationResponse response;
 	response.status = eNotificationResponse::NewMail;
-	response.Send(sysAddr);
+	response.Send();
 }
--- a/dGame/dUtilities/Mail.h
+++ b/dGame/dUtilities/Mail.h
@@ -7,6 +7,8 @@
 #include "dCommonVars.h"
 #include "BitStreamUtils.h"
 #include "MailInfo.h"
+#include "MessageType/Client.h"
+#include "ClientPackets.h"

 class Entity;

@@ -103,111 +105,111 @@ namespace Mail {
 		UnknownError
 	};

-	struct MailLUBitStream : public LUBitStream {
+	struct MailClientLUBitStream : public ClientPackets::ClientLUBitStream {
 		eMessageID messageID = eMessageID::UnknownError;
 		Entity* player = nullptr;

-		MailLUBitStream() = default;
-		MailLUBitStream(eMessageID _messageID) : LUBitStream(ServiceType::CLIENT, MessageType::Client::MAIL), messageID{_messageID} {};
+		MailClientLUBitStream() = default;
+		MailClientLUBitStream(eMessageID _messageID) : ClientPackets::ClientLUBitStream(MessageType::Client::MAIL), messageID{_messageID} {};

 		virtual void Serialize(RakNet::BitStream& bitStream) const override;
 		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
 		virtual void Handle() override {};
 	};

-	struct SendRequest : public MailLUBitStream {
+	struct SendRequest : public MailClientLUBitStream {
 		MailInfo mailInfo;

-		SendRequest() : MailLUBitStream(eMessageID::SendRequest) {}
+		SendRequest() : MailClientLUBitStream(eMessageID::SendRequest) {}
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};

-	struct SendResponse :public MailLUBitStream {
+	struct SendResponse :public MailClientLUBitStream {
 		eSendResponse status = eSendResponse::UnknownError;

-		SendResponse() : MailLUBitStream(eMessageID::SendResponse) {}
+		SendResponse() : MailClientLUBitStream(eMessageID::SendResponse) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct NotificationResponse : public MailLUBitStream {
+	struct NotificationResponse : public MailClientLUBitStream {
 		eNotificationResponse status = eNotificationResponse::UnknownError;
 		LWOOBJID auctionID = LWOOBJID_EMPTY;
 		uint32_t mailCount = 1;
-		NotificationResponse() : MailLUBitStream(eMessageID::NotificationResponse) {};
+		NotificationResponse() : MailClientLUBitStream(eMessageID::NotificationResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct DataRequest : public MailLUBitStream {
-		DataRequest() : MailLUBitStream(eMessageID::DataRequest) {}
+	struct DataRequest : public MailClientLUBitStream {
+		DataRequest() : MailClientLUBitStream(eMessageID::DataRequest) {}
 		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
 		void Handle() override;
 	};

-	struct DataResponse : public MailLUBitStream {
+	struct DataResponse : public MailClientLUBitStream {
 		uint32_t throttled = 0;
 		std::vector<MailInfo> playerMail;

-		DataResponse() : MailLUBitStream(eMessageID::DataResponse) {};
+		DataResponse() : MailClientLUBitStream(eMessageID::DataResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;

 	};

-	struct AttachmentCollectRequest : public MailLUBitStream {
+	struct AttachmentCollectRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		LWOOBJID playerID = LWOOBJID_EMPTY;

-		AttachmentCollectRequest() : MailLUBitStream(eMessageID::AttachmentCollectRequest) {};
+		AttachmentCollectRequest() : MailClientLUBitStream(eMessageID::AttachmentCollectRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};

-	struct AttachmentCollectResponse : public MailLUBitStream {
+	struct AttachmentCollectResponse : public MailClientLUBitStream {
 		eAttachmentCollectResponse status = eAttachmentCollectResponse::UnknownError;
 		uint64_t mailID = 0;
-		AttachmentCollectResponse() : MailLUBitStream(eMessageID::AttachmentCollectResponse) {};
+		AttachmentCollectResponse() : MailClientLUBitStream(eMessageID::AttachmentCollectResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct DeleteRequest : public MailLUBitStream {
+	struct DeleteRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		LWOOBJID playerID = LWOOBJID_EMPTY;

-		DeleteRequest() : MailLUBitStream(eMessageID::DeleteRequest) {};
+		DeleteRequest() : MailClientLUBitStream(eMessageID::DeleteRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};

-	struct DeleteResponse : public MailLUBitStream {
+	struct DeleteResponse : public MailClientLUBitStream {
 		eDeleteResponse status = eDeleteResponse::UnknownError;
 		uint64_t mailID = 0;
-		DeleteResponse() : MailLUBitStream(eMessageID::DeleteResponse) {};
+		DeleteResponse() : MailClientLUBitStream(eMessageID::DeleteResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct ReadRequest : public MailLUBitStream {
+	struct ReadRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;

-		ReadRequest() : MailLUBitStream(eMessageID::ReadRequest) {};
+		ReadRequest() : MailClientLUBitStream(eMessageID::ReadRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};

-	struct ReadResponse : public MailLUBitStream {
+	struct ReadResponse : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		eReadResponse status = eReadResponse::UnknownError;

-		ReadResponse() : MailLUBitStream(eMessageID::ReadResponse) {};
+		ReadResponse() : MailClientLUBitStream(eMessageID::ReadResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct NotificationRequest : public MailLUBitStream {
-		NotificationRequest() : MailLUBitStream(eMessageID::NotificationRequest) {};
+	struct NotificationRequest : public MailClientLUBitStream {
+		NotificationRequest() : MailClientLUBitStream(eMessageID::NotificationRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
 		void Handle() override;
 	};

-	void HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player);
+	void Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player);

 	void SendMail(
 		const Entity* recipient,
--- a/dNet/AuthPackets.cpp
+++ b/dNet/AuthPackets.cpp
@@ -36,6 +36,18 @@ namespace AuthPackets {
 		}}
 	};

+	// Struct Functions
+	void AuthLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool AuthLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));
+		return true;
+	}
+
 	bool LoginRequest::Deserialize(RakNet::BitStream& bitStream) {
 		LUWString usernameLUString;
 		VALIDATE_READ(bitStream.Read(usernameLUString));
@@ -228,22 +240,21 @@ void AuthPackets::LoadClaimCodes() {

 // Non Stuct Functions
 void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
-	inStream.ResetReadPointer();
-	LUBitStream lubitstream;
-	if (!lubitstream.ReadHeader(inStream)) return;
+	AuthLUBitStream authLUBitStream;
+	if (!authLUBitStream.Deserialize(inStream)) return;

-	auto it = g_Handlers.find(static_cast<MessageType::Auth>(lubitstream.internalPacketID));
+	auto it = g_Handlers.find(authLUBitStream.messageType);
 	if (it != g_Handlers.end()) {
 		auto request = it->second();
 		request->sysAddr = sysAddr;
 		if (!request->Deserialize(inStream)) {
-			LOG_DEBUG("Error Reading Auth Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Auth>(lubitstream.internalPacketID)).data());
+			LOG_DEBUG("Error Reading Auth Packet: %s", StringifiedEnum::ToString(authLUBitStream.messageType).data());
 			return;
 		}
-		LOG_DEBUG("Received Auth Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Auth>(lubitstream.internalPacketID)).data());
+		LOG_DEBUG("Received Auth Packet: %s", StringifiedEnum::ToString(authLUBitStream.messageType).data());
 		request->Handle();
 	} else {
-		LOG_DEBUG("Unhandled Auth Packet with ID: %i", lubitstream.internalPacketID);
+		LOG_DEBUG("Unhandled Auth Packet with ID: %i", authLUBitStream.messageType);
 	}
 }

--- a/dNet/AuthPackets.h
+++ b/dNet/AuthPackets.h
@@ -34,7 +34,18 @@ struct magic_enum::customize::enum_range<LanguageCodeID> {

 namespace AuthPackets {

-	struct LoginRequest : public LUBitStream {
+	struct AuthLUBitStream : public LUBitStream {
+		MessageType::Auth messageType = MessageType::Auth::LOGIN_REQUEST;
+
+		AuthLUBitStream() : LUBitStream(ServiceType::AUTH) {};
+		AuthLUBitStream(MessageType::Auth _messageType) : LUBitStream(ServiceType::AUTH), messageType{_messageType} {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
+
+	struct LoginRequest : public AuthLUBitStream {
 		std::string username;
 		std::string password;
 		LanguageCodeID locale_id;
@@ -57,7 +68,7 @@ namespace AuthPackets {
 			} osVersionInfo;
 		} computerInfo;

-		LoginRequest() : LUBitStream(ServiceType::AUTH, MessageType::Auth::LOGIN_REQUEST) {}
+		LoginRequest() : AuthLUBitStream(MessageType::Auth::LOGIN_REQUEST) {}
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};
--- a/dNet/BitStreamUtils.cpp
+++ b/dNet/BitStreamUtils.cpp
@@ -6,18 +6,12 @@

 void LUBitStream::WriteHeader(RakNet::BitStream& bitStream) const {
 	bitStream.Write<MessageID>(ID_USER_PACKET_ENUM);
-	bitStream.Write(this->connectionType);
-	bitStream.Write(this->internalPacketID);
-	bitStream.Write<uint8_t>(0); // padding
+	bitStream.Write(this->serviceType);
 }

 bool LUBitStream::ReadHeader(RakNet::BitStream& bitStream) {
-	MessageID messageID;
-	bitStream.Read(messageID);
-	if (messageID != ID_USER_PACKET_ENUM) return false;
-	VALIDATE_READ(bitStream.Read(this->connectionType));
-	VALIDATE_READ(bitStream.Read(this->internalPacketID));
-    bitStream.IgnoreBytes(1);
+	VALIDATE_READ(bitStream.Read(this->rakNetID));
+	VALIDATE_READ(bitStream.Read(this->serviceType));
 	return true;
 }

--- a/dNet/BitStreamUtils.h
+++ b/dNet/BitStreamUtils.h
@@ -47,16 +47,16 @@ struct LUWString {
 };

 struct LUBitStream {
-	ServiceType connectionType = ServiceType::UNKNOWN;
-	uint32_t internalPacketID = 0xFFFFFFFF;
+	// Common header data that is serialized
+	MessageID rakNetID = ID_USER_PACKET_ENUM;
+	ServiceType serviceType = ServiceType::UNKNOWN;
+
 	SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;

 	LUBitStream() = default;

-	template <typename T> 
-	LUBitStream(ServiceType connectionType, T internalPacketID) {
-		this->connectionType = connectionType;
-		this->internalPacketID = static_cast<uint32_t>(internalPacketID);
+	LUBitStream(ServiceType serviceType) {
+		this->serviceType = serviceType;
 	}

 	void WriteHeader(RakNet::BitStream& bitStream) const;
--- a/dNet/ChatPackets.cpp
+++ b/dNet/ChatPackets.cpp
@@ -12,6 +12,20 @@
 #include "ServiceType.h"
 #include "MessageType/Chat.h"

+namespace ChatPackets {
+	// Struct Functions
+	void ChatLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool ChatLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));
+		return true;
+	}
+}
+
 void ShowAllRequest::Serialize(RakNet::BitStream& bitStream) {
 	BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::SHOW_ALL);
 	bitStream.Write(this->requestor);
--- a/dNet/ChatPackets.h
+++ b/dNet/ChatPackets.h
@@ -12,6 +12,7 @@ struct SystemAddress;
 #include "dCommonVars.h"
 #include "MessageType/Chat.h"
 #include "BitStreamUtils.h"
+#include "ClientPackets.h"

 struct ShowAllRequest{
 	LWOOBJID requestor = LWOOBJID_EMPTY;
@@ -30,28 +31,39 @@ struct FindPlayerRequest{

 namespace ChatPackets {

-	struct Announcement : public LUBitStream {
+	struct ChatLUBitStream : public LUBitStream {
+		MessageType::Chat messageType = MessageType::Chat::GENERAL_CHAT_MESSAGE;
+
+		ChatLUBitStream() : LUBitStream(ServiceType::CHAT) {};
+		ChatLUBitStream(MessageType::Chat _messageType) : LUBitStream(ServiceType::CHAT), messageType{_messageType} {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
+
+	struct Announcement : public ChatLUBitStream {
 		std::string title;
 		std::string message;

-		Announcement() : LUBitStream(ServiceType::CHAT, MessageType::Chat::GM_ANNOUNCE) {};
+		Announcement() : ChatLUBitStream(MessageType::Chat::GM_ANNOUNCE) {};
 		virtual void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct AchievementNotify : public LUBitStream {
+	struct AchievementNotify : public ChatLUBitStream {
 		LUWString targetPlayerName{};
 		uint32_t missionEmailID{};
 		LWOOBJID earningPlayerID{};
 		LUWString earnerName{};
-		AchievementNotify() : LUBitStream(ServiceType::CHAT, MessageType::Chat::ACHIEVEMENT_NOTIFY) {}
+		AchievementNotify() : ChatLUBitStream(MessageType::Chat::ACHIEVEMENT_NOTIFY) {}
 		void Serialize(RakNet::BitStream& bitstream) const override;
 		bool Deserialize(RakNet::BitStream& bitstream) override;
 	};

-	struct TeamInviteInitialResponse : public LUBitStream {
+	struct TeamInviteInitialResponse : public ClientPackets::ClientLUBitStream {
 		bool inviteFailedToSend{};
 		LUWString playerName{};
-		TeamInviteInitialResponse() : LUBitStream(ServiceType::CLIENT, MessageType::Client::TEAM_INVITE_INITIAL_RESPONSE) {}
+		TeamInviteInitialResponse() : ClientPackets::ClientLUBitStream(MessageType::Client::TEAM_INVITE_INITIAL_RESPONSE) {}

 		void Serialize(RakNet::BitStream& bitstream) const override;
 		// No Deserialize needed on our end
--- a/dNet/ClientPackets.cpp
+++ b/dNet/ClientPackets.cpp
@@ -16,7 +16,18 @@ namespace ClientPackets {
 		bitStream.Write(timestamp);
 	};

+	void ClientLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool ClientLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));		return true;
+	}
+
 	void LoginResponse::Serialize(RakNet::BitStream& bitStream) const {
+		ClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(responseCode);
 		bitStream.Write(events[0]);
 		bitStream.Write(events[1]);
--- a/dNet/ClientPackets.h
+++ b/dNet/ClientPackets.h
@@ -97,6 +97,18 @@ enum class Language : uint32_t {
 };

 namespace ClientPackets {
+
+	// Structs
+	struct ClientLUBitStream : public LUBitStream {
+		MessageType::Client messageType = MessageType::Client::LOGIN_RESPONSE;
+
+		ClientLUBitStream() : LUBitStream(ServiceType::CLIENT) {};
+		ClientLUBitStream(MessageType::Client _messageType) : LUBitStream(ServiceType::CLIENT), messageType{_messageType} {};
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
+
 	struct Stamp {
 		eStamps type;
 		uint32_t value;
@@ -111,7 +123,7 @@ namespace ClientPackets {
 		void Serialize(RakNet::BitStream& bitStream) const;
 	};

-	struct LoginResponse : public LUBitStream {
+	struct LoginResponse : public ClientLUBitStream {
 		eLoginResponse responseCode = eLoginResponse::GENERAL_FAILED;
 		std::vector<LUString> events;
 		uint16_t version_major = 0;
@@ -132,7 +144,7 @@ namespace ClientPackets {
 		std::string errorMessage;
 		std::vector<Stamp> stamps;

-		LoginResponse() : LUBitStream(ServiceType::CLIENT, MessageType::Client::LOGIN_RESPONSE) {}
+		LoginResponse() : ClientLUBitStream(MessageType::Client::LOGIN_RESPONSE) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

--- a/dNet/CommonPackets.cpp
+++ b/dNet/CommonPackets.cpp
@@ -22,7 +22,20 @@ namespace CommonPackets {
 		}}
 	};

+	// Struct Functions
+	void CommonLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool CommonLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));
+		return true;
+	}
+
 	void VersionConfirm::Serialize(RakNet::BitStream& bitStream) const {
+		CommonLUBitStream::Serialize(bitStream);
 		bitStream.Write<uint32_t>(netVersion);
 		bitStream.Write<uint32_t>(861228100);
 		bitStream.Write(static_cast<uint32_t>(serviceType));
@@ -59,28 +72,28 @@ namespace CommonPackets {
 	}

 	void GeneralNotify::Serialize(RakNet::BitStream& bitStream) const {
+		CommonLUBitStream::Serialize(bitStream);
 		bitStream.Write(notifyID);
 		bitStream.Write(notifyUser);
 	}
 }

 void CommonPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
-	inStream.ResetReadPointer();
-	LUBitStream lubitstream;
-	if (!lubitstream.ReadHeader(inStream)) return;
+	CommonLUBitStream lubitstream;
+	if (!lubitstream.Deserialize(inStream)) return;

-	auto it = g_Handlers.find(static_cast<MessageType::Server>(lubitstream.internalPacketID));
+	auto it = g_Handlers.find(lubitstream.messageType);
 	if (it != g_Handlers.end()) {
 		auto request = it->second();
 		request->sysAddr = sysAddr;
 		if (!request->Deserialize(inStream)) {
-			LOG_DEBUG("Error Reading Common Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Server>(lubitstream.internalPacketID)).data());
+			LOG_DEBUG("Error Reading Common Packet: %s", StringifiedEnum::ToString(lubitstream.messageType).data());
 			return;
 		}
-		LOG_DEBUG("Received Common Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Server>(lubitstream.internalPacketID)).data());
+		LOG_DEBUG("Received Common Packet: %s", StringifiedEnum::ToString(lubitstream.messageType).data());
 		request->Handle();
 	} else {
-		LOG_DEBUG("Unhandled Common Packet with ID: %i", lubitstream.internalPacketID);
+		LOG_DEBUG("Unhandled Common Packet with ID: %i", lubitstream.messageType);
 	}
 }

--- a/dNet/CommonPackets.h
+++ b/dNet/CommonPackets.h
@@ -23,31 +23,42 @@ enum class eServerDisconnectIdentifiers : uint32_t {

 // Packet Struct Functions
 namespace CommonPackets {
+	// Structs
+	struct CommonLUBitStream : public LUBitStream {
+		MessageType::Server messageType = MessageType::Server::VERSION_CONFIRM;

-	struct VersionConfirm : public LUBitStream {
+		CommonLUBitStream() : LUBitStream(ServiceType::COMMON) {};
+		CommonLUBitStream(MessageType::Server _messageType) : LUBitStream(ServiceType::COMMON), messageType{_messageType} {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
+
+	struct VersionConfirm : public CommonLUBitStream {
 		uint32_t netVersion = 0;
 		ServiceType serviceType;
 		uint32_t processID = 0;
 		uint16_t port = 0;

-		VersionConfirm() : LUBitStream(ServiceType::COMMON, MessageType::Server::VERSION_CONFIRM) {}
+		VersionConfirm() : CommonLUBitStream(MessageType::Server::VERSION_CONFIRM) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};

-	struct DisconnectNotify : public LUBitStream {
+	struct DisconnectNotify : public CommonLUBitStream {
 		eServerDisconnectIdentifiers disconnectID = eServerDisconnectIdentifiers::UNKNOWN_SERVER_ERROR;

-		DisconnectNotify() : LUBitStream(ServiceType::COMMON, MessageType::Server::DISCONNECT_NOTIFY) {}
+		DisconnectNotify() : CommonLUBitStream(MessageType::Server::DISCONNECT_NOTIFY) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};

-	struct GeneralNotify : public LUBitStream {
+	struct GeneralNotify : public CommonLUBitStream {
 		uint32_t notifyID = 0; // only one known value: 0, which is Duplicate account login
 		bool notifyUser = true;

-		GeneralNotify() : LUBitStream(ServiceType::COMMON, MessageType::Server::GENERAL_NOTIFY) {}
+		GeneralNotify() : CommonLUBitStream(MessageType::Server::GENERAL_NOTIFY) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 	
--- a/dNet/WorldPackets.cpp
+++ b/dNet/WorldPackets.cpp
@@ -12,6 +12,20 @@

 #include <iostream>

+namespace WorldPackets {
+	// Struct Functions	
+	void WorldLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool WorldLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));
+		return true;
+	}
+}
+
 void HTTPMonitorInfo::Serialize(RakNet::BitStream& bitStream) const {
 	bitStream.Write(port);
 	bitStream.Write<uint8_t>(openWeb);
--- a/dNet/WorldPackets.h
+++ b/dNet/WorldPackets.h
@@ -4,6 +4,7 @@
 #include "dCommonVars.h"
 #include <vector>
 #include <string>
+#include "MessageType/World.h"

 class User;
 struct SystemAddress;
@@ -25,6 +26,16 @@ struct HTTPMonitorInfo {
 };

 namespace WorldPackets {
+	struct WorldLUBitStream : public LUBitStream {
+		MessageType::World messageType = MessageType::World::VALIDATION;
+
+		WorldLUBitStream() : LUBitStream(ServiceType::WORLD) {};
+		WorldLUBitStream(MessageType::World messageType) : LUBitStream(ServiceType::WORLD), messageType{messageType} {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
 	void SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone);
 	void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
 	void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);
--- a/dWorldServer/WorldServer.cpp
+++ b/dWorldServer/WorldServer.cpp
@@ -859,12 +859,15 @@ void HandlePacket(Packet* packet) {
 	LUBitStream luBitStream;
 	luBitStream.ReadHeader(inStream);

-	if (luBitStream.connectionType == ServiceType::COMMON) {
+	if (luBitStream.serviceType == ServiceType::COMMON) {
 		CommonPackets::Handle(inStream, packet->systemAddress);
 	}

-	if (luBitStream.connectionType != ServiceType::WORLD) return;
-	switch (static_cast<MessageType::World>(luBitStream.internalPacketID)) {
+	if (luBitStream.serviceType != ServiceType::WORLD) return;
+	WorldPackets::WorldLUBitStream worldLUBitStream;
+	worldLUBitStream.Deserialize(inStream);
+
+	switch (static_cast<MessageType::World>(worldLUBitStream.messageType)) {
 	case MessageType::World::VALIDATION: {
 		CINSTREAM_SKIP_HEADER;
 		LUWString username;
@@ -1238,7 +1241,7 @@ void HandlePacket(Packet* packet) {
 	}

 	case MessageType::World::MAIL: {
-		Mail::HandleMail(inStream, packet->systemAddress, UserManager::Instance()->GetUser(packet->systemAddress)->GetLastUsedChar()->GetEntity());
+		Mail::Handle(inStream, packet->systemAddress, UserManager::Instance()->GetUser(packet->systemAddress)->GetLastUsedChar()->GetEntity());
 		break;
 	}