Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2025-10-12 18:38:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Aaron Kimbrell
2025-09-12 22:25:55 -05:00
parent b36b440eba
commit 500a72dc11
16 changed files with 217 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
dAuthServer/AuthServer.cpp
View File

@@ -165,15 +165,12 @@ int main(int argc, char** argv) {
} }
void HandlePacket(Packet* packet) { void HandlePacket(Packet* packet) {
if (packet->length < 4) return;
CINSTREAM; CINSTREAM;
LUBitStream luBitStream; LUBitStream luBitStream;
if (!luBitStream.ReadHeader(inStream)) return; if (!luBitStream.ReadHeader(inStream) && luBitStream.rakNetID != ID_USER_PACKET_ENUM) return;
else if (luBitStream.serviceType == ServiceType::COMMON) {
if (luBitStream.connectionType == ServiceType::COMMON) {
CommonPackets::Handle(inStream, packet->systemAddress); CommonPackets::Handle(inStream, packet->systemAddress);
} else if (luBitStream.connectionType == ServiceType::AUTH) { } else if (luBitStream.serviceType == ServiceType::AUTH) {
AuthPackets::Handle(inStream, packet->systemAddress); AuthPackets::Handle(inStream, packet->systemAddress);
} }
} }

36
dGame/dUtilities/Mail.cpp
View File

@@ -34,7 +34,7 @@ namespace {
} }
namespace Mail { 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, []() { {eMessageID::SendRequest, []() {
return std::make_unique<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); bitStream.Write(messageID);
} }
bool MailLUBitStream::Deserialize(RakNet::BitStream& bitstream) { bool MailClientLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
VALIDATE_READ(bitstream.Read(messageID)); VALIDATE_READ(bitstream.Read(messageID));
return true; return true;
} }
@@ -133,16 +133,16 @@ namespace Mail {
response.status = eSendResponse::SenderAccountIsMuted; response.status = eSendResponse::SenderAccountIsMuted;
} }
LOG("Finished send with status %s", StringifiedEnum::ToString(response.status).data()); LOG("Finished send with status %s", StringifiedEnum::ToString(response.status).data());
response.Send(sysAddr); response.Send();
} }
void SendResponse::Serialize(RakNet::BitStream& bitStream) const { void SendResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(status); bitStream.Write(status);
} }
void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const { void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(status); bitStream.Write(status);
bitStream.Write<uint64_t>(0); // unused bitStream.Write<uint64_t>(0); // unused
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); auto playerMail = Database::Get()->GetMailForPlayer(character->GetID(), 20);
DataResponse response; DataResponse response;
response.playerMail = playerMail; response.playerMail = playerMail;
response.Send(sysAddr); response.Send();
LOG("DataRequest"); LOG("DataRequest");
} }
void DataResponse::Serialize(RakNet::BitStream& bitStream) const { void DataResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(this->throttled); bitStream.Write(this->throttled);
bitStream.Write<uint16_t>(this->playerMail.size()); bitStream.Write<uint16_t>(this->playerMail.size());
@@ -199,11 +199,11 @@ namespace Mail {
} }
} }
LOG("AttachmentCollectResponse %s", StringifiedEnum::ToString(response.status).data()); LOG("AttachmentCollectResponse %s", StringifiedEnum::ToString(response.status).data());
response.Send(sysAddr); response.Send();
} }
void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const { void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(status); bitStream.Write(status);
bitStream.Write(mailID); bitStream.Write(mailID);
} }
@@ -230,11 +230,11 @@ namespace Mail {
response.status = eDeleteResponse::NotFound; response.status = eDeleteResponse::NotFound;
} }
LOG("DeleteRequest status %s", StringifiedEnum::ToString(response.status).data()); LOG("DeleteRequest status %s", StringifiedEnum::ToString(response.status).data());
response.Send(sysAddr); response.Send();
} }
void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const { void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(status); bitStream.Write(status);
bitStream.Write(mailID); bitStream.Write(mailID);
} }
@@ -256,11 +256,11 @@ namespace Mail {
} }
LOG("ReadRequest %s", StringifiedEnum::ToString(response.status).data()); LOG("ReadRequest %s", StringifiedEnum::ToString(response.status).data());
response.Send(sysAddr); response.Send();
} }
void ReadResponse::Serialize(RakNet::BitStream& bitStream) const { void ReadResponse::Serialize(RakNet::BitStream& bitStream) const {
MailLUBitStream::Serialize(bitStream); MailClientLUBitStream::Serialize(bitStream);
bitStream.Write(status); bitStream.Write(status);
bitStream.Write(mailID); bitStream.Write(mailID);
} }
@@ -275,13 +275,13 @@ namespace Mail {
} }
LOG("NotificationRequest %s", StringifiedEnum::ToString(response.status).data()); LOG("NotificationRequest %s", StringifiedEnum::ToString(response.status).data());
response.Send(sysAddr); response.Send();
} }
} }
// Non Stuct Functions // Non Stuct Functions
void Mail::HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) { void Mail::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
MailLUBitStream data; MailClientLUBitStream data;
if (!data.Deserialize(inStream)) { if (!data.Deserialize(inStream)) {
LOG_DEBUG("Error Reading Mail header"); LOG_DEBUG("Error Reading Mail header");
return; 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 if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) return; // TODO: Echo to chat server
NotificationResponse response; NotificationResponse response;
response.status = eNotificationResponse::NewMail; response.status = eNotificationResponse::NewMail;
response.Send(sysAddr); response.Send();
} }

