Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2024-11-21 21:17:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: cleanup LU(W)string writing (#1188)

Browse Source 
* chore: cleanup LU(W)string writing
and add methods for reading
remove redunent "packet" from packet reading helpers
move write header to bitstreamutils since it's not packet related
add tests for reading/writing LU(W)Strings

* remove un-needed function defintions in header

* make reading and writing more efficient

* p

p

* quotes

* remove unneeded default

---------

Co-authored-by: David Markowitz <39972741+EmosewaMC@users.noreply.github.com>
This commit is contained in:
Aaron Kimbrell 2023-09-20 20:06:28 -05:00 committed by GitHub
parent ca78a166d9
commit 08020cd86d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 537 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
dChatServer/ChatPacketHandler.cpp
View File

@ -3,6 +3,7 @@
#include "Database.h" #include "Database.h"
#include <vector> #include <vector>
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "Game.h" #include "Game.h"
#include "dServer.h" #include "dServer.h"
#include "GeneralUtils.h" #include "GeneralUtils.h"
@ -75,11 +76,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
//Now, we need to send the friendlist to the server they came from: //Now, we need to send the friendlist to the server they came from:
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(playerID); bitStream.Write(playerID);
//portion that will get routed: //portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
bitStream.Write<uint8_t>(0); bitStream.Write<uint8_t>(0);
bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it. bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
bitStream.Write((uint16_t)friends.size()); bitStream.Write((uint16_t)friends.size());
@ -412,21 +413,21 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
const auto otherName = std::string(otherMember->playerName.c_str()); const auto otherName = std::string(otherMember->playerName.c_str());
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(otherMember->playerID); bitStream.Write(otherMember->playerID);
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
bitStream.Write(otherMember->playerID); bitStream.Write(otherMember->playerID);
bitStream.Write<uint8_t>(8); bitStream.Write<uint8_t>(8);
bitStream.Write<unsigned int>(69); bitStream.Write<unsigned int>(69);
PacketUtils::WritePacketWString(senderName, 33, &bitStream); bitStream.Write(LUWString(senderName));
bitStream.Write(sender->playerID); bitStream.Write(sender->playerID);
bitStream.Write<uint16_t>(0); bitStream.Write<uint16_t>(0);
bitStream.Write<uint8_t>(0); //not mythran nametag bitStream.Write<uint8_t>(0); //not mythran nametag
PacketUtils::WritePacketWString(otherName, 33, &bitStream); bitStream.Write(LUWString(otherName));
bitStream.Write<uint8_t>(0); //not mythran for receiver bitStream.Write<uint8_t>(0); //not mythran for receiver
bitStream.Write<uint8_t>(0); //teams? bitStream.Write<uint8_t>(0); //teams?
PacketUtils::WritePacketWString(message, 512, &bitStream); bitStream.Write(LUWString(message, 512));
SystemAddress sysAddr = otherMember->sysAddr; SystemAddress sysAddr = otherMember->sysAddr;
SEND_PACKET; SEND_PACKET;
@ -434,7 +435,7 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
} }
void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) { void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
LWOOBJID senderID = PacketUtils::ReadPacketS64(0x08, packet); LWOOBJID senderID = PacketUtils::ReadS64(0x08, packet);
std::string receiverName = PacketUtils::ReadString(0x66, packet, true); std::string receiverName = PacketUtils::ReadString(0x66, packet, true);
std::string message = PacketUtils::ReadString(0xAA, packet, true, 512); std::string message = PacketUtils::ReadString(0xAA, packet, true, 512);
@ -451,21 +452,21 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
//To the sender: //To the sender:
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(goonA->playerID); bitStream.Write(goonA->playerID);
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
bitStream.Write(goonA->playerID); bitStream.Write(goonA->playerID);
bitStream.Write<uint8_t>(7); bitStream.Write<uint8_t>(7);
bitStream.Write<unsigned int>(69); bitStream.Write<unsigned int>(69);
PacketUtils::WritePacketWString(goonAName, 33, &bitStream); bitStream.Write(LUWString(goonAName));
bitStream.Write(goonA->playerID); bitStream.Write(goonA->playerID);
bitStream.Write<uint16_t>(0); bitStream.Write<uint16_t>(0);
bitStream.Write<uint8_t>(0); //not mythran nametag bitStream.Write<uint8_t>(0); //not mythran nametag
PacketUtils::WritePacketWString(goonBName, 33, &bitStream); bitStream.Write(LUWString(goonBName));
bitStream.Write<uint8_t>(0); //not mythran for receiver bitStream.Write<uint8_t>(0); //not mythran for receiver
bitStream.Write<uint8_t>(0); //success bitStream.Write<uint8_t>(0); //success
PacketUtils::WritePacketWString(message, 512, &bitStream); bitStream.Write(LUWString(message, 512));
SystemAddress sysAddr = goonA->sysAddr; SystemAddress sysAddr = goonA->sysAddr;
SEND_PACKET; SEND_PACKET;
@ -474,21 +475,21 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
//To the receiver: //To the receiver:
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(goonB->playerID); bitStream.Write(goonB->playerID);
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
bitStream.Write(goonA->playerID); bitStream.Write(goonA->playerID);
bitStream.Write<uint8_t>(7); bitStream.Write<uint8_t>(7);
bitStream.Write<unsigned int>(69); bitStream.Write<unsigned int>(69);
PacketUtils::WritePacketWString(goonAName, 33, &bitStream); bitStream.Write(LUWString(goonAName));
bitStream.Write(goonA->playerID); bitStream.Write(goonA->playerID);
bitStream.Write<uint16_t>(0); bitStream.Write<uint16_t>(0);
bitStream.Write<uint8_t>(0); //not mythran nametag bitStream.Write<uint8_t>(0); //not mythran nametag
PacketUtils::WritePacketWString(goonBName, 33, &bitStream); bitStream.Write(LUWString(goonBName));
bitStream.Write<uint8_t>(0); //not mythran for receiver bitStream.Write<uint8_t>(0); //not mythran for receiver
bitStream.Write<uint8_t>(3); //new whisper bitStream.Write<uint8_t>(3); //new whisper
PacketUtils::WritePacketWString(message, 512, &bitStream); bitStream.Write(LUWString(message, 512));
SystemAddress sysAddr = goonB->sysAddr; SystemAddress sysAddr = goonB->sysAddr;
SEND_PACKET; SEND_PACKET;
@ -709,13 +710,13 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) { void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream); bitStream.Write(LUWString(sender->playerName.c_str()));
bitStream.Write(sender->playerID); bitStream.Write(sender->playerID);
SystemAddress sysAddr = receiver->sysAddr; SystemAddress sysAddr = receiver->sysAddr;
@ -724,7 +725,7 @@ void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender)
void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) { void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -751,7 +752,7 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader
void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) { void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -776,7 +777,7 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) { void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -793,7 +794,7 @@ void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64Play
void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) { void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -822,7 +823,7 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria
void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) { void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -848,7 +849,7 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) { void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
@ -882,16 +883,16 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
[bool] - is FTP*/ [bool] - is FTP*/
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(friendData->playerID); bitStream.Write(friendData->playerID);
//portion that will get routed: //portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
bitStream.Write<uint8_t>(notifyType); bitStream.Write<uint8_t>(notifyType);
std::string playerName = playerData->playerName.c_str(); std::string playerName = playerData->playerName.c_str();
PacketUtils::WritePacketWString(playerName, 33, &bitStream); bitStream.Write(LUWString(playerName));
bitStream.Write(playerData->zoneID.GetMapID()); bitStream.Write(playerData->zoneID.GetMapID());
bitStream.Write(playerData->zoneID.GetInstanceID()); bitStream.Write(playerData->zoneID.GetInstanceID());
@ -921,12 +922,12 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
} }
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream); bitStream.Write(LUWString(sender->playerName.c_str()));
bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side. bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
SystemAddress sysAddr = receiver->sysAddr; SystemAddress sysAddr = receiver->sysAddr;
@ -937,16 +938,16 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen
if (!receiver || !sender) return; if (!receiver || !sender) return;
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
// Portion that will get routed: // Portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
bitStream.Write(responseCode); bitStream.Write(responseCode);
// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver. // For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS); bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
// Then write the player name // Then write the player name
PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream); bitStream.Write(LUWString(sender->playerName.c_str()));
// Then if this is an acceptance code, write the following extra info. // Then if this is an acceptance code, write the following extra info.
if (responseCode == eAddFriendResponseType::ACCEPTED) { if (responseCode == eAddFriendResponseType::ACCEPTED) {
bitStream.Write(sender->playerID); bitStream.Write(sender->playerID);
@ -962,13 +963,13 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
if (!receiver) return; if (!receiver) return;
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
bitStream.Write(receiver->playerID); bitStream.Write(receiver->playerID);
//portion that will get routed: //portion that will get routed:
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
bitStream.Write<uint8_t>(isSuccessful); //isOnline bitStream.Write<uint8_t>(isSuccessful); //isOnline
PacketUtils::WritePacketWString(personToRemove, 33, &bitStream); bitStream.Write(LUWString(personToRemove));
SystemAddress sysAddr = receiver->sysAddr; SystemAddress sysAddr = receiver->sysAddr;
SEND_PACKET; SEND_PACKET;

6
dChatServer/PlayerContainer.cpp
View File

@ -6,7 +6,7 @@
#include "dLogger.h" #include "dLogger.h"
#include "ChatPacketHandler.h" #include "ChatPacketHandler.h"
#include "GeneralUtils.h" #include "GeneralUtils.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "Database.h" #include "Database.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eChatInternalMessageType.h" #include "eChatInternalMessageType.h"
@ -147,7 +147,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) { void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
bitStream.Write(player); bitStream.Write(player);
bitStream.Write(time); bitStream.Write(time);
@ -354,7 +354,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) { void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
bitStream.Write(team->teamID); bitStream.Write(team->teamID);
bitStream.Write(deleteTeam); bitStream.Write(deleteTeam);

3
dCommon/dEnums/dCommonVars.h
View File

@ -9,6 +9,7 @@
#include "BitStream.h" #include "BitStream.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eClientMessageType.h" #include "eClientMessageType.h"
#include "BitStreamUtils.h"
#pragma warning (disable:4251) //Disables SQL warnings #pragma warning (disable:4251) //Disables SQL warnings
@ -32,7 +33,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
#define CBITSTREAM RakNet::BitStream bitStream; #define CBITSTREAM RakNet::BitStream bitStream;
#define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false); #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
#define CINSTREAM_SKIP_HEADER CINSTREAM if (inStream.GetNumberOfUnreadBits() >= BYTES_TO_BITS(HEADER_SIZE)) inStream.IgnoreBytes(HEADER_SIZE); else inStream.IgnoreBits(inStream.GetNumberOfUnreadBits()); #define CINSTREAM_SKIP_HEADER CINSTREAM if (inStream.GetNumberOfUnreadBits() >= BYTES_TO_BITS(HEADER_SIZE)) inStream.IgnoreBytes(HEADER_SIZE); else inStream.IgnoreBits(inStream.GetNumberOfUnreadBits());
#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); #define CMSGHEADER BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
#define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false); #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
#define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true); #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);

33
dGame/UserManager.cpp
View File

@ -28,6 +28,7 @@
#include "eRenameResponse.h" #include "eRenameResponse.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eChatInternalMessageType.h" #include "eChatInternalMessageType.h"
#include "BitStreamUtils.h"
UserManager* UserManager::m_Address = nullptr; UserManager* UserManager::m_Address = nullptr;
@ -251,21 +252,21 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
std::string name = PacketUtils::ReadString(8, packet, true); std::string name = PacketUtils::ReadString(8, packet, true);
uint32_t firstNameIndex = PacketUtils::ReadPacketU32(74, packet); uint32_t firstNameIndex = PacketUtils::ReadU32(74, packet);
uint32_t middleNameIndex = PacketUtils::ReadPacketU32(78, packet); uint32_t middleNameIndex = PacketUtils::ReadU32(78, packet);
uint32_t lastNameIndex = PacketUtils::ReadPacketU32(82, packet); uint32_t lastNameIndex = PacketUtils::ReadU32(82, packet);
std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex); std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex);
uint32_t shirtColor = PacketUtils::ReadPacketU32(95, packet); uint32_t shirtColor = PacketUtils::ReadU32(95, packet);
uint32_t shirtStyle = PacketUtils::ReadPacketU32(99, packet); uint32_t shirtStyle = PacketUtils::ReadU32(99, packet);
uint32_t pantsColor = PacketUtils::ReadPacketU32(103, packet); uint32_t pantsColor = PacketUtils::ReadU32(103, packet);
uint32_t hairStyle = PacketUtils::ReadPacketU32(107, packet); uint32_t hairStyle = PacketUtils::ReadU32(107, packet);
uint32_t hairColor = PacketUtils::ReadPacketU32(111, packet); uint32_t hairColor = PacketUtils::ReadU32(111, packet);
uint32_t lh = PacketUtils::ReadPacketU32(115, packet); uint32_t lh = PacketUtils::ReadU32(115, packet);
uint32_t rh = PacketUtils::ReadPacketU32(119, packet); uint32_t rh = PacketUtils::ReadU32(119, packet);
uint32_t eyebrows = PacketUtils::ReadPacketU32(123, packet); uint32_t eyebrows = PacketUtils::ReadU32(123, packet);
uint32_t eyes = PacketUtils::ReadPacketU32(127, packet); uint32_t eyes = PacketUtils::ReadU32(127, packet);
uint32_t mouth = PacketUtils::ReadPacketU32(131, packet); uint32_t mouth = PacketUtils::ReadU32(131, packet);
LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle); LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
LOT pantsLOT = FindCharPantsID(pantsColor); LOT pantsLOT = FindCharPantsID(pantsColor);
@ -387,7 +388,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
return; return;
} }
LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet); LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
uint32_t charID = static_cast<uint32_t>(objectID); uint32_t charID = static_cast<uint32_t>(objectID);
Game::logger->Log("UserManager", "Received char delete req for ID: %llu (%u)", objectID, charID); Game::logger->Log("UserManager", "Received char delete req for ID: %llu (%u)", objectID, charID);
@ -423,7 +424,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
stmt->execute(); stmt->execute();
delete stmt; delete stmt;
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
bitStream.Write(objectID); bitStream.Write(objectID);
Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
} }
@ -483,7 +484,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
return; return;
} }
LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet); LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER); GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT); GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);

