From 500a72dc11d96a460771f23a2951ca113ecbec50 Mon Sep 17 00:00:00 2001 From: Aaron Kimbrell Date: Fri, 12 Sep 2025 22:25:55 -0500 Subject: [PATCH] Change LUBitstream to make more sense and only read what it needs from the bitstream at each level --- dAuthServer/AuthServer.cpp | 9 ++---- dGame/dUtilities/Mail.cpp | 36 +++++++++++----------- dGame/dUtilities/Mail.h | 58 +++++++++++++++++++----------------- dNet/AuthPackets.cpp | 25 +++++++++++----- dNet/AuthPackets.h | 15 ++++++++-- dNet/BitStreamUtils.cpp | 12 ++------ dNet/BitStreamUtils.h | 12 ++++---- dNet/ChatPackets.cpp | 14 +++++++++ dNet/ChatPackets.h | 24 +++++++++++---- dNet/ClientPackets.cpp | 11 +++++++ dNet/ClientPackets.h | 16 ++++++++-- dNet/CommonPackets.cpp | 27 ++++++++++++----- dNet/CommonPackets.h | 23 ++++++++++---- dNet/WorldPackets.cpp | 14 +++++++++ dNet/WorldPackets.h | 11 +++++++ dWorldServer/WorldServer.cpp | 11 ++++--- 16 files changed, 217 insertions(+), 101 deletions(-) diff --git a/dAuthServer/AuthServer.cpp b/dAuthServer/AuthServer.cpp index ed5f9bc6..fefa83e7 100644 --- 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); } } diff --git a/dGame/dUtilities/Mail.cpp b/dGame/dUtilities/Mail.cpp index 5ab82f61..9b39e26b 100644 --- a/dGame/dUtilities/Mail.cpp +++ b/dGame/dUtilities/Mail.cpp @@ -34,7 +34,7 @@ namespace { } namespace Mail { - std::map()>> g_Handlers = { + std::map()>> g_Handlers = { {eMessageID::SendRequest, []() { return std::make_unique(); }}, @@ -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(0); // unused bitStream.Write(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(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(); } diff --git a/dGame/dUtilities/Mail.h b/dGame/dUtilities/Mail.h index 1735ef43..5182090a 100644 --- 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 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, diff --git a/dNet/AuthPackets.cpp b/dNet/AuthPackets.cpp index 87a445cd..a39aa545 100644 --- 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(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(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(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(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); } } diff --git a/dNet/AuthPackets.h b/dNet/AuthPackets.h index 190a8e24..a4cdfaaf 100644 --- a/dNet/AuthPackets.h +++ b/dNet/AuthPackets.h @@ -34,7 +34,18 @@ struct magic_enum::customize::enum_range { 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; }; diff --git a/dNet/BitStreamUtils.cpp b/dNet/BitStreamUtils.cpp index 91273785..e5dec71e 100644 --- a/dNet/BitStreamUtils.cpp +++ b/dNet/BitStreamUtils.cpp @@ -6,18 +6,12 @@ void LUBitStream::WriteHeader(RakNet::BitStream& bitStream) const { bitStream.Write(ID_USER_PACKET_ENUM); - bitStream.Write(this->connectionType); - bitStream.Write(this->internalPacketID); - bitStream.Write(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; } diff --git a/dNet/BitStreamUtils.h b/dNet/BitStreamUtils.h index 9560d16c..bcfc9471 100644 --- 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 - LUBitStream(ServiceType connectionType, T internalPacketID) { - this->connectionType = connectionType; - this->internalPacketID = static_cast(internalPacketID); + LUBitStream(ServiceType serviceType) { + this->serviceType = serviceType; } void WriteHeader(RakNet::BitStream& bitStream) const; diff --git a/dNet/ChatPackets.cpp b/dNet/ChatPackets.cpp index 86622ad1..0c6ae5be 100644 --- 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(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); diff --git a/dNet/ChatPackets.h b/dNet/ChatPackets.h index 53d0eced..918259d8 100644 --- 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 diff --git a/dNet/ClientPackets.cpp b/dNet/ClientPackets.cpp index 886f9c53..2c48eab9 100644 --- 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(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]); diff --git a/dNet/ClientPackets.h b/dNet/ClientPackets.h index 4029f9b3..6661d7a0 100644 --- 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 events; uint16_t version_major = 0; @@ -132,7 +144,7 @@ namespace ClientPackets { std::string errorMessage; std::vector stamps; - LoginResponse() : LUBitStream(ServiceType::CLIENT, MessageType::Client::LOGIN_RESPONSE) {} + LoginResponse() : ClientLUBitStream(MessageType::Client::LOGIN_RESPONSE) {} void Serialize(RakNet::BitStream& bitStream) const override; }; diff --git a/dNet/CommonPackets.cpp b/dNet/CommonPackets.cpp index 2a04ba5c..a35b009a 100644 --- 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(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(netVersion); bitStream.Write(861228100); bitStream.Write(static_cast(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(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(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(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); } } diff --git a/dNet/CommonPackets.h b/dNet/CommonPackets.h index 69d17253..da89f9fe 100644 --- 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; }; diff --git a/dNet/WorldPackets.cpp b/dNet/WorldPackets.cpp index 1c9898a9..ce1236ba 100644 --- a/dNet/WorldPackets.cpp +++ b/dNet/WorldPackets.cpp @@ -12,6 +12,20 @@ #include +namespace WorldPackets { + // Struct Functions + void WorldLUBitStream::Serialize(RakNet::BitStream& bitStream) const { + bitStream.Write(this->messageType); + bitStream.Write(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(openWeb); diff --git a/dNet/WorldPackets.h b/dNet/WorldPackets.h index 1a48f5df..f99c9920 100644 --- a/dNet/WorldPackets.h +++ b/dNet/WorldPackets.h @@ -4,6 +4,7 @@ #include "dCommonVars.h" #include #include +#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); diff --git a/dWorldServer/WorldServer.cpp b/dWorldServer/WorldServer.cpp index 2e0978a4..413bc8f7 100644 --- 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(luBitStream.internalPacketID)) { + if (luBitStream.serviceType != ServiceType::WORLD) return; + WorldPackets::WorldLUBitStream worldLUBitStream; + worldLUBitStream.Deserialize(inStream); + + switch (static_cast(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; }