58
dGame/dUtilities/Mail.h
View File

@@ -7,6 +7,8 @@
#include "dCommonVars.h" #include "dCommonVars.h"
#include "BitStreamUtils.h" #include "BitStreamUtils.h"
#include "MailInfo.h" #include "MailInfo.h"
#include "MessageType/Client.h"
#include "ClientPackets.h"
class Entity; class Entity;
@@ -103,111 +105,111 @@ namespace Mail {
UnknownError UnknownError
}; };
struct MailLUBitStream : public LUBitStream { struct MailClientLUBitStream : public ClientPackets::ClientLUBitStream {
eMessageID messageID = eMessageID::UnknownError; eMessageID messageID = eMessageID::UnknownError;
Entity* player = nullptr; Entity* player = nullptr;
MailLUBitStream() = default; MailClientLUBitStream() = default;
MailLUBitStream(eMessageID _messageID) : LUBitStream(ServiceType::CLIENT, MessageType::Client::MAIL), messageID{_messageID} {}; MailClientLUBitStream(eMessageID _messageID) : ClientPackets::ClientLUBitStream(MessageType::Client::MAIL), messageID{_messageID} {};
virtual void Serialize(RakNet::BitStream& bitStream) const override; virtual void Serialize(RakNet::BitStream& bitStream) const override;
virtual bool Deserialize(RakNet::BitStream& bitStream) override; virtual bool Deserialize(RakNet::BitStream& bitStream) override;
virtual void Handle() override {}; virtual void Handle() override {};
}; };
struct SendRequest : public MailLUBitStream { struct SendRequest : public MailClientLUBitStream {
MailInfo mailInfo; MailInfo mailInfo;
SendRequest() : MailLUBitStream(eMessageID::SendRequest) {} SendRequest() : MailClientLUBitStream(eMessageID::SendRequest) {}
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct SendResponse :public MailLUBitStream { struct SendResponse :public MailClientLUBitStream {
eSendResponse status = eSendResponse::UnknownError; eSendResponse status = eSendResponse::UnknownError;
SendResponse() : MailLUBitStream(eMessageID::SendResponse) {} SendResponse() : MailClientLUBitStream(eMessageID::SendResponse) {}
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct NotificationResponse : public MailLUBitStream { struct NotificationResponse : public MailClientLUBitStream {
eNotificationResponse status = eNotificationResponse::UnknownError; eNotificationResponse status = eNotificationResponse::UnknownError;
LWOOBJID auctionID = LWOOBJID_EMPTY; LWOOBJID auctionID = LWOOBJID_EMPTY;
uint32_t mailCount = 1; uint32_t mailCount = 1;
NotificationResponse() : MailLUBitStream(eMessageID::NotificationResponse) {}; NotificationResponse() : MailClientLUBitStream(eMessageID::NotificationResponse) {};
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct DataRequest : public MailLUBitStream { struct DataRequest : public MailClientLUBitStream {
DataRequest() : MailLUBitStream(eMessageID::DataRequest) {} DataRequest() : MailClientLUBitStream(eMessageID::DataRequest) {}
bool Deserialize(RakNet::BitStream& bitStream) override { return true; }; bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
void Handle() override; void Handle() override;
}; };
struct DataResponse : public MailLUBitStream { struct DataResponse : public MailClientLUBitStream {
uint32_t throttled = 0; uint32_t throttled = 0;
std::vector<MailInfo> playerMail; std::vector<MailInfo> playerMail;
DataResponse() : MailLUBitStream(eMessageID::DataResponse) {}; DataResponse() : MailClientLUBitStream(eMessageID::DataResponse) {};
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct AttachmentCollectRequest : public MailLUBitStream { struct AttachmentCollectRequest : public MailClientLUBitStream {
uint64_t mailID = 0; uint64_t mailID = 0;
LWOOBJID playerID = LWOOBJID_EMPTY; LWOOBJID playerID = LWOOBJID_EMPTY;
AttachmentCollectRequest() : MailLUBitStream(eMessageID::AttachmentCollectRequest) {}; AttachmentCollectRequest() : MailClientLUBitStream(eMessageID::AttachmentCollectRequest) {};
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct AttachmentCollectResponse : public MailLUBitStream { struct AttachmentCollectResponse : public MailClientLUBitStream {
eAttachmentCollectResponse status = eAttachmentCollectResponse::UnknownError; eAttachmentCollectResponse status = eAttachmentCollectResponse::UnknownError;
uint64_t mailID = 0; uint64_t mailID = 0;
AttachmentCollectResponse() : MailLUBitStream(eMessageID::AttachmentCollectResponse) {}; AttachmentCollectResponse() : MailClientLUBitStream(eMessageID::AttachmentCollectResponse) {};
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct DeleteRequest : public MailLUBitStream { struct DeleteRequest : public MailClientLUBitStream {
uint64_t mailID = 0; uint64_t mailID = 0;
LWOOBJID playerID = LWOOBJID_EMPTY; LWOOBJID playerID = LWOOBJID_EMPTY;
DeleteRequest() : MailLUBitStream(eMessageID::DeleteRequest) {}; DeleteRequest() : MailClientLUBitStream(eMessageID::DeleteRequest) {};
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct DeleteResponse : public MailLUBitStream { struct DeleteResponse : public MailClientLUBitStream {
eDeleteResponse status = eDeleteResponse::UnknownError; eDeleteResponse status = eDeleteResponse::UnknownError;
uint64_t mailID = 0; uint64_t mailID = 0;
DeleteResponse() : MailLUBitStream(eMessageID::DeleteResponse) {}; DeleteResponse() : MailClientLUBitStream(eMessageID::DeleteResponse) {};
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct ReadRequest : public MailLUBitStream { struct ReadRequest : public MailClientLUBitStream {
uint64_t mailID = 0; uint64_t mailID = 0;
ReadRequest() : MailLUBitStream(eMessageID::ReadRequest) {}; ReadRequest() : MailClientLUBitStream(eMessageID::ReadRequest) {};
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct ReadResponse : public MailLUBitStream { struct ReadResponse : public MailClientLUBitStream {
uint64_t mailID = 0; uint64_t mailID = 0;
eReadResponse status = eReadResponse::UnknownError; eReadResponse status = eReadResponse::UnknownError;
ReadResponse() : MailLUBitStream(eMessageID::ReadResponse) {}; ReadResponse() : MailClientLUBitStream(eMessageID::ReadResponse) {};
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct NotificationRequest : public MailLUBitStream { struct NotificationRequest : public MailClientLUBitStream {
NotificationRequest() : MailLUBitStream(eMessageID::NotificationRequest) {}; NotificationRequest() : MailClientLUBitStream(eMessageID::NotificationRequest) {};
bool Deserialize(RakNet::BitStream& bitStream) override { return true; }; bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
void Handle() override; 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( void SendMail(
const Entity* recipient, const Entity* recipient,

25
dNet/AuthPackets.cpp
View File

@@ -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) { bool LoginRequest::Deserialize(RakNet::BitStream& bitStream) {
LUWString usernameLUString; LUWString usernameLUString;
VALIDATE_READ(bitStream.Read(usernameLUString)); VALIDATE_READ(bitStream.Read(usernameLUString));
@@ -228,22 +240,21 @@ void AuthPackets::LoadClaimCodes() {
// Non Stuct Functions // Non Stuct Functions
void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) { void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
inStream.ResetReadPointer(); AuthLUBitStream authLUBitStream;
LUBitStream lubitstream; if (!authLUBitStream.Deserialize(inStream)) return;
if (!lubitstream.ReadHeader(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()) { if (it != g_Handlers.end()) {
auto request = it->second(); auto request = it->second();
request->sysAddr = sysAddr; request->sysAddr = sysAddr;
if (!request->Deserialize(inStream)) { 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; 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(); request->Handle();
} else { } else {
LOG_DEBUG("Unhandled Auth Packet with ID: %i", lubitstream.internalPacketID); LOG_DEBUG("Unhandled Auth Packet with ID: %i", authLUBitStream.messageType);
} }
} }

15
dNet/AuthPackets.h
View File

@@ -34,7 +34,18 @@ struct magic_enum::customize::enum_range<LanguageCodeID> {
namespace AuthPackets { 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 username;
std::string password; std::string password;
LanguageCodeID locale_id; LanguageCodeID locale_id;
@@ -57,7 +68,7 @@ namespace AuthPackets {
} osVersionInfo; } osVersionInfo;
} computerInfo; } computerInfo;
LoginRequest() : LUBitStream(ServiceType::AUTH, MessageType::Auth::LOGIN_REQUEST) {} LoginRequest() : AuthLUBitStream(MessageType::Auth::LOGIN_REQUEST) {}
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };

12
dNet/BitStreamUtils.cpp
View File

@@ -6,18 +6,12 @@
void LUBitStream::WriteHeader(RakNet::BitStream& bitStream) const { void LUBitStream::WriteHeader(RakNet::BitStream& bitStream) const {
bitStream.Write<MessageID>(ID_USER_PACKET_ENUM); bitStream.Write<MessageID>(ID_USER_PACKET_ENUM);
bitStream.Write(this->connectionType); bitStream.Write(this->serviceType);
bitStream.Write(this->internalPacketID);
bitStream.Write<uint8_t>(0); // padding
} }
bool LUBitStream::ReadHeader(RakNet::BitStream& bitStream) { bool LUBitStream::ReadHeader(RakNet::BitStream& bitStream) {
MessageID messageID; VALIDATE_READ(bitStream.Read(this->rakNetID));
bitStream.Read(messageID); VALIDATE_READ(bitStream.Read(this->serviceType));
if (messageID != ID_USER_PACKET_ENUM) return false;
VALIDATE_READ(bitStream.Read(this->connectionType));
VALIDATE_READ(bitStream.Read(this->internalPacketID));
bitStream.IgnoreBytes(1);
return true; return true;
} }

12
dNet/BitStreamUtils.h
View File

@@ -47,16 +47,16 @@ struct LUWString {
}; };
struct LUBitStream { struct LUBitStream {
ServiceType connectionType = ServiceType::UNKNOWN; // Common header data that is serialized
uint32_t internalPacketID = 0xFFFFFFFF; MessageID rakNetID = ID_USER_PACKET_ENUM;
ServiceType serviceType = ServiceType::UNKNOWN;
SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS; SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
LUBitStream() = default; LUBitStream() = default;
template <typename T> LUBitStream(ServiceType serviceType) {
LUBitStream(ServiceType connectionType, T internalPacketID) { this->serviceType = serviceType;
this->connectionType = connectionType;
this->internalPacketID = static_cast<uint32_t>(internalPacketID);
} }
void WriteHeader(RakNet::BitStream& bitStream) const; void WriteHeader(RakNet::BitStream& bitStream) const;

14
dNet/ChatPackets.cpp
View File

@@ -12,6 +12,20 @@
#include "ServiceType.h" #include "ServiceType.h"
#include "MessageType/Chat.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) { void ShowAllRequest::Serialize(RakNet::BitStream& bitStream) {
BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::SHOW_ALL); BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::SHOW_ALL);
bitStream.Write(this->requestor); bitStream.Write(this->requestor);

24
dNet/ChatPackets.h
View File

@@ -12,6 +12,7 @@ struct SystemAddress;
#include "dCommonVars.h" #include "dCommonVars.h"
#include "MessageType/Chat.h" #include "MessageType/Chat.h"
#include "BitStreamUtils.h" #include "BitStreamUtils.h"
#include "ClientPackets.h"
struct ShowAllRequest{ struct ShowAllRequest{
LWOOBJID requestor = LWOOBJID_EMPTY; LWOOBJID requestor = LWOOBJID_EMPTY;
@@ -30,28 +31,39 @@ struct FindPlayerRequest{
namespace ChatPackets { 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 title;
std::string message; 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; virtual void Serialize(RakNet::BitStream& bitStream) const override;
}; };
struct AchievementNotify : public LUBitStream { struct AchievementNotify : public ChatLUBitStream {
LUWString targetPlayerName{}; LUWString targetPlayerName{};
uint32_t missionEmailID{}; uint32_t missionEmailID{};
LWOOBJID earningPlayerID{}; LWOOBJID earningPlayerID{};
LUWString earnerName{}; LUWString earnerName{};
AchievementNotify() : LUBitStream(ServiceType::CHAT, MessageType::Chat::ACHIEVEMENT_NOTIFY) {} AchievementNotify() : ChatLUBitStream(MessageType::Chat::ACHIEVEMENT_NOTIFY) {}
void Serialize(RakNet::BitStream& bitstream) const override; void Serialize(RakNet::BitStream& bitstream) const override;
bool Deserialize(RakNet::BitStream& bitstream) override; bool Deserialize(RakNet::BitStream& bitstream) override;
}; };
struct TeamInviteInitialResponse : public LUBitStream { struct TeamInviteInitialResponse : public ClientPackets::ClientLUBitStream {
bool inviteFailedToSend{}; bool inviteFailedToSend{};
LUWString playerName{}; 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; void Serialize(RakNet::BitStream& bitstream) const override;
// No Deserialize needed on our end // No Deserialize needed on our end

11
dNet/ClientPackets.cpp
View File

@@ -16,7 +16,18 @@ namespace ClientPackets {
bitStream.Write(timestamp); 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 { void LoginResponse::Serialize(RakNet::BitStream& bitStream) const {
ClientLUBitStream::Serialize(bitStream);
bitStream.Write(responseCode); bitStream.Write(responseCode);
bitStream.Write(events[0]); bitStream.Write(events[0]);
bitStream.Write(events[1]); bitStream.Write(events[1]);

16
dNet/ClientPackets.h
View File

@@ -97,6 +97,18 @@ enum class Language : uint32_t {
}; };
namespace ClientPackets { 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 { struct Stamp {
eStamps type; eStamps type;
uint32_t value; uint32_t value;
@@ -111,7 +123,7 @@ namespace ClientPackets {
void Serialize(RakNet::BitStream& bitStream) const; void Serialize(RakNet::BitStream& bitStream) const;
}; };
struct LoginResponse : public LUBitStream { struct LoginResponse : public ClientLUBitStream {
eLoginResponse responseCode = eLoginResponse::GENERAL_FAILED; eLoginResponse responseCode = eLoginResponse::GENERAL_FAILED;
std::vector<LUString> events; std::vector<LUString> events;
uint16_t version_major = 0; uint16_t version_major = 0;
@@ -132,7 +144,7 @@ namespace ClientPackets {
std::string errorMessage; std::string errorMessage;
std::vector<Stamp> stamps; 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; void Serialize(RakNet::BitStream& bitStream) const override;
}; };

27
dNet/CommonPackets.cpp
View File

@@ -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 { void VersionConfirm::Serialize(RakNet::BitStream& bitStream) const {
CommonLUBitStream::Serialize(bitStream);
bitStream.Write<uint32_t>(netVersion); bitStream.Write<uint32_t>(netVersion);
bitStream.Write<uint32_t>(861228100); bitStream.Write<uint32_t>(861228100);
bitStream.Write(static_cast<uint32_t>(serviceType)); bitStream.Write(static_cast<uint32_t>(serviceType));
@@ -59,28 +72,28 @@ namespace CommonPackets {
} }
void GeneralNotify::Serialize(RakNet::BitStream& bitStream) const { void GeneralNotify::Serialize(RakNet::BitStream& bitStream) const {
CommonLUBitStream::Serialize(bitStream);
bitStream.Write(notifyID); bitStream.Write(notifyID);
bitStream.Write(notifyUser); bitStream.Write(notifyUser);
} }
} }
void CommonPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) { void CommonPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
inStream.ResetReadPointer(); CommonLUBitStream lubitstream;
LUBitStream lubitstream; if (!lubitstream.Deserialize(inStream)) return;
if (!lubitstream.ReadHeader(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()) { if (it != g_Handlers.end()) {
auto request = it->second(); auto request = it->second();
request->sysAddr = sysAddr; request->sysAddr = sysAddr;
if (!request->Deserialize(inStream)) { 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; 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(); request->Handle();
} else { } else {
LOG_DEBUG("Unhandled Common Packet with ID: %i", lubitstream.internalPacketID); LOG_DEBUG("Unhandled Common Packet with ID: %i", lubitstream.messageType);
} }
} }

23
dNet/CommonPackets.h
View File

@@ -23,31 +23,42 @@ enum class eServerDisconnectIdentifiers : uint32_t {
// Packet Struct Functions // Packet Struct Functions
namespace CommonPackets { 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; uint32_t netVersion = 0;
ServiceType serviceType; ServiceType serviceType;
uint32_t processID = 0; uint32_t processID = 0;
uint16_t port = 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; void Serialize(RakNet::BitStream& bitStream) const override;
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct DisconnectNotify : public LUBitStream { struct DisconnectNotify : public CommonLUBitStream {
eServerDisconnectIdentifiers disconnectID = eServerDisconnectIdentifiers::UNKNOWN_SERVER_ERROR; 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; 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 uint32_t notifyID = 0; // only one known value: 0, which is Duplicate account login
bool notifyUser = true; bool notifyUser = true;
GeneralNotify() : LUBitStream(ServiceType::COMMON, MessageType::Server::GENERAL_NOTIFY) {} GeneralNotify() : CommonLUBitStream(MessageType::Server::GENERAL_NOTIFY) {}
void Serialize(RakNet::BitStream& bitStream) const override; void Serialize(RakNet::BitStream& bitStream) const override;
}; };

14
dNet/WorldPackets.cpp
View File

@@ -12,6 +12,20 @@
#include <iostream> #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 { void HTTPMonitorInfo::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(port); bitStream.Write(port);
bitStream.Write<uint8_t>(openWeb); bitStream.Write<uint8_t>(openWeb);

11
dNet/WorldPackets.h
View File

@@ -4,6 +4,7 @@
#include "dCommonVars.h" #include "dCommonVars.h"
#include <vector> #include <vector>
#include <string> #include <string>
#include "MessageType/World.h"
class User; class User;
struct SystemAddress; struct SystemAddress;
@@ -25,6 +26,16 @@ struct HTTPMonitorInfo {
}; };
namespace WorldPackets { 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 SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone);
void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response); void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response); void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);

11
dWorldServer/WorldServer.cpp
View File

@@ -859,12 +859,15 @@ void HandlePacket(Packet* packet) {
LUBitStream luBitStream; LUBitStream luBitStream;
luBitStream.ReadHeader(inStream); luBitStream.ReadHeader(inStream);
if (luBitStream.connectionType == ServiceType::COMMON) { if (luBitStream.serviceType == ServiceType::COMMON) {
CommonPackets::Handle(inStream, packet->systemAddress); CommonPackets::Handle(inStream, packet->systemAddress);
} }
if (luBitStream.connectionType != ServiceType::WORLD) return; if (luBitStream.serviceType != ServiceType::WORLD) return;
switch (static_cast<MessageType::World>(luBitStream.internalPacketID)) { WorldPackets::WorldLUBitStream worldLUBitStream;
worldLUBitStream.Deserialize(inStream);
switch (static_cast<MessageType::World>(worldLUBitStream.messageType)) {
case MessageType::World::VALIDATION: { case MessageType::World::VALIDATION: {
CINSTREAM_SKIP_HEADER; CINSTREAM_SKIP_HEADER;
LUWString username; LUWString username;
@@ -1238,7 +1241,7 @@ void HandlePacket(Packet* packet) {
} }
case MessageType::World::MAIL: { 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; break;
} }