4
dGame/dBehaviors/BehaviorContext.cpp
View File

@ -6,7 +6,7 @@
#include "Game.h" #include "Game.h"
#include "dLogger.h" #include "dLogger.h"
#include "dServer.h" #include "dServer.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include <sstream> #include <sstream>
@ -253,7 +253,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
// Write message // Write message
RakNet::BitStream message; RakNet::BitStream message;
PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
message.Write(this->originator); message.Write(this->originator);
echo.Serialize(&message); echo.Serialize(&message);

4
dGame/dComponents/RocketLaunchpadControlComponent.cpp
View File

@ -15,7 +15,7 @@
#include "PropertyEntranceComponent.h" #include "PropertyEntranceComponent.h"
#include "MultiZoneEntranceComponent.h" #include "MultiZoneEntranceComponent.h"
#include "dServer.h" #include "dServer.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "eObjectWorldState.h" #include "eObjectWorldState.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
@ -137,7 +137,7 @@ LWOCLONEID RocketLaunchpadControlComponent::GetSelectedCloneId(LWOOBJID player)
void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) { void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE);
bitStream.Write(zoneID); bitStream.Write(zoneID);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
} }

4
dGame/dComponents/ScriptedActivityComponent.cpp
View File

@ -11,7 +11,7 @@
#include "EntityManager.h" #include "EntityManager.h"
#include "ChatPackets.h" #include "ChatPackets.h"
#include "Player.h" #include "Player.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "dServer.h" #include "dServer.h"
#include "GeneralUtils.h" #include "GeneralUtils.h"
#include "dZoneManager.h" #include "dZoneManager.h"
@ -516,7 +516,7 @@ void ActivityInstance::StartZone() {
// only make a team if we have more than one participant // only make a team if we have more than one participant
if (participants.size() > 1) { if (participants.size() > 1) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::CREATE_TEAM); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::CREATE_TEAM);
bitStream.Write(leader->GetObjectID()); bitStream.Write(leader->GetObjectID());
bitStream.Write(m_Participants.size()); bitStream.Write(m_Participants.size());

6
dGame/dComponents/SkillComponent.cpp
View File

@ -15,7 +15,7 @@
#include "dServer.h" #include "dServer.h"
#include "EntityManager.h" #include "EntityManager.h"
#include "Game.h" #include "Game.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "BaseCombatAIComponent.h" #include "BaseCombatAIComponent.h"
#include "ScriptComponent.h" #include "ScriptComponent.h"
#include "BuffComponent.h" #include "BuffComponent.h"
@ -304,7 +304,7 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
// Write message // Write message
RakNet::BitStream message; RakNet::BitStream message;
PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
message.Write(this->m_Parent->GetObjectID()); message.Write(this->m_Parent->GetObjectID());
start.Serialize(&message); start.Serialize(&message);
@ -437,7 +437,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
RakNet::BitStream message; RakNet::BitStream message;
PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
message.Write(this->m_Parent->GetObjectID()); message.Write(this->m_Parent->GetObjectID());
projectileImpact.Serialize(&message); projectileImpact.Serialize(&message);

6
dGame/dGameMessages/GameMessageHandler.cpp
View File

@ -5,7 +5,7 @@
#include "GameMessageHandler.h" #include "GameMessageHandler.h"
#include "MissionComponent.h" #include "MissionComponent.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "dServer.h" #include "dServer.h"
#include "../thirdparty/raknet/Source/RakNetworkFactory.h" #include "../thirdparty/raknet/Source/RakNetworkFactory.h"
#include <future> #include <future>
@ -315,7 +315,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
if (success) { if (success) {
//Broadcast our startSkill: //Broadcast our startSkill:
RakNet::BitStream bitStreamLocal; RakNet::BitStream bitStreamLocal;
PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
bitStreamLocal.Write(entity->GetObjectID()); bitStreamLocal.Write(entity->GetObjectID());
EchoStartSkill echoStartSkill; EchoStartSkill echoStartSkill;
@ -337,7 +337,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
case eGameMessageType::SYNC_SKILL: { case eGameMessageType::SYNC_SKILL: {
RakNet::BitStream bitStreamLocal; RakNet::BitStream bitStreamLocal;
PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG); BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
bitStreamLocal.Write(entity->GetObjectID()); bitStreamLocal.Write(entity->GetObjectID());
//bitStreamLocal.Write((unsigned short)eGameMessageType::ECHO_SYNC_SKILL); //bitStreamLocal.Write((unsigned short)eGameMessageType::ECHO_SYNC_SKILL);
//bitStreamLocal.Write(inStream); //bitStreamLocal.Write(inStream);

16
dGame/dGameMessages/GameMessages.cpp
View File

@ -2,6 +2,7 @@
#include "User.h" #include "User.h"
#include "Entity.h" #include "Entity.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "BitStream.h" #include "BitStream.h"
#include "Game.h" #include "Game.h"
#include "SlashCommandHandler.h" #include "SlashCommandHandler.h"
@ -173,7 +174,7 @@ void GameMessages::SendPlayAnimation(Entity* entity, const std::u16string& anima
bitStream.Write(eGameMessageType::PLAY_ANIMATION); bitStream.Write(eGameMessageType::PLAY_ANIMATION);
bitStream.Write(animationIDLength); bitStream.Write(animationIDLength);
PacketUtils::WriteWString(bitStream, animationName, animationIDLength); bitStream.Write(LUWString(animationName, animationIDLength));
bitStream.Write(bExpectAnimToExist); bitStream.Write(bExpectAnimToExist);
@ -326,13 +327,6 @@ void GameMessages::SendPlayNDAudioEmitter(Entity* entity, const SystemAddress& s
bitStream.Write(static_cast<char>(audioGUID[k])); bitStream.Write(static_cast<char>(audioGUID[k]));
} }
//PacketUtils::WriteString(bitStream, audioGUID, audioGUID.size());
//bitStream.Write(uint32_t(audioGUID.size()));
//for (char character : audioGUID) {
// bitStream.Write(character);
//}
bitStream.Write(uint32_t(0)); bitStream.Write(uint32_t(0));
bitStream.Write0(); bitStream.Write0();
bitStream.Write0(); bitStream.Write0();
@ -2181,7 +2175,7 @@ void GameMessages::HandleUnUseModel(RakNet::BitStream* inStream, Entity* entity,
if (unknown) { if (unknown) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE);
bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes
bitStream.Write(eBlueprintSaveResponseType::PlacementFailed); // Sending a non-zero error code here prevents the client from deleting its in progress build for some reason? bitStream.Write(eBlueprintSaveResponseType::PlacementFailed); // Sending a non-zero error code here prevents the client from deleting its in progress build for some reason?
bitStream.Write<uint32_t>(0); bitStream.Write<uint32_t>(0);
@ -2433,7 +2427,7 @@ void GameMessages::HandleBBBLoadItemRequest(RakNet::BitStream* inStream, Entity*
void GameMessages::SendBlueprintLoadItemResponse(const SystemAddress& sysAddr, bool success, LWOOBJID oldItemId, LWOOBJID newItemId) { void GameMessages::SendBlueprintLoadItemResponse(const SystemAddress& sysAddr, bool success, LWOOBJID oldItemId, LWOOBJID newItemId) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_LOAD_RESPONSE_ITEMID); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_LOAD_RESPONSE_ITEMID);
bitStream.Write(static_cast<uint8_t>(success)); bitStream.Write(static_cast<uint8_t>(success));
bitStream.Write<LWOOBJID>(oldItemId); bitStream.Write<LWOOBJID>(oldItemId);
bitStream.Write<LWOOBJID>(newItemId); bitStream.Write<LWOOBJID>(newItemId);
@ -2681,7 +2675,7 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream* inStream, Entity* ent
//Tell the client their model is saved: (this causes us to actually pop out of our current state): //Tell the client their model is saved: (this causes us to actually pop out of our current state):
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE);
bitStream.Write(localId); bitStream.Write(localId);
bitStream.Write(eBlueprintSaveResponseType::EverythingWorked); bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
bitStream.Write<uint32_t>(1); bitStream.Write<uint32_t>(1);

13
dGame/dUtilities/Mail.cpp
View File

@ -13,6 +13,7 @@
#include "Entity.h" #include "Entity.h"
#include "Character.h" #include "Character.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "dLogger.h" #include "dLogger.h"
#include "EntityManager.h" #include "EntityManager.h"
#include "InventoryComponent.h" #include "InventoryComponent.h"
@ -283,7 +284,7 @@ void Mail::HandleDataRequest(RakNet::BitStream* packet, const SystemAddress& sys
sql::ResultSet* res = stmt->executeQuery(); sql::ResultSet* res = stmt->executeQuery();
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
bitStream.Write(int(MailMessageID::MailData)); bitStream.Write(int(MailMessageID::MailData));
bitStream.Write(int(0)); bitStream.Write(int(0));
@ -406,7 +407,7 @@ void Mail::HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t obje
void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) { void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
bitStream.Write(int(MailMessageID::SendResponse)); bitStream.Write(int(MailMessageID::SendResponse));
bitStream.Write(int(response)); bitStream.Write(int(response));
Game::server->Send(&bitStream, sysAddr, false); Game::server->Send(&bitStream, sysAddr, false);
@ -414,7 +415,7 @@ void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse respo
void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) { void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
uint64_t messageType = 2; uint64_t messageType = 2;
uint64_t s1 = 0; uint64_t s1 = 0;
uint64_t s2 = 0; uint64_t s2 = 0;
@ -433,7 +434,7 @@ void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) { void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
bitStream.Write(int(MailMessageID::AttachmentCollectConfirm)); bitStream.Write(int(MailMessageID::AttachmentCollectConfirm));
bitStream.Write(int(0)); //unknown bitStream.Write(int(0)); //unknown
bitStream.Write(mailID); bitStream.Write(mailID);
@ -442,7 +443,7 @@ void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t ma
void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) { void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
bitStream.Write(int(MailMessageID::MailDeleteConfirm)); bitStream.Write(int(MailMessageID::MailDeleteConfirm));
bitStream.Write(int(0)); //unknown bitStream.Write(int(0)); //unknown
bitStream.Write(mailID); bitStream.Write(mailID);
@ -456,7 +457,7 @@ void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOO
void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) { void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
bitStream.Write(int(MailMessageID::MailReadConfirm)); bitStream.Write(int(MailMessageID::MailReadConfirm));
bitStream.Write(int(0)); //unknown bitStream.Write(int(0)); //unknown
bitStream.Write(mailID); bitStream.Write(mailID);

8
dGame/dUtilities/SlashCommandHandler.cpp
View File

@ -49,7 +49,7 @@
#include "dpWorld.h" #include "dpWorld.h"
#include "Item.h" #include "Item.h"
#include "PropertyManagementComponent.h" #include "PropertyManagementComponent.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "Loot.h" #include "Loot.h"
#include "EntityInfo.h" #include "EntityInfo.h"
#include "LUTriggers.h" #include "LUTriggers.h"
@ -761,7 +761,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
if (chatCommand == "shutdownuniverse" && entity->GetGMLevel() == eGameMasterLevel::OPERATOR) { if (chatCommand == "shutdownuniverse" && entity->GetGMLevel() == eGameMasterLevel::OPERATOR) {
//Tell the master server that we're going to be shutting down whole "universe": //Tell the master server that we're going to be shutting down whole "universe":
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_UNIVERSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_UNIVERSE);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
ChatPackets::SendSystemMessage(sysAddr, u"Sent universe shutdown notification to master."); ChatPackets::SendSystemMessage(sysAddr, u"Sent universe shutdown notification to master.");
@ -1092,7 +1092,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
//Notify chat about it //Notify chat about it
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
bitStream.Write(characterId); bitStream.Write(characterId);
bitStream.Write(expire); bitStream.Write(expire);
@ -2013,7 +2013,7 @@ void SlashCommandHandler::SendAnnouncement(const std::string& title, const std::
//Notify chat about it //Notify chat about it
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ANNOUNCEMENT); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ANNOUNCEMENT);
bitStream.Write<uint32_t>(title.size()); bitStream.Write<uint32_t>(title.size());
for (auto character : title) { for (auto character : title) {

6
dMasterServer/InstanceManager.cpp
View File

@ -8,7 +8,7 @@
#include "CDClientManager.h" #include "CDClientManager.h"
#include "CDZoneTableTable.h" #include "CDZoneTableTable.h"
#include "MasterPackets.h" #include "MasterPackets.h"
#include "PacketUtils.h" #include "BitStreamUtils.h"
#include "BinaryPathFinder.h" #include "BinaryPathFinder.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
@ -202,7 +202,7 @@ void InstanceManager::RequestAffirmation(Instance* instance, const PendingInstan
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_REQUEST); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_REQUEST);
bitStream.Write(request.id); bitStream.Write(request.id);
@ -406,7 +406,7 @@ bool Instance::GetShutdownComplete() const {
void Instance::Shutdown() { void Instance::Shutdown() {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN);
Game::server->Send(&bitStream, this->m_SysAddr, false); Game::server->Send(&bitStream, this->m_SysAddr, false);

9
dMasterServer/MasterServer.cpp
View File

@ -42,6 +42,7 @@
#include "ObjectIDManager.h" #include "ObjectIDManager.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "FdbToSqlite.h" #include "FdbToSqlite.h"
#include "BitStreamUtils.h"
namespace Game { namespace Game {
dLogger* logger = nullptr; dLogger* logger = nullptr;
@ -632,7 +633,7 @@ void HandlePacket(Packet* packet) {
activeSessions.erase(it.first); activeSessions.erase(it.first);
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::NEW_SESSION_ALERT); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::NEW_SESSION_ALERT);
bitStream.Write(sessionKey); bitStream.Write(sessionKey);
bitStream.Write<uint32_t>(username.size()); bitStream.Write<uint32_t>(username.size());
for (auto character : username) { for (auto character : username) {
@ -657,9 +658,9 @@ void HandlePacket(Packet* packet) {
for (auto key : activeSessions) { for (auto key : activeSessions) {
if (key.second == username) { if (key.second == username) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SESSION_KEY_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SESSION_KEY_RESPONSE);
bitStream.Write(key.first); bitStream.Write(key.first);
PacketUtils::WriteString(bitStream, key.second, 64); bitStream.Write(LUString(key.second, 64));
Game::server->Send(&bitStream, packet->systemAddress, false); Game::server->Send(&bitStream, packet->systemAddress, false);
break; break;
} }
@ -903,7 +904,7 @@ void ShutdownSequence(int32_t signal) {
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN);
Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true); Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
Game::logger->Log("MasterServer", "Triggered master shutdown"); Game::logger->Log("MasterServer", "Triggered master shutdown");
} }

54
dNet/AuthPackets.cpp
View File

@ -1,5 +1,6 @@
#include "AuthPackets.h" #include "AuthPackets.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "dNetCommon.h" #include "dNetCommon.h"
#include "dServer.h" #include "dServer.h"
@ -39,7 +40,7 @@ void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType) { void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM); BitStreamUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM);
uint32_t netVersion; uint32_t netVersion;
if (!GeneralUtils::TryParse(Game::config->GetValue("client_net_version"), netVersion)) { if (!GeneralUtils::TryParse(Game::config->GetValue("client_net_version"), netVersion)) {
Game::logger->Log("AuthPackets", "Failed to parse client_net_version. Cannot authenticate to %s:%i", nextServerIP.c_str(), nextServerPort); Game::logger->Log("AuthPackets", "Failed to parse client_net_version. Cannot authenticate to %s:%i", nextServerIP.c_str(), nextServerPort);
@ -197,20 +198,19 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) { void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) {
RakNet::BitStream packet; RakNet::BitStream packet;
PacketUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE); BitStreamUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
packet.Write(static_cast<uint8_t>(responseCode)); packet.Write(static_cast<uint8_t>(responseCode));
PacketUtils::WritePacketString("Talk_Like_A_Pirate", 33, &packet); // Event Gating
packet.Write(LUString("Talk_Like_A_Pirate"));
// 7 unknown strings - perhaps other IP addresses? packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
PacketUtils::WritePacketString("", 33, &packet);
packet.Write(static_cast<uint16_t>(1)); // Version Major packet.Write(static_cast<uint16_t>(1)); // Version Major
packet.Write(static_cast<uint16_t>(10)); // Version Current packet.Write(static_cast<uint16_t>(10)); // Version Current
@ -220,34 +220,34 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>(); uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
std::string userHash = std::to_string(sessionKey); std::string userHash = std::to_string(sessionKey);
userHash = md5(userHash); userHash = md5(userHash);
PacketUtils::WritePacketWString(userHash, 33, &packet); packet.Write(LUWString(userHash));
// Write the Character and Chat IPs // Write the Character and Chat IPs
PacketUtils::WritePacketString(wServerIP, 33, &packet); packet.Write(LUString(wServerIP));
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
// Write the Character and Chat Ports // Write the Character and Chat Ports
packet.Write(static_cast<uint16_t>(wServerPort)); packet.Write(static_cast<uint16_t>(wServerPort));
packet.Write(static_cast<uint16_t>(0)); packet.Write(static_cast<uint16_t>(0));
// Write another IP // CDN Key
PacketUtils::WritePacketString("", 33, &packet); packet.Write(LUString(""));
// Write a GUID or something... // CDN Ticket
PacketUtils::WritePacketString("00000000-0000-0000-0000-000000000000", 37, &packet); packet.Write(LUString("00000000-0000-0000-0000-000000000000", 37));
packet.Write(static_cast<uint32_t>(0)); // ??? packet.Write(static_cast<uint32_t>(0)); // Language
// Write the localization // Write the localization
PacketUtils::WritePacketString("US", 3, &packet); packet.Write(LUString("US", 3));
packet.Write(static_cast<uint8_t>(false)); // User first logged in? packet.Write(static_cast<uint8_t>(false)); // Just upgraded from F2P
packet.Write(static_cast<uint8_t>(false)); // User is F2P? packet.Write(static_cast<uint8_t>(false)); // User is F2P
packet.Write(static_cast<uint64_t>(0)); // ??? packet.Write(static_cast<uint64_t>(0)); // Time Remaining in F2P
// Write custom error message // Write custom error message
packet.Write(static_cast<uint16_t>(errorMsg.length())); packet.Write(static_cast<uint16_t>(errorMsg.length()));
PacketUtils::WritePacketWString(errorMsg, static_cast<uint32_t>(errorMsg.length()), &packet); packet.Write(LUWString(errorMsg, static_cast<uint32_t>(errorMsg.length())));
// Here write auth logs // Here write auth logs
packet.Write(static_cast<uint32_t>(20)); packet.Write(static_cast<uint32_t>(20));
@ -263,9 +263,9 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
//Inform the master server that we've created a session for this user: //Inform the master server that we've created a session for this user:
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY);
bitStream.Write(sessionKey); bitStream.Write(sessionKey);
PacketUtils::WriteString(bitStream, username, 66); bitStream.Write(LUString(username, 66));
server->SendToMaster(&bitStream); server->SendToMaster(&bitStream);
server->GetLogger()->Log("AuthPackets", "Set sessionKey: %i for user %s", sessionKey, username.c_str()); server->GetLogger()->Log("AuthPackets", "Set sessionKey: %i for user %s", sessionKey, username.c_str());

104
dNet/BitStreamUtils.h Normal file
View File

@ -0,0 +1,104 @@
#ifndef __BITSTREAMUTILS__H__
#define __BITSTREAMUTILS__H__
#include "GeneralUtils.h"
#include "MessageIdentifiers.h"
#include "BitStream.h"
#include <string>
enum class eConnectionType : uint16_t;
struct LUString {
std::string string;
uint32_t size;
LUString(uint32_t size) {
this->size = size;
};
LUString(std::string string, uint32_t size = 33) {
this->string = string;
this->size = size;
};
std::u16string GetAsU16String() const {
return GeneralUtils::ASCIIToUTF16(this->string);
};
};
struct LUWString {
std::u16string string;
uint32_t size;
LUWString(uint32_t size) {
this->size = size;
};
LUWString(std::u16string string, uint32_t size = 33) {
this->string = string;
this->size = size;
};
LUWString(std::string string, uint32_t size = 33) {
this->string = GeneralUtils::ASCIIToUTF16(string);
this->size = size;
};
std::string GetAsString() const {
return GeneralUtils::UTF16ToWTF8(this->string);
};
};
namespace BitStreamUtils {
template<typename T>
void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) {
bitStream.Write<uint8_t>(MessageID(ID_USER_PACKET_ENUM));
bitStream.Write<eConnectionType>(connectionType);
bitStream.Write<uint32_t>(static_cast<uint32_t>(internalPacketID));
bitStream.Write<uint8_t>(0);
}
}
namespace RakNet {
#ifndef __BITSTREAM_NATIVE_END
#error No definition for big endian reading of LUString
#endif
template <>
inline bool RakNet::BitStream::Read<LUString>(LUString& value) {
value.string.resize(value.size);
bool res = ReadBits(reinterpret_cast<unsigned char*>(value.string.data()), BYTES_TO_BITS(value.string.size()), true);
if (!res) return false;
value.string.erase(std::find(value.string.begin(), value.string.end(), '\0'), value.string.end());
return res;
}
template <>
inline bool RakNet::BitStream::Read<LUWString>(LUWString& value) {
value.string.resize(value.size);
bool res = ReadBits(reinterpret_cast<unsigned char*>(value.string.data()), BYTES_TO_BITS(value.string.size()) * sizeof(std::u16string::value_type), true);
if (!res) return false;
value.string.erase(std::find(value.string.begin(), value.string.end(), u'\0'), value.string.end());
return res;
}
template <>
inline void RakNet::BitStream::Write<std::string>(std::string value) {
this->WriteBits(reinterpret_cast<const unsigned char*>(value.data()), BYTES_TO_BITS(value.size()));
}
template <>
inline void RakNet::BitStream::Write<std::u16string>(std::u16string value) {
this->WriteBits(reinterpret_cast<const unsigned char*>(value.data()), BYTES_TO_BITS(value.size()) * sizeof(std::u16string::value_type));
}
template <>
inline void RakNet::BitStream::Write<LUString>(LUString value) {
value.string.resize(value.size);
this->Write(value.string);
}
template <>
inline void RakNet::BitStream::Write<LUWString>(LUWString value) {
value.string.resize(value.size);
this->Write(value.string);
}
};
#endif //!__BITSTREAMUTILS__H__

11
dNet/ChatPackets.cpp
View File

@ -8,19 +8,20 @@
#include "BitStream.h" #include "BitStream.h"
#include "Game.h" #include "Game.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "dServer.h" #include "dServer.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eChatMessageType.h" #include "eChatMessageType.h"
void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) { void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
bitStream.Write(static_cast<uint64_t>(0)); bitStream.Write(static_cast<uint64_t>(0));
bitStream.Write(chatChannel); bitStream.Write(chatChannel);
bitStream.Write(static_cast<uint32_t>(message.size())); bitStream.Write(static_cast<uint32_t>(message.size()));
PacketUtils::WriteWString(bitStream, senderName, 33); bitStream.Write(LUWString(senderName));
bitStream.Write(playerObjectID); bitStream.Write(playerObjectID);
bitStream.Write(static_cast<uint16_t>(0)); bitStream.Write(static_cast<uint16_t>(0));
@ -36,13 +37,13 @@ void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel
void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) { void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
bitStream.Write(static_cast<uint64_t>(0)); bitStream.Write(static_cast<uint64_t>(0));
bitStream.Write(static_cast<char>(4)); bitStream.Write(static_cast<char>(4));
bitStream.Write(static_cast<uint32_t>(message.size())); bitStream.Write(static_cast<uint32_t>(message.size()));
PacketUtils::WriteWString(bitStream, "", 33); bitStream.Write(LUWString("", 33));
bitStream.Write(static_cast<uint64_t>(0)); bitStream.Write(static_cast<uint64_t>(0));
bitStream.Write(static_cast<uint16_t>(0)); bitStream.Write(static_cast<uint16_t>(0));
@ -68,7 +69,7 @@ void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) {
//0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players." //0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players."
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SEND_CANNED_TEXT); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SEND_CANNED_TEXT);
bitStream.Write<uint8_t>(0); //response type, options above ^ bitStream.Write<uint8_t>(0); //response type, options above ^
//docs say there's a wstring here-- no idea what it's for, or if it's even needed so leaving it as is for now. //docs say there's a wstring here-- no idea what it's for, or if it's even needed so leaving it as is for now.
SEND_PACKET; SEND_PACKET;

21
dNet/MasterPackets.cpp
View File

@ -5,19 +5,20 @@
#include "dServer.h" #include "dServer.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
#include "BitStreamUtils.h"
#include <string> #include <string>
void MasterPackets::SendPersistentIDRequest(dServer* server, uint64_t requestID) { void MasterPackets::SendPersistentIDRequest(dServer* server, uint64_t requestID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID);
bitStream.Write(requestID); bitStream.Write(requestID);
server->SendToMaster(&bitStream); server->SendToMaster(&bitStream);
} }
void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, uint32_t objID) { void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, uint32_t objID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE);
bitStream.Write(requestID); bitStream.Write(requestID);
bitStream.Write(objID); bitStream.Write(objID);
@ -27,7 +28,7 @@ void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddres
void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t cloneID) { void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t cloneID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER);
bitStream.Write(requestID); bitStream.Write(requestID);
bitStream.Write(static_cast<uint8_t>(mythranShift)); bitStream.Write(static_cast<uint8_t>(mythranShift));
@ -39,7 +40,7 @@ void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID,
void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint32_t cloneID, const std::string& password) { void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint32_t cloneID, const std::string& password) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE);
bitStream.Write(zoneID); bitStream.Write(zoneID);
bitStream.Write(cloneID); bitStream.Write(cloneID);
@ -54,7 +55,7 @@ void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint
void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, bool mythranShift, const std::string& password) { void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, bool mythranShift, const std::string& password) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE);
bitStream.Write(requestID); bitStream.Write(requestID);
bitStream.Write(static_cast<uint8_t>(mythranShift)); bitStream.Write(static_cast<uint8_t>(mythranShift));
@ -69,7 +70,7 @@ void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID,
void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCEID instanceId) { void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCEID instanceId) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY);
bitStream.Write(zoneId); bitStream.Write(zoneId);
bitStream.Write(instanceId); bitStream.Write(instanceId);
@ -79,7 +80,7 @@ void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCE
void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, const std::string& serverIP, uint32_t serverPort) { void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, const std::string& serverIP, uint32_t serverPort) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE);
bitStream.Write(requestID); bitStream.Write(requestID);
bitStream.Write(static_cast<uint8_t>(mythranShift)); bitStream.Write(static_cast<uint8_t>(mythranShift));
@ -87,7 +88,7 @@ void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddres
bitStream.Write(zoneInstance); bitStream.Write(zoneInstance);
bitStream.Write(zoneClone); bitStream.Write(zoneClone);
bitStream.Write(static_cast<uint16_t>(serverPort)); bitStream.Write(static_cast<uint16_t>(serverPort));
PacketUtils::WriteString(bitStream, serverIP, static_cast<uint32_t>(serverIP.size() + 1)); bitStream.Write(LUString(serverIP, static_cast<uint32_t>(serverIP.size() + 1)));
server->Send(&bitStream, sysAddr, false); server->Send(&bitStream, sysAddr, false);
} }
@ -111,13 +112,13 @@ void MasterPackets::HandleServerInfo(Packet* packet) {
void MasterPackets::SendServerInfo(dServer* server, Packet* packet) { void MasterPackets::SendServerInfo(dServer* server, Packet* packet) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO);
bitStream.Write(server->GetPort()); bitStream.Write(server->GetPort());
bitStream.Write(server->GetZoneID()); bitStream.Write(server->GetZoneID());
bitStream.Write(server->GetInstanceID()); bitStream.Write(server->GetInstanceID());
bitStream.Write(server->GetServerType()); bitStream.Write(server->GetServerType());
PacketUtils::WriteString(bitStream, server->GetIP(), server->GetIP().size()); bitStream.Write(LUString(server->GetIP(), server->GetIP().size()));
server->SendToMaster(&bitStream); server->SendToMaster(&bitStream);
} }

83
dNet/PacketUtils.cpp
View File

@ -4,7 +4,7 @@
#include "dLogger.h" #include "dLogger.h"
#include "Game.h" #include "Game.h"
uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) { uint16_t PacketUtils::ReadU16(uint32_t startLoc, Packet* packet) {
if (startLoc + 2 > packet->length) return 0; if (startLoc + 2 > packet->length) return 0;
std::vector<unsigned char> t; std::vector<unsigned char> t;
@ -12,7 +12,7 @@ uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) {
return *(uint16_t*)t.data(); return *(uint16_t*)t.data();
} }
uint32_t PacketUtils::ReadPacketU32(uint32_t startLoc, Packet* packet) { uint32_t PacketUtils::ReadU32(uint32_t startLoc, Packet* packet) {
if (startLoc + 4 > packet->length) return 0; if (startLoc + 4 > packet->length) return 0;
std::vector<unsigned char> t; std::vector<unsigned char> t;
@ -22,7 +22,7 @@ uint32_t PacketUtils::ReadPacketU32(uint32_t startLoc, Packet* packet) {
return *(uint32_t*)t.data(); return *(uint32_t*)t.data();
} }
uint64_t PacketUtils::ReadPacketU64(uint32_t startLoc, Packet* packet) { uint64_t PacketUtils::ReadU64(uint32_t startLoc, Packet* packet) {
if (startLoc + 8 > packet->length) return 0; if (startLoc + 8 > packet->length) return 0;
std::vector<unsigned char> t; std::vector<unsigned char> t;
@ -30,7 +30,7 @@ uint64_t PacketUtils::ReadPacketU64(uint32_t startLoc, Packet* packet) {
return *(uint64_t*)t.data(); return *(uint64_t*)t.data();
} }
int64_t PacketUtils::ReadPacketS64(uint32_t startLoc, Packet* packet) { int64_t PacketUtils::ReadS64(uint32_t startLoc, Packet* packet) {
if (startLoc + 8 > packet->length) return 0; if (startLoc + 8 > packet->length) return 0;
std::vector<unsigned char> t; std::vector<unsigned char> t;
@ -59,81 +59,6 @@ std::string PacketUtils::ReadString(uint32_t startLoc, Packet* packet, bool wide
return readString; return readString;
} }
void PacketUtils::WritePacketString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream) {
uint32_t size = static_cast<uint32_t>(string.size());
uint32_t remSize = static_cast<uint32_t>(maxSize - size);
if (size > maxSize) size = maxSize;
for (uint32_t i = 0; i < size; ++i) {
bitStream->Write(static_cast<char>(string[i]));
}
for (uint32_t j = 0; j < remSize; ++j) {
bitStream->Write(static_cast<char>(0));
}
}
void PacketUtils::WriteString(RakNet::BitStream& bitStream, const std::string& s, uint32_t maxSize) {
uint32_t size = s.size();
uint32_t emptySize = maxSize - size;
if (size > maxSize) size = maxSize;
for (uint32_t i = 0; i < size; i++) {
bitStream.Write((char)s[i]);
}
for (uint32_t i = 0; i < emptySize; i++) {
bitStream.Write((char)0);
}
}
void PacketUtils::WriteWString(RakNet::BitStream& bitStream, const std::string& string, uint32_t maxSize) {
uint32_t size = static_cast<uint32_t>(string.length());
uint32_t remSize = static_cast<uint32_t>(maxSize - size);
if (size > maxSize) size = maxSize;
for (uint32_t i = 0; i < size; ++i) {
bitStream.Write(static_cast<uint16_t>(string[i]));
}
for (uint32_t j = 0; j < remSize; ++j) {
bitStream.Write(static_cast<uint16_t>(0));
}
}
void PacketUtils::WriteWString(RakNet::BitStream& bitStream, const std::u16string& string, uint32_t maxSize) {
uint32_t size = static_cast<uint32_t>(string.length());
uint32_t remSize = static_cast<uint32_t>(maxSize - size);
if (size > maxSize) size = maxSize;
for (uint32_t i = 0; i < size; ++i) {
bitStream.Write(static_cast<uint16_t>(string[i]));
}
for (uint32_t j = 0; j < remSize; ++j) {
bitStream.Write(static_cast<uint16_t>(0));
}
}
void PacketUtils::WritePacketWString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream) {
uint32_t size = static_cast<uint32_t>(string.length());
uint32_t remSize = static_cast<uint32_t>(maxSize - size);
if (size > maxSize) size = maxSize;
for (uint32_t i = 0; i < size; ++i) {
bitStream->Write(static_cast<uint16_t>(string[i]));
}
for (uint32_t j = 0; j < remSize; ++j) {
bitStream->Write(static_cast<uint16_t>(0));
}
}
//! Saves a packet to the filesystem //! Saves a packet to the filesystem
void PacketUtils::SavePacket(const std::string& filename, const char* data, size_t length) { void PacketUtils::SavePacket(const std::string& filename, const char* data, size_t length) {
//If we don't log to the console, don't save the bin files either. This takes up a lot of time. //If we don't log to the console, don't save the bin files either. This takes up a lot of time.

23
dNet/PacketUtils.h
View File

@ -8,26 +8,11 @@
enum class eConnectionType : uint16_t; enum class eConnectionType : uint16_t;
namespace PacketUtils { namespace PacketUtils {
template<typename T> uint16_t ReadU16(uint32_t startLoc, Packet* packet);
void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) { uint32_t ReadU32(uint32_t startLoc, Packet* packet);
bitStream.Write<uint8_t>(MessageID(ID_USER_PACKET_ENUM)); uint64_t ReadU64(uint32_t startLoc, Packet* packet);
bitStream.Write<eConnectionType>(connectionType); int64_t ReadS64(uint32_t startLoc, Packet* packet);
bitStream.Write<uint32_t>(static_cast<uint32_t>(internalPacketID));
bitStream.Write<uint8_t>(0);
}
uint16_t ReadPacketU16(uint32_t startLoc, Packet* packet);
uint32_t ReadPacketU32(uint32_t startLoc, Packet* packet);
uint64_t ReadPacketU64(uint32_t startLoc, Packet* packet);
int64_t ReadPacketS64(uint32_t startLoc, Packet* packet);
std::string ReadString(uint32_t startLoc, Packet* packet, bool wide, uint32_t maxLen = 33); std::string ReadString(uint32_t startLoc, Packet* packet, bool wide, uint32_t maxLen = 33);
void WritePacketString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream);
void WriteString(RakNet::BitStream& bitStream, const std::string& s, uint32_t maxSize);
void WriteWString(RakNet::BitStream& bitStream, const std::string& string, uint32_t maxSize);
void WriteWString(RakNet::BitStream& bitStream, const std::u16string& string, uint32_t maxSize);
void WritePacketWString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream);
void SavePacket(const std::string& filename, const char* data, size_t length); void SavePacket(const std::string& filename, const char* data, size_t length);
}; };

31
dNet/WorldPackets.cpp
View File

@ -14,10 +14,11 @@
#include "CharacterComponent.h" #include "CharacterComponent.h"
#include "ZCompression.h" #include "ZCompression.h"
#include "eConnectionType.h" #include "eConnectionType.h"
#include "BitStreamUtils.h"
void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) { void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE);
auto zone = Game::zoneManager->GetZone()->GetZoneID(); auto zone = Game::zoneManager->GetZone()->GetZoneID();
bitStream.Write(static_cast<uint16_t>(zone.GetMapID())); bitStream.Write(static_cast<uint16_t>(zone.GetMapID()));
@ -41,7 +42,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
if (!user) return; if (!user) return;
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);
std::vector<Character*> characters = user->GetCharacters(); std::vector<Character*> characters = user->GetCharacters();
bitStream.Write(static_cast<uint8_t>(characters.size())); bitStream.Write(static_cast<uint8_t>(characters.size()));
@ -51,13 +52,13 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
bitStream.Write(characters[i]->GetObjectID()); bitStream.Write(characters[i]->GetObjectID());
bitStream.Write(static_cast<uint32_t>(0)); bitStream.Write(static_cast<uint32_t>(0));
PacketUtils::WriteWString(bitStream, characters[i]->GetName(), 33); bitStream.Write(LUWString(characters[i]->GetName()));
PacketUtils::WriteWString(bitStream, characters[i]->GetUnapprovedName(), 33); bitStream.Write(LUWString(characters[i]->GetUnapprovedName()));
bitStream.Write(static_cast<uint8_t>(characters[i]->GetNameRejected())); bitStream.Write(static_cast<uint8_t>(characters[i]->GetNameRejected()));
bitStream.Write(static_cast<uint8_t>(false)); bitStream.Write(static_cast<uint8_t>(false));
PacketUtils::WriteString(bitStream, "", 10); bitStream.Write(LUString("", 10));
bitStream.Write(characters[i]->GetShirtColor()); bitStream.Write(characters[i]->GetShirtColor());
bitStream.Write(characters[i]->GetShirtStyle()); bitStream.Write(characters[i]->GetShirtStyle());
@ -90,30 +91,30 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) { void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE);
bitStream.Write(response); bitStream.Write(response);
SEND_PACKET; SEND_PACKET;
} }
void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) { void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE);
bitStream.Write(response); bitStream.Write(response);
SEND_PACKET; SEND_PACKET;
} }
void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) { void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE);
bitStream.Write(static_cast<uint8_t>(response)); bitStream.Write(static_cast<uint8_t>(response));
SEND_PACKET; SEND_PACKET;
} }
void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) { void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD);
PacketUtils::WriteString(bitStream, serverIP, 33); bitStream.Write(LUString(serverIP));
bitStream.Write(static_cast<uint16_t>(serverPort)); bitStream.Write(static_cast<uint16_t>(serverPort));
bitStream.Write(static_cast<uint8_t>(mythranShift)); bitStream.Write(static_cast<uint8_t>(mythranShift));
@ -122,14 +123,14 @@ void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::
void WorldPackets::SendServerState(const SystemAddress& sysAddr) { void WorldPackets::SendServerState(const SystemAddress& sysAddr) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES);
bitStream.Write(static_cast<uint8_t>(1)); //If the server is receiving this request, it probably is ready anyway. bitStream.Write(static_cast<uint8_t>(1)); //If the server is receiving this request, it probably is ready anyway.
SEND_PACKET; SEND_PACKET;
} }
void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* entity, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) { void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* entity, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER);
RakNet::BitStream data; RakNet::BitStream data;
data.Write<uint32_t>(7); //LDF key count data.Write<uint32_t>(7); //LDF key count
@ -198,7 +199,7 @@ void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* ent
void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems) { void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING);
bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok? bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
bitStream.Write<uint16_t>(0x16); // Source ID, unknown bitStream.Write<uint16_t>(0x16); // Source ID, unknown
@ -206,7 +207,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool
bitStream.Write(static_cast<uint8_t>(requestID)); // request ID bitStream.Write(static_cast<uint8_t>(requestID)); // request ID
bitStream.Write(static_cast<char>(0)); // chat mode bitStream.Write(static_cast<char>(0)); // chat mode
PacketUtils::WritePacketWString(receiver, 42, &bitStream); // receiver name bitStream.Write(LUWString(receiver, 42)); // receiver name
for (auto it : unacceptedItems) { for (auto it : unacceptedItems) {
bitStream.Write<uint8_t>(it.first); // start index bitStream.Write<uint8_t>(it.first); // start index
@ -222,7 +223,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool
void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) { void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE);
bitStream.Write<uint8_t>(success); bitStream.Write<uint8_t>(success);
bitStream.Write(static_cast<uint16_t>(highestLevel)); bitStream.Write(static_cast<uint16_t>(highestLevel));

8
dNet/ZoneInstanceManager.cpp
View File

@ -28,10 +28,10 @@ void ZoneInstanceManager::RequestZoneTransfer(dServer* server, uint32_t zoneID,
void ZoneInstanceManager::HandleRequestZoneTransferResponse(uint64_t requestID, Packet* packet) { void ZoneInstanceManager::HandleRequestZoneTransferResponse(uint64_t requestID, Packet* packet) {
bool mythranShift = static_cast<bool>(packet->data[16]); bool mythranShift = static_cast<bool>(packet->data[16]);
uint32_t zoneID = PacketUtils::ReadPacketU32(17, packet); uint32_t zoneID = PacketUtils::ReadU32(17, packet);
uint32_t zoneInstance = PacketUtils::ReadPacketU32(21, packet); uint32_t zoneInstance = PacketUtils::ReadU32(21, packet);
uint32_t zoneClone = PacketUtils::ReadPacketU32(25, packet); uint32_t zoneClone = PacketUtils::ReadU32(25, packet);
uint16_t serverPort = PacketUtils::ReadPacketU16(29, packet); uint16_t serverPort = PacketUtils::ReadU16(29, packet);
std::string serverIP = PacketUtils::ReadString(31, packet, false); std::string serverIP = PacketUtils::ReadString(31, packet, false);
for (uint32_t i = 0; i < this->requests.size(); ++i) { for (uint32_t i = 0; i < this->requests.size(); ++i) {

5
dNet/dServer.cpp
View File

@ -11,6 +11,7 @@
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "MasterPackets.h" #include "MasterPackets.h"
#include "ZoneInstanceManager.h" #include "ZoneInstanceManager.h"
@ -123,7 +124,7 @@ Packet* dServer::ReceiveFromMaster() {
if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) { if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
switch (static_cast<eMasterMessageType>(packet->data[3])) { switch (static_cast<eMasterMessageType>(packet->data[3])) {
case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: { case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: {
uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); uint64_t requestID = PacketUtils::ReadU64(8, packet);
ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
break; break;
} }
@ -168,7 +169,7 @@ void dServer::SendToMaster(RakNet::BitStream* bitStream) {
void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) { void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) {
RakNet::BitStream bitStream; RakNet::BitStream bitStream;
PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY); BitStreamUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY);
bitStream.Write(disconNotifyID); bitStream.Write(disconNotifyID);
mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false); mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false);

31
dWorldServer/WorldServer.cpp
View File

@ -29,6 +29,7 @@
#include "AuthPackets.h" #include "AuthPackets.h"
#include "PacketUtils.h" #include "PacketUtils.h"
#include "BitStreamUtils.h"
#include "WorldPackets.h" #include "WorldPackets.h"
#include "UserManager.h" #include "UserManager.h"
#include "CDClientManager.h" #include "CDClientManager.h"
@ -708,7 +709,7 @@ void HandlePacket(Packet* packet) {
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
bitStream.Write(user->GetLoggedInChar()); bitStream.Write(user->GetLoggedInChar());
Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
} }
@ -720,7 +721,7 @@ void HandlePacket(Packet* packet) {
} }
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED);
bitStream.Write((LWOMAPID)Game::server->GetZoneID()); bitStream.Write((LWOMAPID)Game::server->GetZoneID());
bitStream.Write((LWOINSTANCEID)instanceID); bitStream.Write((LWOINSTANCEID)instanceID);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
@ -736,14 +737,14 @@ void HandlePacket(Packet* packet) {
if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) { if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
switch (static_cast<eMasterMessageType>(packet->data[3])) { switch (static_cast<eMasterMessageType>(packet->data[3])) {
case eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE: { case eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE: {
uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); uint64_t requestID = PacketUtils::ReadU64(8, packet);
uint32_t objectID = PacketUtils::ReadPacketU32(16, packet); uint32_t objectID = PacketUtils::ReadU32(16, packet);
ObjectIDManager::Instance()->HandleRequestPersistentIDResponse(requestID, objectID); ObjectIDManager::Instance()->HandleRequestPersistentIDResponse(requestID, objectID);
break; break;
} }
case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: { case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: {
uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); uint64_t requestID = PacketUtils::ReadU64(8, packet);
ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
break; break;
} }
@ -805,7 +806,7 @@ void HandlePacket(Packet* packet) {
//Notify master: //Notify master:
{ {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED);
bitStream.Write((LWOMAPID)Game::server->GetZoneID()); bitStream.Write((LWOMAPID)Game::server->GetZoneID());
bitStream.Write((LWOINSTANCEID)instanceID); bitStream.Write((LWOINSTANCEID)instanceID);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
@ -815,13 +816,13 @@ void HandlePacket(Packet* packet) {
break; break;
} }
case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: { case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: {
const uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); const uint64_t requestID = PacketUtils::ReadU64(8, packet);
Game::logger->Log("MasterServer", "Got affirmation request of transfer %llu", requestID); Game::logger->Log("MasterServer", "Got affirmation request of transfer %llu", requestID);
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_RESPONSE);
bitStream.Write(requestID); bitStream.Write(requestID);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
@ -907,8 +908,8 @@ void HandlePacket(Packet* packet) {
//Request the session info from Master: //Request the session info from Master:
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_SESSION_KEY); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_SESSION_KEY);
PacketUtils::WriteString(bitStream, username, 64); bitStream.Write(LUString(username, 64));
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
//Insert info into our pending list //Insert info into our pending list
@ -981,7 +982,7 @@ void HandlePacket(Packet* packet) {
// This means we swapped characters and we need to remove the previous player from the container. // This means we swapped characters and we need to remove the previous player from the container.
if (static_cast<uint32_t>(lastCharacter) != playerID) { if (static_cast<uint32_t>(lastCharacter) != playerID) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
bitStream.Write(lastCharacter); bitStream.Write(lastCharacter);
Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false); Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
} }
@ -1130,7 +1131,7 @@ void HandlePacket(Packet* packet) {
GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT); GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE);
bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes
bitStream.Write(eBlueprintSaveResponseType::EverythingWorked); bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
bitStream.Write<uint32_t>(1); bitStream.Write<uint32_t>(1);
@ -1171,7 +1172,7 @@ void HandlePacket(Packet* packet) {
//RakNet::RakString playerName(player->GetCharacter()->GetName().c_str()); //RakNet::RakString playerName(player->GetCharacter()->GetName().c_str());
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION);
bitStream.Write(player->GetObjectID()); bitStream.Write(player->GetObjectID());
bitStream.Write<uint32_t>(playerName.size()); bitStream.Write<uint32_t>(playerName.size());
for (size_t i = 0; i < playerName.size(); i++) { for (size_t i = 0; i < playerName.size(); i++) {
@ -1222,7 +1223,7 @@ void HandlePacket(Packet* packet) {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, packet->data[14]); BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, packet->data[14]);
//We need to insert the player's objectID so the chat server can find who originated this request: //We need to insert the player's objectID so the chat server can find who originated this request:
LWOOBJID objectID = 0; LWOOBJID objectID = 0;
@ -1348,6 +1349,6 @@ void FinalizeShutdown() {
void SendShutdownMessageToMaster() { void SendShutdownMessageToMaster() {
CBITSTREAM; CBITSTREAM;
PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_RESPONSE); BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_RESPONSE);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
} }

2
tests/dCommonTests/CMakeLists.txt
View File

@ -5,6 +5,8 @@ set(DCOMMONTEST_SOURCES
"TestLDFFormat.cpp" "TestLDFFormat.cpp"
"TestNiPoint3.cpp" "TestNiPoint3.cpp"
"TestEncoding.cpp" "TestEncoding.cpp"
"TestLUString.cpp"
"TestLUWString.cpp"
"dCommonDependencies.cpp" "dCommonDependencies.cpp"
) )

121
tests/dCommonTests/TestLUString.cpp Normal file
View File

@ -0,0 +1,121 @@
#include <gtest/gtest.h>
#include "dCommonVars.h"
TEST(LUString33Test, SerializeWriteTestOld) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 33; i++) testString += "a";
for (const auto& c : testString) bitStream.Write(c);
std::string result;
char c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeWriteTestOldPartial) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 15; i++) testString += "a";
for (const auto& c : testString) bitStream.Write(c);
for (int i = 0; i < 18; i++) bitStream.Write<char>(0);
std::string result;
char c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeWriteTestNew) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 33; i++) testString += "a";
bitStream.Write(LUString(testString, 33));
std::string result;
char c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeWriteTestNewPartial) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 15; i++) testString += "a";
bitStream.Write(LUString(testString, 33));
std::string result;
char c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeReadTestOld) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 33; i++) testString += "a";
for (const auto& c : testString) bitStream.Write(c);
std::string result;
char c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeReadTestOldPartial) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 15; i++) testString += "a";
for (const auto& c : testString) bitStream.Write(c);
for (int i = 0; i < 18; i++) bitStream.Write<char>(0);
std::string result;
char c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUString33Test, SerializeReadTestNew) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 33; i++) testString += "a";
bitStream.Write(LUString(testString, 33));
LUString result(33);
ASSERT_EQ(result.size, 33);
ASSERT_TRUE(bitStream.Read(result));
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result.string, testString);
}
TEST(LUString33Test, SerializeReadTestNewPartial) {
CBITSTREAM;
std::string testString;
for (int i = 0; i < 15; i++) testString += "a";
bitStream.Write(LUString(testString, 33));
LUString result(33);
ASSERT_EQ(result.size, 33);
ASSERT_TRUE(bitStream.Read(result));
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result.string, testString);
}

121
tests/dCommonTests/TestLUWString.cpp Normal file
View File

@ -0,0 +1,121 @@
#include <gtest/gtest.h>
#include "dCommonVars.h"
TEST(LUWString33Test, SerializeWriteTestOld) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 33; i++) testString += u'ü';
for (const auto& c : testString) bitStream.Write(c);
std::u16string result;
char16_t c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeWriteTestOldPartial) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 15; i++) testString += u'ü';
for (const auto& c : testString) bitStream.Write(c);
for (int i = 0; i < 18; i++) bitStream.Write<char16_t>(0);
std::u16string result;
char16_t c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeWriteTestNew) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 33; i++) testString += u'ü';
bitStream.Write(LUWString(testString, 33));
std::u16string result;
char16_t c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeWriteTestNewPartial) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 15; i++) testString += u'ü';
bitStream.Write(LUWString(testString, 33));
std::u16string result;
char16_t c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeReadTestOld) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 33; i++) testString += u'ü';
for (const auto& c : testString) bitStream.Write(c);
std::u16string result;
char16_t c;
while (bitStream.Read(c)) result += c;
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeReadTestOldPartial) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 15; i++) testString += u'ü';
for (const auto& c : testString) bitStream.Write(c);
for (int i = 0; i < 18; i++) bitStream.Write<char16_t>(0);
std::u16string result;
char16_t c;
int nulls = 18;
while (bitStream.Read(c)){
if (c == 0) {
nulls--;
continue;
}
result += c;
}
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(nulls, 0);
ASSERT_EQ(result, testString);
}
TEST(LUWString33Test, SerializeReadTestNew) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 33; i++) testString += u'ü';
bitStream.Write(LUWString(testString, 33));
LUWString result(33);
ASSERT_EQ(result.size, 33);
ASSERT_TRUE(bitStream.Read(result));
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result.string, testString);
}
TEST(LUWString33Test, SerializeReadTestNewPartial) {
CBITSTREAM;
std::u16string testString;
for (int i = 0; i < 15; i++) testString += u'ü';
bitStream.Write(LUWString(testString, 33));
LUWString result(33);
ASSERT_EQ(result.size, 33);
ASSERT_TRUE(bitStream.Read(result));
ASSERT_EQ(bitStream.GetNumberOfUnreadBits(), 0);
ASSERT_EQ(result.string, testString);
}