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

Make PacketUtils only for packetAdd BitstreamUtils and make better read/writesupdate

Browse Source
This commit is contained in:
Aaron Kimbre 2023-08-04 21:28:07 -05:00
parent c2b4aa4026
commit e145d237e4
33 changed files with 986 additions and 573 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
dChatServer/ChatPacketHandler.cpp
View File

@ -2,7 +2,7 @@
#include "PlayerContainer.h" #include "PlayerContainer.h"
#include "Database.h" #include "Database.h"
#include <vector> #include <vector>
#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 +75,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());
@ -103,25 +103,17 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
inStream.Read(requestorPlayerID); inStream.Read(requestorPlayerID);
uint32_t spacing{}; uint32_t spacing{};
inStream.Read(spacing); inStream.Read(spacing);
std::string playerName = ""; LUWString playerName(33);
uint16_t character;
bool noMoreLettersInName = false;
for (uint32_t j = 0; j < 33; j++) {
inStream.Read(character);
if (character == '\0') noMoreLettersInName = true;
if (!noMoreLettersInName) playerName.push_back(static_cast<char>(character));
}
char isBestFriendRequest{}; char isBestFriendRequest{};
inStream.Read(isBestFriendRequest); inStream.Read(isBestFriendRequest);
auto requestor = playerContainer.GetPlayerData(requestorPlayerID); auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
if (requestor->playerName == playerName) { if (requestor->playerName == playerName.GetAsString()) {
SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN); SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
return; return;
}; };
std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName)); std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName.GetAsString()));
// Check if player is online first // Check if player is online first
if (isBestFriendRequest && !requestee) { if (isBestFriendRequest && !requestee) {
@ -249,12 +241,14 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
LWOOBJID playerID; LWOOBJID playerID;
inStream.Read(playerID); inStream.Read(playerID);
eAddFriendResponseCode clientResponseCode = static_cast<eAddFriendResponseCode>(packet->data[0x14]); eAddFriendResponseCode clientResponseCode;
std::string friendName = PacketUtils::ReadString(0x15, packet, true); inStream.Read(clientResponseCode);
LUWString friendName(33);
inStream.Read(friendName);
//Now to try and find both of these: //Now to try and find both of these:
auto requestor = playerContainer.GetPlayerData(playerID); auto requestor = playerContainer.GetPlayerData(playerID);
auto requestee = playerContainer.GetPlayerData(friendName); auto requestee = playerContainer.GetPlayerData(friendName.GetAsString());
if (!requestor || !requestee) return; if (!requestor || !requestee) return;
eAddFriendResponseType serverResponseCode{}; eAddFriendResponseType serverResponseCode{};
@ -323,12 +317,13 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
CINSTREAM_SKIP_HEADER; CINSTREAM_SKIP_HEADER;
LWOOBJID playerID; LWOOBJID playerID;
inStream.Read(playerID); inStream.Read(playerID);
std::string friendName = PacketUtils::ReadString(0x14, packet, true); LUWString friendName(33);
inStream.Read(friendName);
//we'll have to query the db here to find the user, since you can delete them while they're offline. //we'll have to query the db here to find the user, since you can delete them while they're offline.
//First, we need to find their ID: //First, we need to find their ID:
std::unique_ptr<sql::PreparedStatement> stmt(Database::CreatePreppedStmt("SELECT id FROM charinfo WHERE name=? LIMIT 1;")); std::unique_ptr<sql::PreparedStatement> stmt(Database::CreatePreppedStmt("SELECT id FROM charinfo WHERE name=? LIMIT 1;"));
stmt->setString(1, friendName.c_str()); stmt->setString(1, friendName.GetAsString().c_str());
LWOOBJID friendID = 0; LWOOBJID friendID = 0;
std::unique_ptr<sql::ResultSet> res(stmt->executeQuery()); std::unique_ptr<sql::ResultSet> res(stmt->executeQuery());
@ -358,7 +353,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
break; break;
} }
} }
SendRemoveFriend(goonA, friendName, true); auto friendString = friendName.GetAsString();
SendRemoveFriend(goonA, friendString, true);
} }
auto goonB = playerContainer.GetPlayerData(friendID); auto goonB = playerContainer.GetPlayerData(friendID);
@ -394,9 +390,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
uint8_t channel = 0; uint8_t channel = 0;
inStream.Read(channel); inStream.Read(channel);
std::string message = PacketUtils::ReadString(0x66, packet, true, 512); LUWString message(512);
inStream.Read(message);
Game::logger->Log("ChatPacketHandler", "Got a message from (%s) [%d]: %s", senderName.c_str(), channel, message.c_str()); Game::logger->Log("ChatPacketHandler", "Got a message from (%s) [%d]: %s", senderName.c_str(), channel, message.GetAsString().c_str());
if (channel != 8) return; if (channel != 8) return;
@ -412,21 +409,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(message);
SystemAddress sysAddr = otherMember->sysAddr; SystemAddress sysAddr = otherMember->sysAddr;
SEND_PACKET; SEND_PACKET;
@ -434,13 +431,17 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
} }
void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) { void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
LWOOBJID senderID = PacketUtils::ReadPacketS64(0x08, packet); CINSTREAM_SKIP_HEADER;
std::string receiverName = PacketUtils::ReadString(0x66, packet, true); LWOOBJID senderID;
std::string message = PacketUtils::ReadString(0xAA, packet, true, 512); inStream.Read(senderID);
LUWString receiverName(33);
inStream.Read(receiverName);
LUWString message(512);
inStream.Read(message);
//Get the bois: //Get the bois:
auto goonA = playerContainer.GetPlayerData(senderID); auto goonA = playerContainer.GetPlayerData(senderID);
auto goonB = playerContainer.GetPlayerData(receiverName); auto goonB = playerContainer.GetPlayerData(receiverName.GetAsString());
if (!goonA || !goonB) return; if (!goonA || !goonB) return;
if (playerContainer.GetIsMuted(goonA)) return; if (playerContainer.GetIsMuted(goonA)) return;
@ -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.string, 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.string, 512));
SystemAddress sysAddr = goonB->sysAddr; SystemAddress sysAddr = goonB->sysAddr;
SEND_PACKET; SEND_PACKET;
@ -499,7 +500,8 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
CINSTREAM_SKIP_HEADER; CINSTREAM_SKIP_HEADER;
LWOOBJID playerID; LWOOBJID playerID;
inStream.Read(playerID); inStream.Read(playerID);
std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true); LUWString invitedPlayer(33);
inStream.Read(invitedPlayer);
auto* player = playerContainer.GetPlayerData(playerID); auto* player = playerContainer.GetPlayerData(playerID);
@ -513,7 +515,7 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
team = playerContainer.CreateTeam(playerID); team = playerContainer.CreateTeam(playerID);
} }
auto* other = playerContainer.GetPlayerData(invitedPlayer); auto* other = playerContainer.GetPlayerData(invitedPlayer.GetAsString());
if (other == nullptr) { if (other == nullptr) {
return; return;
@ -532,7 +534,7 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
SendTeamInvite(other, player); SendTeamInvite(other, player);
Game::logger->Log("ChatPacketHandler", "Got team invite: %llu -> %s", playerID, invitedPlayer.c_str()); Game::logger->Log("ChatPacketHandler", "Got team invite: %llu -> %s", playerID, invitedPlayer.GetAsString().c_str());
} }
void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) { void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
@ -589,18 +591,18 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
LWOOBJID playerID = LWOOBJID_EMPTY; LWOOBJID playerID = LWOOBJID_EMPTY;
inStream.Read(playerID); inStream.Read(playerID);
std::string kickedPlayer = PacketUtils::ReadString(0x14, packet, true); LUWString kickedPlayer(33);
inStream.Read(kickedPlayer);
Game::logger->Log("ChatPacketHandler", "(%llu) kicking (%s) from team", playerID, kickedPlayer.GetAsString().c_str());
Game::logger->Log("ChatPacketHandler", "(%llu) kicking (%s) from team", playerID, kickedPlayer.c_str()); auto* kicked = playerContainer.GetPlayerData(kickedPlayer.GetAsString());
auto* kicked = playerContainer.GetPlayerData(kickedPlayer);
LWOOBJID kickedId = LWOOBJID_EMPTY; LWOOBJID kickedId = LWOOBJID_EMPTY;
if (kicked != nullptr) { if (kicked != nullptr) {
kickedId = kicked->playerID; kickedId = kicked->playerID;
} else { } else {
kickedId = playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer)); kickedId = playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer.GetAsString()));
} }
if (kickedId == LWOOBJID_EMPTY) return; if (kickedId == LWOOBJID_EMPTY) return;
@ -619,11 +621,12 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
LWOOBJID playerID = LWOOBJID_EMPTY; LWOOBJID playerID = LWOOBJID_EMPTY;
inStream.Read(playerID); inStream.Read(playerID);
std::string promotedPlayer = PacketUtils::ReadString(0x14, packet, true); LUWString promotedPlayer(33);
inStream.Read(promotedPlayer);
Game::logger->Log("ChatPacketHandler", "(%llu) promoting (%s) to team leader", playerID, promotedPlayer.c_str()); Game::logger->Log("ChatPacketHandler", "(%llu) promoting (%s) to team leader", playerID, promotedPlayer.GetAsString().c_str());
auto* promoted = playerContainer.GetPlayerData(promotedPlayer); auto* promoted = playerContainer.GetPlayerData(promotedPlayer.GetAsString());
if (promoted == nullptr) return; if (promoted == nullptr) return;
@ -709,13 +712,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 +727,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 +754,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 +779,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 +796,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 +825,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 +851,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 +885,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 +924,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 +940,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 +965,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"
@ -146,7 +146,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);
@ -345,7 +345,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);

48
dCommon/dEnums/eStamps.h Normal file
View File

@ -0,0 +1,48 @@
#ifndef __ESTAMPS__H__
#define __ESTAMPS__H__
#include <cstdint>
enum class eStamps : uint32_t {
PASSPORT_AUTH_START,
PASSPORT_AUTH_BYPASS,
PASSPORT_AUTH_ERROR,
PASSPORT_AUTH_DB_SELECT_START,
PASSPORT_AUTH_DB_SELECT_FINISH,
PASSPORT_AUTH_DB_INSERT_START,
PASSPORT_AUTH_DB_INSERT_FINISH,
PASSPORT_AUTH_LEGOINT_COMMUNICATION_START,
PASSPORT_AUTH_LEGOINT_RECEIVED,
PASSPORT_AUTH_LEGOINT_THREAD_SPAWN,
PASSPORT_AUTH_LEGOINT_WEBSERVICE_START,
PASSPORT_AUTH_LEGOINT_WEBSERVICE_FINISH,
PASSPORT_AUTH_LEGOINT_LEGOCLUB_START,
PASSPORT_AUTH_LEGOINT_LEGOCLUB_FINISH,
PASSPORT_AUTH_LEGOINT_THREAD_FINISH,
PASSPORT_AUTH_LEGOINT_REPLY,
PASSPORT_AUTH_LEGOINT_ERROR,
PASSPORT_AUTH_LEGOINT_COMMUNICATION_END,
PASSPORT_AUTH_LEGOINT_DISCONNECT,
PASSPORT_AUTH_WORLD_COMMUNICATION_START,
PASSPORT_AUTH_CLIENT_OS,
PASSPORT_AUTH_WORLD_PACKET_RECEIVED,
PASSPORT_AUTH_IM_COMMUNICATION_START,
PASSPORT_AUTH_IM_LOGIN_START,
PASSPORT_AUTH_IM_LOGIN_ALREADY_LOGGED_IN,
PASSPORT_AUTH_IM_OTHER_LOGIN_REMOVED,
PASSPORT_AUTH_IM_LOGIN_QUEUED,
PASSPORT_AUTH_IM_LOGIN_RESPONSE,
PASSPORT_AUTH_IM_COMMUNICATION_END,
PASSPORT_AUTH_WORLD_SESSION_CONFIRM_TO_AUTH,
PASSPORT_AUTH_WORLD_COMMUNICATION_FINISH,
PASSPORT_AUTH_WORLD_DISCONNECT,
NO_LEGO_INTERFACE,
DB_ERROR,
GM_REQUIRED,
NO_LEGO_WEBSERVICE_XML,
LEGO_WEBSERVICE_TIMEOUT,
LEGO_WEBSERVICE_ERROR,
NO_WORLD_SERVER
};
#endif //!__ESTAMPS__H__

1
dGame/Entity.cpp
View File

@ -3,7 +3,6 @@
#include "CDClientManager.h" #include "CDClientManager.h"
#include "Game.h" #include "Game.h"
#include "dLogger.h" #include "dLogger.h"
#include <PacketUtils.h>
#include <functional> #include <functional>
#include "CDDestructibleComponentTable.h" #include "CDDestructibleComponentTable.h"
#include "CDClientDatabase.h" #include "CDClientDatabase.h"

91
dGame/UserManager.cpp
View File

@ -11,7 +11,7 @@
#include <WorldPackets.h> #include <WorldPackets.h>
#include "Character.h" #include "Character.h"
#include <BitStream.h> #include <BitStream.h>
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "../dWorldServer/ObjectIDManager.h" #include "../dWorldServer/ObjectIDManager.h"
#include "dLogger.h" #include "dLogger.h"
#include "GeneralUtils.h" #include "GeneralUtils.h"
@ -248,30 +248,44 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet) { void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet) {
User* u = GetUser(sysAddr); User* u = GetUser(sysAddr);
if (!u) return; if (!u) return;
CINSTREAM;
LUWString name(33);
inStream.Read(name);
std::string name = PacketUtils::ReadString(8, packet, true); uint32_t firstNameIndex;
inStream.Read(firstNameIndex);
uint32_t firstNameIndex = PacketUtils::ReadPacketU32(74, packet); uint32_t middleNameIndex;
uint32_t middleNameIndex = PacketUtils::ReadPacketU32(78, packet); inStream.Read(middleNameIndex);
uint32_t lastNameIndex = PacketUtils::ReadPacketU32(82, packet); uint32_t lastNameIndex;
inStream.Read(lastNameIndex);
std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex); std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex);
uint32_t shirtColor = PacketUtils::ReadPacketU32(95, packet); uint32_t shirtColor;
uint32_t shirtStyle = PacketUtils::ReadPacketU32(99, packet); inStream.Read(shirtColor);
uint32_t pantsColor = PacketUtils::ReadPacketU32(103, packet); uint32_t shirtStyle;
uint32_t hairStyle = PacketUtils::ReadPacketU32(107, packet); inStream.Read(shirtStyle);
uint32_t hairColor = PacketUtils::ReadPacketU32(111, packet); uint32_t pantsColor;
uint32_t lh = PacketUtils::ReadPacketU32(115, packet); inStream.Read(pantsColor);
uint32_t rh = PacketUtils::ReadPacketU32(119, packet); uint32_t hairStyle;
uint32_t eyebrows = PacketUtils::ReadPacketU32(123, packet); inStream.Read(hairStyle);
uint32_t eyes = PacketUtils::ReadPacketU32(127, packet); uint32_t hairColor;
uint32_t mouth = PacketUtils::ReadPacketU32(131, packet); inStream.Read(hairColor);
uint32_t lh;
inStream.Read(lh);
uint32_t rh;
inStream.Read(rh);
uint32_t eyebrows;
inStream.Read(eyebrows);
uint32_t eyes;
inStream.Read(eyes);
uint32_t mouth;
inStream.Read(mouth);
LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle); LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
LOT pantsLOT = FindCharPantsID(pantsColor); LOT pantsLOT = FindCharPantsID(pantsColor);
if (name != "" && !UserManager::IsNameAvailable(name)) { if (name.GetAsString() != "" && !UserManager::IsNameAvailable(name.GetAsString())) {
Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str()); Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.GetAsString().c_str());
WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE); WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
return; return;
} }
@ -282,10 +296,10 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
return; return;
} }
if (name == "") { if (name.GetAsString() == "") {
Game::logger->Log("UserManager", "AccountID: %i is creating a character with predefined name: %s", u->GetAccountID(), predefinedName.c_str()); Game::logger->Log("UserManager", "AccountID: %i is creating a character with predefined name: %s", u->GetAccountID(), predefinedName.c_str());
} else { } else {
Game::logger->Log("UserManager", "AccountID: %i is creating a character with name: %s (temporary: %s)", u->GetAccountID(), name.c_str(), predefinedName.c_str()); Game::logger->Log("UserManager", "AccountID: %i is creating a character with name: %s (temporary: %s)", u->GetAccountID(), name.GetAsString().c_str(), predefinedName.c_str());
} }
//Now that the name is ok, we can get an objectID from Master: //Now that the name is ok, we can get an objectID from Master:
@ -334,20 +348,20 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
xml3 << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>"; xml3 << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>";
//Check to see if our name was pre-approved: //Check to see if our name was pre-approved:
bool nameOk = IsNamePreapproved(name); bool nameOk = IsNamePreapproved(name.GetAsString());
if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true; if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
if (name != "") { if (name.GetAsString() != "") {
sql::PreparedStatement* stmt = Database::CreatePreppedStmt("INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`) VALUES (?,?,?,?,?,?)"); sql::PreparedStatement* stmt = Database::CreatePreppedStmt("INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`) VALUES (?,?,?,?,?,?)");
stmt->setUInt(1, objectID); stmt->setUInt(1, objectID);
stmt->setUInt(2, u->GetAccountID()); stmt->setUInt(2, u->GetAccountID());
stmt->setString(3, predefinedName.c_str()); stmt->setString(3, predefinedName.c_str());
stmt->setString(4, name.c_str()); stmt->setString(4, name.GetAsString().c_str());
stmt->setBoolean(5, false); stmt->setBoolean(5, false);
stmt->setUInt64(6, time(NULL)); stmt->setUInt64(6, time(NULL));
if (nameOk) { if (nameOk) {
stmt->setString(3, name.c_str()); stmt->setString(3, name.GetAsString().c_str());
stmt->setString(4, ""); stmt->setString(4, "");
} }
@ -386,8 +400,9 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
Game::logger->Log("UserManager", "Couldn't get user to delete character"); Game::logger->Log("UserManager", "Couldn't get user to delete character");
return; return;
} }
CINSTREAM_SKIP_HEADER;
LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet); LWOOBJID objectID;
inStream.Read(objectID);
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 +438,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);
} }
@ -482,15 +497,17 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
Game::logger->Log("UserManager", "Couldn't get user to delete character"); Game::logger->Log("UserManager", "Couldn't get user to delete character");
return; return;
} }
CINSTREAM_SKIP_HEADER;
LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet); LWOOBJID objectID;
inStream.Read(objectID);
GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER); GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT); GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);
uint32_t charID = static_cast<uint32_t>(objectID); uint32_t charID = static_cast<uint32_t>(objectID);
Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID); Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID);
std::string newName = PacketUtils::ReadString(16, packet, true); LUWString newName(33);
inStream.Read(newName);
Character* character = nullptr; Character* character = nullptr;
@ -505,32 +522,32 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID()); Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID());
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR); WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
} else if (hasCharacter && character) { } else if (hasCharacter && character) {
if (newName == character->GetName()) { if (newName.GetAsString() == character->GetName()) {
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE); WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
return; return;
} }
if (IsNameAvailable(newName)) { if (IsNameAvailable(newName.GetAsString())) {
if (IsNamePreapproved(newName)) { if (IsNamePreapproved(newName.GetAsString())) {
sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET name=?, pending_name='', needs_rename=0, last_login=? WHERE id=? LIMIT 1"); sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET name=?, pending_name='', needs_rename=0, last_login=? WHERE id=? LIMIT 1");
stmt->setString(1, newName); stmt->setString(1, newName.GetAsString());
stmt->setUInt64(2, time(NULL)); stmt->setUInt64(2, time(NULL));
stmt->setUInt(3, character->GetID()); stmt->setUInt(3, character->GetID());
stmt->execute(); stmt->execute();
delete stmt; delete stmt;
Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.c_str()); Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.GetAsString().c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS); WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr); UserManager::RequestCharacterList(sysAddr);
} else { } else {
sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET pending_name=?, needs_rename=0, last_login=? WHERE id=? LIMIT 1"); sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET pending_name=?, needs_rename=0, last_login=? WHERE id=? LIMIT 1");
stmt->setString(1, newName); stmt->setString(1, newName.GetAsString());
stmt->setUInt64(2, time(NULL)); stmt->setUInt64(2, time(NULL));
stmt->setUInt(3, character->GetID()); stmt->setUInt(3, character->GetID());
stmt->execute(); stmt->execute();
delete stmt; delete stmt;
Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str()); Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.GetAsString().c_str());
WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS); WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
UserManager::RequestCharacterList(sysAddr); UserManager::RequestCharacterList(sysAddr);
} }

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);

1
dGame/dComponents/RebuildComponent.cpp
View File

@ -14,7 +14,6 @@
#include "eGameActivity.h" #include "eGameActivity.h"
#include "dServer.h" #include "dServer.h"
#include "PacketUtils.h"
#include "Spawner.h" #include "Spawner.h"
#include "MovingPlatformComponent.h" #include "MovingPlatformComponent.h"
#include "Preconditions.h" #include "Preconditions.h"

1
dGame/dComponents/RenderComponent.cpp
View File

@ -5,7 +5,6 @@
#include <iomanip> #include <iomanip>
#include "Entity.h" #include "Entity.h"
#include "PacketUtils.h"
#include "CDClientManager.h" #include "CDClientManager.h"
#include "GameMessages.h" #include "GameMessages.h"

4
dGame/dComponents/RocketLaunchpadControlComponent.cpp
View File

@ -15,7 +15,7 @@
#include "PropertyEntranceComponent.h" #include "PropertyEntranceComponent.h"
#include "RocketLaunchLupComponent.h" #include "RocketLaunchLupComponent.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>
@ -314,7 +314,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;
@ -336,7 +336,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);

11
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"
@ -172,7 +173,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(animationName);
bitStream.Write(bExpectAnimToExist); bitStream.Write(bExpectAnimToExist);
@ -325,7 +326,7 @@ 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()); //BitstreamUtils::WriteString(bitStream, audioGUID, audioGUID.size());
//bitStream.Write(uint32_t(audioGUID.size())); //bitStream.Write(uint32_t(audioGUID.size()));
//for (char character : audioGUID) { //for (char character : audioGUID) {
@ -2179,7 +2180,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);
@ -2431,7 +2432,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);
@ -2679,7 +2680,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);

12
dGame/dUtilities/Mail.cpp
View File

@ -283,7 +283,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 +406,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 +414,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 +433,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 +442,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 +456,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);

44
dMasterServer/MasterServer.cpp
View File

@ -40,7 +40,7 @@
#include "InstanceManager.h" #include "InstanceManager.h"
#include "MasterPackets.h" #include "MasterPackets.h"
#include "ObjectIDManager.h" #include "ObjectIDManager.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "FdbToSqlite.h" #include "FdbToSqlite.h"
namespace Game { namespace Game {
@ -561,13 +561,19 @@ void HandlePacket(Packet* packet) {
uint32_t theirZoneID = 0; uint32_t theirZoneID = 0;
uint32_t theirInstanceID = 0; uint32_t theirInstanceID = 0;
ServerType theirServerType; ServerType theirServerType;
uint32_t theirIPSize;
std::string theirIP = ""; std::string theirIP = "";
inStream.Read(theirPort); inStream.Read(theirPort);
inStream.Read(theirZoneID); inStream.Read(theirZoneID);
inStream.Read(theirInstanceID); inStream.Read(theirInstanceID);
inStream.Read(theirServerType); inStream.Read(theirServerType);
theirIP = PacketUtils::ReadString(24, packet, false); //24 is the current offset inStream.Read(theirIPSize);
char character;
while(theirIPSize-- > 0) {
inStream.Read(character);
theirIP.push_back(character);
}
if (theirServerType == ServerType::World && !Game::im->IsPortInUse(theirPort)) { if (theirServerType == ServerType::World && !Game::im->IsPortInUse(theirPort)) {
Instance* in = new Instance(theirIP, theirPort, theirZoneID, theirInstanceID, 0, 12, 12); Instance* in = new Instance(theirIP, theirPort, theirZoneID, theirInstanceID, 0, 12, 12);
@ -608,23 +614,21 @@ void HandlePacket(Packet* packet) {
} }
case eMasterMessageType::SET_SESSION_KEY: { case eMasterMessageType::SET_SESSION_KEY: {
RakNet::BitStream inStream(packet->data, packet->length, false); CINSTREAM_SKIP_HEADER;
uint64_t header = inStream.Read(header);
uint32_t sessionKey = 0; uint32_t sessionKey = 0;
std::string username;
inStream.Read(sessionKey); inStream.Read(sessionKey);
username = PacketUtils::ReadString(12, packet, false); LUString username(33);
inStream.Read(username);
for (auto it : activeSessions) { for (auto it : activeSessions) {
if (it.second == username) { if (it.second == username.string) {
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.string.size());
for (auto character : username) { for (auto character : username.string) {
bitStream.Write(character); bitStream.Write(character);
} }
SEND_PACKET_BROADCAST; SEND_PACKET_BROADCAST;
@ -633,22 +637,22 @@ void HandlePacket(Packet* packet) {
} }
} }
activeSessions.insert(std::make_pair(sessionKey, username)); activeSessions.insert(std::make_pair(sessionKey, username.string));
Game::logger->Log("MasterServer", "Got sessionKey %i for user %s", sessionKey, username.c_str()); Game::logger->Log("MasterServer", "Got sessionKey %i for user %s", sessionKey, username.string.c_str());
break; break;
} }
case eMasterMessageType::REQUEST_SESSION_KEY: { case eMasterMessageType::REQUEST_SESSION_KEY: {
RakNet::BitStream inStream(packet->data, packet->length, false); CINSTREAM_SKIP_HEADER
uint64_t header = inStream.Read(header); LUWString username(33);
std::string username = PacketUtils::ReadString(8, packet, false); inStream.Read(username);
for (auto key : activeSessions) { for (auto key : activeSessions) {
if (key.second == username) { if (key.second == username.GetAsString()) {
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;
} }
@ -892,7 +896,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");
} }

340
dNet/AuthPackets.cpp
View File

@ -1,5 +1,5 @@
#include "AuthPackets.h" #include "AuthPackets.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "dNetCommon.h" #include "dNetCommon.h"
#include "dServer.h" #include "dServer.h"
@ -19,6 +19,7 @@
#include <BitStream.h> #include <BitStream.h>
#include <future> #include <future>
#include "PacketUtils.h"
#include "Game.h" #include "Game.h"
#include "dConfig.h" #include "dConfig.h"
#include "eServerDisconnectIdentifiers.h" #include "eServerDisconnectIdentifiers.h"
@ -26,46 +27,136 @@
#include "eConnectionType.h" #include "eConnectionType.h"
#include "eServerMessageType.h" #include "eServerMessageType.h"
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
#include "eStamps.h"
enum class ClientOS : uint8_t {
UNKNOWN,
WINDOWS,
MACOS
};
enum class LCID : uint16_t {
en_US = 0x0409,
de_DE = 0x0407,
en_GB = 0x0809
};
enum class Language : uint32_t {
en_US,
pl_US,
de_DE,
en_GB,
};
void Stamp::Serialize(RakNet::BitStream* outBitStream){
outBitStream->Write(type);
outBitStream->Write(value);
outBitStream->Write(timestamp);
};
void AuthPackets::HandleHandshake(dServer* server, Packet* packet) { void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
RakNet::BitStream inStream(packet->data, packet->length, false); CINSTREAM_SKIP_HEADER
uint64_t header = inStream.Read(header);
uint32_t clientVersion = 0; uint32_t clientVersion = 0;
inStream.Read(clientVersion); inStream.Read(clientVersion);
server->GetLogger()->Log("AuthPackets", "Received client version: %i", clientVersion); uint32_t paddingZero;
inStream.Read(paddingZero);
if (paddingZero != 0) Game::logger->Log("AuthPackets::HandleHandShake", "WARNING: ZeroPadding is not Zero!");
ServiceId serviceId;
inStream.Read(serviceId);
if (serviceId != ServiceId::Client) Game::logger->Log("AuthPackets::HandleHandShake", "WARNING: Service ID is not a Client!");
uint32_t processID;
inStream.Read(processID);
uint16_t port;
inStream.Read(port);
LUWString paddingString(33);
inStream.Read(paddingString);
if (!paddingString.string.empty()) Game::logger->Log("AuthPackets::HandleHandShake", "WARNING: StringPadding is not empty!");
if (inStream.GetNumberOfUnreadBits() != 8) Game::logger->Log("AuthPackets::HandleHandShake", "WARNING: End padding is incorrect!");
Game::logger->Log("AuthPackets::HandleHandShake", "Client Data [Version: %i, PaddingZero: %i, Service: %u, Process: %u, Port: %u, paddingString: %s, Sysaddr Port: %u]", clientVersion, paddingZero, serviceId, processID, port, paddingString.string.c_str(), packet->systemAddress.port);
SendHandshake(server, packet->systemAddress, server->GetIP(), server->GetPort(), server->GetServerType()); SendHandshake(server, packet->systemAddress, server->GetIP(), server->GetPort(), server->GetServerType());
} }
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 handshakeResponse;
PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM); BitstreamUtils::WriteHeader(handshakeResponse, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM);
bitStream.Write<unsigned int>(NET_VERSION); handshakeResponse.Write<uint32_t>(NET_VERSION);
bitStream.Write(uint32_t(0x93)); handshakeResponse.Write<uint32_t>(0); // Unused/Unknown/Padding
if (serverType == ServerType::Auth) bitStream.Write(uint32_t(1)); //Conn: auth if (serverType == ServerType::Auth) handshakeResponse.Write(ServiceId::Auth);
else bitStream.Write(uint32_t(4)); //Conn: world else if (serverType == ServerType::World) handshakeResponse.Write(ServiceId::World);
else handshakeResponse.Write(ServiceId::General);
bitStream.Write(uint32_t(0)); //Server process ID server->Send(&handshakeResponse, sysAddr, false);
bitStream.Write(nextServerPort);
server->Send(&bitStream, sysAddr, false);
} }
void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) { void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
std::string username = PacketUtils::ReadString(8, packet, true); CINSTREAM_SKIP_HEADER;
std::string password = PacketUtils::ReadString(0x4A, packet, true);
const char* szUsername = username.c_str(); LUWString username(33);
inStream.Read(username);
std::string usernameString = GeneralUtils::UTF16ToWTF8(username.string);
LUWString password(41);
inStream.Read(password);
LCID locale_id;
inStream.Read(locale_id);
Game::logger->Log("AuthPackets", "Locale ID: %i", locale_id);
ClientOS clientOS;
inStream.Read(clientOS);
std::string clientOSString = "Unknown";
if (clientOS == ClientOS::WINDOWS) clientOSString = "Windows";
else if (clientOS == ClientOS::MACOS) clientOSString = "MacOS";
Game::logger->Log("AuthPackets", "Operating System: %s",clientOSString.c_str());
LUWString memoryStats(256);
inStream.Read(memoryStats);
Game::logger->Log("AuthPackets", "Memory Stats [%s]", memoryStats.GetAsString().c_str());
LUWString videoCard(128);
inStream.Read(videoCard);
Game::logger->Log("AuthPackets", "VideoCard Info: [%s]", videoCard.GetAsString().c_str());
// Processor/CPU info
uint32_t numOfProcessors;
inStream.Read(numOfProcessors);
uint32_t processorType;
inStream.Read(processorType);
uint16_t processorLevel;
inStream.Read(processorLevel);
uint16_t processorRevision;
inStream.Read(processorRevision);
Game::logger->Log("AuthPackets", "CPU Info: [#Processors: %i, Processor Type: %i, Processor Level: %i, Processor Revision: %i]", numOfProcessors, processorType, processorLevel, processorRevision);
// OS Info
uint32_t osVersionInfoSize;
inStream.Read(osVersionInfoSize);
uint32_t majorVersion;
inStream.Read(majorVersion);
uint32_t minorVersion;
inStream.Read(minorVersion);
uint32_t buildNumber;
inStream.Read(buildNumber);
uint32_t platformID;
inStream.Read(platformID);
Game::logger->Log("AuthPackets", "OS Info: [Size: %i, Major: %i, Minor %i, Buid#: %i, platformID: %i]", osVersionInfoSize, majorVersion, minorVersion, buildNumber, platformID);
// Fetch account details // Fetch account details
sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT password, banned, locked, play_key_id, gm_level FROM accounts WHERE name=? LIMIT 1;"); std::unique_ptr<sql::PreparedStatement> stmt(Database::CreatePreppedStmt("SELECT password, banned, locked, play_key_id, gm_level FROM accounts WHERE name=? LIMIT 1;"));
stmt->setString(1, szUsername); stmt->setString(1, usernameString.c_str());
sql::ResultSet* res = stmt->executeQuery(); std::unique_ptr<sql::ResultSet> res(stmt->executeQuery());
if (res->rowsCount() == 0) { if (res->rowsCount() == 0) {
server->GetLogger()->Log("AuthPackets", "No user found!"); server->GetLogger()->Log("AuthPackets", "No user found!");
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::INVALID_USER, "", "", 2001, username); AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::INVALID_USER, "", "", 2001, usernameString);
return; return;
} }
@ -83,21 +174,25 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
sqlGmLevel = res->getInt(5); sqlGmLevel = res->getInt(5);
} }
delete stmt; int32_t bcryptState = ::bcrypt_checkpw(GeneralUtils::UTF16ToWTF8(password.string).c_str(), sqlPass.c_str());
delete res; if (bcryptState != 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::WRONG_PASS, "", "", 2001, usernameString);
server->GetLogger()->Log("AuthPackets", "Wrong password used");
return;
}
//If we aren't running in live mode, then only GMs are allowed to enter: //If we aren't running in live mode, then only GMs are allowed to enter:
const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs"); const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs");
if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && sqlGmLevel == 0) { if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username); AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, usernameString);
return; return;
} }
if (Game::config->GetValue("dont_use_keys") != "1") { if (Game::config->GetValue("dont_use_keys") != "1") {
//Check to see if we have a play key: //Check to see if we have a play key:
if (sqlPlayKey == 0 && sqlGmLevel == 0) { if (sqlPlayKey == 0 && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username); AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, usernameString);
server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but they don't have a play key.", username.c_str()); server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but they don't have a play key.", usernameString.c_str());
return; return;
} }
@ -108,7 +203,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
bool isKeyActive = false; bool isKeyActive = false;
if (keyRes->rowsCount() == 0 && sqlGmLevel == 0) { if (keyRes->rowsCount() == 0 && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username); AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, usernameString);
return; return;
} }
@ -117,150 +212,133 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
} }
if (!isKeyActive && sqlGmLevel == 0) { if (!isKeyActive && sqlGmLevel == 0) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username); AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, usernameString);
server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but their play key was disabled", username.c_str()); server->GetLogger()->Log("AuthPackets", "User %s tried to log in, but their play key was disabled", usernameString.c_str());
return; return;
} }
} }
if (sqlBanned) { if (sqlBanned) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::BANNED, "", "", 2001, username); return; AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::BANNED, "", "", 2001, usernameString);
return;
} }
if (sqlLocked) { if (sqlLocked) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, username); return; AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, usernameString);
return;
} }
/* auto system = packet->systemAddress; //Copy the sysAddr before the Packet gets destroyed from main
* Updated hashing method:
* First attempt bcrypt.
* If that fails, fallback to old method and setup bcrypt for new login.
*/
bool loginSuccess = true; if (!server->GetIsConnectedToMaster()) {
AuthPackets::SendLoginResponse(server, system, eLoginResponse::GENERAL_FAILED, "Unable to Connect to Master Server", "", 0, usernameString);
int32_t bcryptState = ::bcrypt_checkpw(password.c_str(), sqlPass.c_str()); Game::logger->Log("AuthPackets", "Unable to complete login of user %s due to no connection to Master", usernameString.c_str());
return;
if (bcryptState != 0) {
// Fallback on old method
std::string oldPassword = sha512(password + username);
if (sqlPass != oldPassword) {
loginSuccess = false;
} else {
// Generate new hash for bcrypt
char salt[BCRYPT_HASHSIZE];
char hash[BCRYPT_HASHSIZE];
bcryptState = ::bcrypt_gensalt(12, salt);
assert(bcryptState == 0);
bcryptState = ::bcrypt_hashpw(password.c_str(), salt, hash);
assert(bcryptState == 0);
sql::PreparedStatement* accountUpdate = Database::CreatePreppedStmt("UPDATE accounts SET password = ? WHERE name = ? LIMIT 1;");
accountUpdate->setString(1, std::string(hash, BCRYPT_HASHSIZE).c_str());
accountUpdate->setString(2, szUsername);
accountUpdate->executeUpdate();
}
} else {
// Login success with bcrypt
} }
if (!loginSuccess) { ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, server, usernameString](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) {
AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::WRONG_PASS, "", "", 2001, username); AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, usernameString);
server->GetLogger()->Log("AuthPackets", "Wrong password used"); });
} else {
SystemAddress system = packet->systemAddress; //Copy the sysAddr before the Packet gets destroyed from main
if (!server->GetIsConnectedToMaster()) {
AuthPackets::SendLoginResponse(server, system, eLoginResponse::GENERAL_FAILED, "", "", 0, username);
return;
}
ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, server, username](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) {
AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, 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) { 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 loginResponse;
PacketUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE); BitstreamUtils::WriteHeader(loginResponse, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
packet.Write(static_cast<uint8_t>(responseCode)); loginResponse.Write(responseCode);
PacketUtils::WritePacketString("Talk_Like_A_Pirate", 33, &packet); // Events
loginResponse.Write(LUString("Talk_Like_A_Pirate"));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
loginResponse.Write(LUString(""));
// 7 unknown strings - perhaps other IP addresses? loginResponse.Write(static_cast<uint16_t>(1)); // Version Major
PacketUtils::WritePacketString("", 33, &packet); loginResponse.Write(static_cast<uint16_t>(10)); // Version Current
PacketUtils::WritePacketString("", 33, &packet); loginResponse.Write(static_cast<uint16_t>(64)); // Version Minor
PacketUtils::WritePacketString("", 33, &packet);
PacketUtils::WritePacketString("", 33, &packet);
PacketUtils::WritePacketString("", 33, &packet);
PacketUtils::WritePacketString("", 33, &packet);
PacketUtils::WritePacketString("", 33, &packet);
packet.Write(static_cast<uint16_t>(1)); // Version Major
packet.Write(static_cast<uint16_t>(10)); // Version Current
packet.Write(static_cast<uint16_t>(64)); // Version Minor
// Writes the user key // Writes the user key
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); loginResponse.Write(LUWString(userHash));
// Write the Character and Chat IPs // World Server IP
PacketUtils::WritePacketString(wServerIP, 33, &packet); loginResponse.Write(LUString(wServerIP));
PacketUtils::WritePacketString("", 33, &packet); // Chat Server IP (unused)
loginResponse.Write(LUString(""));
// Write the Character and Chat Ports // World Server Redirect port
packet.Write(static_cast<uint16_t>(wServerPort)); loginResponse.Write(wServerPort);
packet.Write(static_cast<uint16_t>(0)); // Char Server Redirect port (unused)
loginResponse.Write(static_cast<uint16_t>(0));
// Write another IP // CDN Key
PacketUtils::WritePacketString("", 33, &packet); loginResponse.Write(LUString(""));
// Write a GUID or something... // CDN Ticket
PacketUtils::WritePacketString("00000000-0000-0000-0000-000000000000", 37, &packet); loginResponse.Write(LUString("00000000-0000-0000-0000-000000000000", 37));
packet.Write(static_cast<uint32_t>(0)); // ??? // Language
loginResponse.Write(Language::en_US);
// Write the localization // Country Code
PacketUtils::WritePacketString("US", 3, &packet); loginResponse.Write(LUString("US", 3));
packet.Write(static_cast<uint8_t>(false)); // User first logged in?
packet.Write(static_cast<uint8_t>(false)); // User is F2P? // Just upgraded from FTP
packet.Write(static_cast<uint64_t>(0)); // ??? loginResponse.Write(static_cast<uint8_t>(false));
// Is FTP, static_cast<uint32_t>(errorMsg.length()))
loginResponse.Write(static_cast<uint8_t>(false));
// Time remaining in FTP
loginResponse.Write(static_cast<uint64_t>(0));
// Write custom error message // Write custom error message
packet.Write(static_cast<uint16_t>(errorMsg.length())); loginResponse.Write(static_cast<uint16_t>(errorMsg.length()));
PacketUtils::WritePacketWString(errorMsg, static_cast<uint32_t>(errorMsg.length()), &packet); loginResponse.Write(errorMsg);
// Here write auth logs // Stamps
packet.Write(static_cast<uint32_t>(20)); std::vector<Stamp> stamps;
for (uint32_t i = 0; i < 20; ++i) { stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_START, 0, time(nullptr)));
packet.Write(static_cast<uint32_t>(8)); stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_COMMUNICATION_START, 207, time(nullptr)));
packet.Write(static_cast<uint32_t>(44)); stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_RECEIVED, 13, time(nullptr)));
packet.Write(static_cast<uint32_t>(14000)); stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_THREAD_SPAWN, 0, time(nullptr)));
packet.Write(static_cast<uint32_t>(0)); stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_WEBSERVICE_START, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_WEBSERVICE_FINISH, 1, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_THREAD_FINISH, 1, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_REPLY, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_LEGOINT_COMMUNICATION_END, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_DB_INSERT_START, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_DB_INSERT_FINISH, 1, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_CLIENT_OS, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_WORLD_COMMUNICATION_START, 16087, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_WORLD_PACKET_RECEIVED, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_IM_COMMUNICATION_START, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_IM_LOGIN_START, 5926, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_IM_LOGIN_RESPONSE, 5926, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_IM_COMMUNICATION_END, 1, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_WORLD_SESSION_CONFIRM_TO_AUTH, 0, time(nullptr)));
stamps.push_back(Stamp(eStamps::PASSPORT_AUTH_WORLD_COMMUNICATION_FINISH, 16087, time(nullptr)));
loginResponse.Write(static_cast<uint32_t>((sizeof(Stamp) * stamps.size()) + sizeof(uint32_t)));
for (auto& stamp : stamps) {
stamp.Serialize(&loginResponse);
} }
PacketUtils::SavePacket("loginresponse",(const char*)loginResponse.GetData(), loginResponse.GetNumberOfBytesUsed());
server->Send(&packet, sysAddr, false); Game::logger->Log("AuthPackets", "Sending Login Response...");
server->Send(&loginResponse, sysAddr, false);
//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());

15
dNet/AuthPackets.h
View File

@ -7,8 +7,23 @@
enum class ServerType : uint32_t; enum class ServerType : uint32_t;
enum class eLoginResponse : uint8_t; enum class eLoginResponse : uint8_t;
enum class eStamps : uint32_t;
class dServer; class dServer;
struct Stamp {
eStamps type;
uint32_t value;
uint64_t timestamp;
Stamp(eStamps type, uint32_t value, uint64_t timestamp){
this->type = type;
this->value = value;
this->timestamp = timestamp;
}
void Serialize(RakNet::BitStream* outBitStream);
};
namespace AuthPackets { namespace AuthPackets {
void HandleHandshake(dServer* server, Packet* packet); void HandleHandshake(dServer* server, Packet* packet);
void SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType); void SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType);

127
dNet/BitstreamUtils.h Normal file
View File

@ -0,0 +1,127 @@
#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 {
template <>
inline bool RakNet::BitStream::Read<LUString>(LUString& value) {
bool noMoreLetters = false;
char character;
for (uint32_t j = 0; j < value.size; j++) {
if (!Read(character)) return false;
if (character == '\0') noMoreLetters = true;
if (!noMoreLetters) value.string.push_back(character);
}
return true;
}
template <>
inline bool RakNet::BitStream::Read<LUWString>(LUWString& value) {
bool noMoreLetters = false;
char16_t character;
for (uint32_t j = 0; j < value.size; j++) {
if (!Read(character)) return false;
if (character == '\0') noMoreLetters = true;
if (!noMoreLetters) value.string.push_back(character);
}
return true;
}
template <>
inline void RakNet::BitStream::Write<LUString>(LUString value) {
uint32_t size = value.string.size();
uint32_t emptySize = value.size - size;
if (size > value.size) size = value.size;
for (uint32_t i = 0; i < size; i++) {
this->Write(static_cast<char>(value.string[i]));
}
for (uint32_t i = 0; i < emptySize; i++) {
this->Write(static_cast<char>(0));
}
}
template <>
inline void RakNet::BitStream::Write<LUWString>(LUWString value) {
uint32_t size = static_cast<uint32_t>(value.string.length());
uint32_t remSize = static_cast<uint32_t>(value.size - size);
if (size > value.size) size = value.size;
for (uint32_t i = 0; i < size; ++i) {
this->Write(static_cast<uint16_t>(value.string[i]));
}
for (uint32_t j = 0; j < remSize; ++j) {
this->Write(static_cast<uint16_t>(0));
}
}
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()) * 2);
}
};
#endif //!__BITSTREAMUTILS__H__

12
dNet/ChatPackets.cpp
View File

@ -7,20 +7,20 @@
#include "RakNetTypes.h" #include "RakNetTypes.h"
#include "BitStream.h" #include "BitStream.h"
#include "Game.h" #include "Game.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 +36,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(""));
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 +68,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;

27
dNet/MasterPackets.cpp
View File

@ -1,6 +1,6 @@
#include "MasterPackets.h" #include "MasterPackets.h"
#include "BitStream.h" #include "BitStream.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "dCommonVars.h" #include "dCommonVars.h"
#include "dServer.h" #include "dServer.h"
#include "eConnectionType.h" #include "eConnectionType.h"
@ -10,14 +10,14 @@
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 +27,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 +39,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 +54,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 +69,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 +79,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 +87,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, 255));
server->Send(&bitStream, sysAddr, false); server->Send(&bitStream, sysAddr, false);
} }
@ -99,25 +99,26 @@ void MasterPackets::HandleServerInfo(Packet* packet) {
uint32_t theirPort = 0; uint32_t theirPort = 0;
uint32_t theirZoneID = 0; uint32_t theirZoneID = 0;
uint32_t theirInstanceID = 0; uint32_t theirInstanceID = 0;
std::string theirIP = ""; LUString theirIP(33);
inStream.Read(theirPort); inStream.Read(theirPort);
inStream.Read(theirZoneID); inStream.Read(theirZoneID);
inStream.Read(theirInstanceID); inStream.Read(theirInstanceID);
theirIP = PacketUtils::ReadString(inStream.GetReadOffset(), packet, false); //20 is the current offset inStream.Read(theirIP);
//TODO: Actually mark this server as an available server in the manager //TODO: Actually mark this server as an available server in the manager
} }
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<uint32_t>(server->GetIP().size());
bitStream.Write(server->GetIP());
server->SendToMaster(&bitStream); server->SendToMaster(&bitStream);
} }

131
dNet/PacketUtils.cpp
View File

@ -1,139 +1,8 @@
#include "PacketUtils.h" #include "PacketUtils.h"
#include <vector>
#include <fstream> #include <fstream>
#include "dLogger.h" #include "dLogger.h"
#include "Game.h" #include "Game.h"
uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) {
if (startLoc + 2 > packet->length) return 0;
std::vector<unsigned char> t;
for (uint32_t i = startLoc; i < startLoc + 2; i++) t.push_back(packet->data[i]);
return *(uint16_t*)t.data();
}
uint32_t PacketUtils::ReadPacketU32(uint32_t startLoc, Packet* packet) {
if (startLoc + 4 > packet->length) return 0;
std::vector<unsigned char> t;
for (uint32_t i = startLoc; i < startLoc + 4; i++) {
t.push_back(packet->data[i]);
}
return *(uint32_t*)t.data();
}
uint64_t PacketUtils::ReadPacketU64(uint32_t startLoc, Packet* packet) {
if (startLoc + 8 > packet->length) return 0;
std::vector<unsigned char> t;
for (uint32_t i = startLoc; i < startLoc + 8; i++) t.push_back(packet->data[i]);
return *(uint64_t*)t.data();
}
int64_t PacketUtils::ReadPacketS64(uint32_t startLoc, Packet* packet) {
if (startLoc + 8 > packet->length) return 0;
std::vector<unsigned char> t;
for (size_t i = startLoc; i < startLoc + 8; i++) t.push_back(packet->data[i]);
return *(int64_t*)t.data();
}
std::string PacketUtils::ReadString(uint32_t startLoc, Packet* packet, bool wide, uint32_t maxLen) {
std::string readString = "";
if (wide) maxLen *= 2;
if (packet->length > startLoc) {
uint32_t i = 0;
while (packet->data[startLoc + i] != '\0' && packet->length > (uint32_t)(startLoc + i) && maxLen > i) {
readString.push_back(packet->data[startLoc + i]);
if (wide) {
i += 2; // Wide-char string
} else {
i++; // Regular string
}
}
}
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.

25
dNet/PacketUtils.h
View File

@ -1,33 +1,12 @@
#ifndef PACKETUTILS_H #ifndef PACKETUTILS_H
#define PACKETUTILS_H #define PACKETUTILS_H
#include <MessageIdentifiers.h>
#include <BitStream.h>
#include <string> #include <string>
#include <cstdint>
#include "RakNetTypes.h"
enum class eConnectionType : uint16_t;
namespace PacketUtils { namespace PacketUtils {
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);
}
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);
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);
}; };

32
dNet/WorldPackets.cpp
View File

@ -1,7 +1,7 @@
#include "dCommonVars.h" #include "dCommonVars.h"
#include "WorldPackets.h" #include "WorldPackets.h"
#include "BitStream.h" #include "BitStream.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "GeneralUtils.h" #include "GeneralUtils.h"
#include "User.h" #include "User.h"
#include "Character.h" #include "Character.h"
@ -17,7 +17,7 @@
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 +41,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 +51,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 +90,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 +122,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 +198,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 +206,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 +222,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));

28
dNet/ZoneInstanceManager.cpp
View File

@ -3,7 +3,7 @@
// Custom Classes // Custom Classes
#include "MasterPackets.h" #include "MasterPackets.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "dServer.h" #include "dServer.h"
// C++ // C++
@ -26,19 +26,29 @@ void ZoneInstanceManager::RequestZoneTransfer(dServer* server, uint32_t zoneID,
//! Handles a zone transfer response //! Handles a zone transfer response
void ZoneInstanceManager::HandleRequestZoneTransferResponse(uint64_t requestID, Packet* packet) { void ZoneInstanceManager::HandleRequestZoneTransferResponse(uint64_t requestID, Packet* packet) {
CINSTREAM_SKIP_HEADER;
bool mythranShift = static_cast<bool>(packet->data[16]); uint64_t requestIDAgain;
uint32_t zoneID = PacketUtils::ReadPacketU32(17, packet); inStream.Read(requestIDAgain);
uint32_t zoneInstance = PacketUtils::ReadPacketU32(21, packet); bool mythranShift;
uint32_t zoneClone = PacketUtils::ReadPacketU32(25, packet); uint8_t tmp;
uint16_t serverPort = PacketUtils::ReadPacketU16(29, packet); inStream.Read(tmp);
std::string serverIP = PacketUtils::ReadString(31, packet, false); mythranShift = tmp > 0;
uint32_t zoneID;
inStream.Read(zoneID);
uint32_t zoneInstance;
inStream.Read(zoneInstance);
uint32_t zoneClone;
inStream.Read(zoneClone);
uint16_t serverPort;
inStream.Read(serverPort);
LUString serverIP(255);
inStream.Read(serverIP);
for (uint32_t i = 0; i < this->requests.size(); ++i) { for (uint32_t i = 0; i < this->requests.size(); ++i) {
if (this->requests[i]->requestID == requestID) { if (this->requests[i]->requestID == requestID) {
// Call the request callback // Call the request callback
this->requests[i]->callback(mythranShift, zoneID, zoneInstance, zoneClone, serverIP, serverPort); this->requests[i]->callback(mythranShift, zoneID, zoneInstance, zoneClone, serverIP.string, serverPort);
delete this->requests[i]; delete this->requests[i];
this->requests.erase(this->requests.begin() + i); this->requests.erase(this->requests.begin() + i);

9
dNet/dServer.cpp
View File

@ -10,7 +10,7 @@
#include "eServerMessageType.h" #include "eServerMessageType.h"
#include "eMasterMessageType.h" #include "eMasterMessageType.h"
#include "PacketUtils.h" #include "BitstreamUtils.h"
#include "MasterPackets.h" #include "MasterPackets.h"
#include "ZoneInstanceManager.h" #include "ZoneInstanceManager.h"
@ -123,7 +123,9 @@ 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); CINSTREAM_SKIP_HEADER;
uint64_t requestID;
inStream.Read(requestID);
ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
break; break;
} }
@ -167,8 +169,9 @@ void dServer::SendToMaster(RakNet::BitStream* bitStream) {
} }
void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) { void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) {
Game::logger->Log("dServer", "Disconnecting reason: %i", 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);

8
dNet/dServer.h
View File

@ -15,6 +15,14 @@ enum class ServerType : uint32_t {
World World
}; };
enum class ServiceId : uint32_t{
General = 0,
Auth = 1,
Chat = 2,
World = 4,
Client = 5,
};
class dServer { class dServer {
public: public:
// Default constructor should only used for testing! // Default constructor should only used for testing!

156
dWorldServer/WorldServer.cpp
View File

@ -256,56 +256,57 @@ int main(int argc, char** argv) {
Game::entityManager = new EntityManager(); Game::entityManager = new EntityManager();
Game::zoneManager = new dZoneManager(); Game::zoneManager = new dZoneManager();
//Load our level: //Load our level:
if (zoneID != 0) { if (zoneID != 0) {
dpWorld::Instance().Initialize(zoneID); dpWorld::Instance().Initialize(zoneID);
Game::zoneManager->Initialize(LWOZONEID(zoneID, instanceID, cloneID)); Game::zoneManager->Initialize(LWOZONEID(zoneID, instanceID, cloneID));
g_CloneID = cloneID; g_CloneID = cloneID;
// pre calculate the FDB checksum
if (Game::config->GetValue("check_fdb") == "1") {
std::ifstream fileStream;
static const std::vector<std::string> aliases = {
"CDServers.fdb",
"cdserver.fdb",
"CDClient.fdb",
"cdclient.fdb",
};
for (const auto& file : aliases) {
fileStream.open(Game::assetManager->GetResPath() / file, std::ios::binary | std::ios::in);
if (fileStream.is_open()) {
break;
}
}
const int32_t bufferSize = 1024;
MD5* md5 = new MD5();
char fileStreamBuffer[1024] = {};
while (!fileStream.eof()) {
memset(fileStreamBuffer, 0, bufferSize);
fileStream.read(fileStreamBuffer, bufferSize);
md5->update(fileStreamBuffer, fileStream.gcount());
}
fileStream.close();
const char* nullTerminateBuffer = "\0";
md5->update(nullTerminateBuffer, 1); // null terminate the data
md5->finalize();
databaseChecksum = md5->hexdigest();
delete md5;
Game::logger->Log("WorldServer", "FDB Checksum calculated as: %s", databaseChecksum.c_str());
}
} else { } else {
Game::entityManager->Initialize(); Game::entityManager->Initialize();
} }
// pre calculate the FDB checksum
if (Game::config->GetValue("check_fdb") == "1") {
std::ifstream fileStream;
static const std::vector<std::string> aliases = {
"CDServers.fdb",
"cdserver.fdb",
"CDClient.fdb",
"cdclient.fdb",
};
for (const auto& file : aliases) {
fileStream.open(Game::assetManager->GetResPath() / file, std::ios::binary | std::ios::in);
if (fileStream.is_open()) {
break;
}
}
const int32_t bufferSize = 1024;
MD5* md5 = new MD5();
char fileStreamBuffer[1024] = {};
while (!fileStream.eof()) {
memset(fileStreamBuffer, 0, bufferSize);
fileStream.read(fileStreamBuffer, bufferSize);
md5->update(fileStreamBuffer, fileStream.gcount());
}
fileStream.close();
const char* nullTerminateBuffer = "\0";
md5->update(nullTerminateBuffer, 1); // null terminate the data
md5->finalize();
databaseChecksum = md5->hexdigest();
delete md5;
Game::logger->Log("WorldServer", "FDB Checksum calculated as: %s", databaseChecksum.c_str());
}
uint32_t currentFrameDelta = highFrameDelta; uint32_t currentFrameDelta = highFrameDelta;
// These values are adjust them selves to the current framerate should it update. // These values are adjust them selves to the current framerate should it update.
uint32_t logFlushTime = 15 * currentFramerate; // 15 seconds in frames uint32_t logFlushTime = 15 * currentFramerate; // 15 seconds in frames
@ -707,7 +708,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);
} }
@ -719,7 +720,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);
@ -735,14 +736,19 @@ 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); CINSTREAM_SKIP_HEADER;
uint32_t objectID = PacketUtils::ReadPacketU32(16, packet); uint64_t requestID;
inStream.Read(requestID);
uint32_t objectID;
inStream.Read(objectID);
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); CINSTREAM_SKIP_HEADER;
uint64_t requestID;
inStream.Read(requestID);
ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet); ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
break; break;
} }
@ -752,13 +758,13 @@ void HandlePacket(Packet* packet) {
RakNet::BitStream inStream(packet->data, packet->length, false); RakNet::BitStream inStream(packet->data, packet->length, false);
uint64_t header = inStream.Read(header); uint64_t header = inStream.Read(header);
uint32_t sessionKey = 0; uint32_t sessionKey = 0;
std::string username; LUString username(64);
inStream.Read(sessionKey); inStream.Read(sessionKey);
username = PacketUtils::ReadString(12, packet, false); inStream.Read(username);
//Find them: //Find them:
auto it = m_PendingUsers.find(username); auto it = m_PendingUsers.find(username.string);
if (it == m_PendingUsers.end()) return; if (it == m_PendingUsers.end()) return;
//Convert our key: //Convert our key:
@ -771,12 +777,12 @@ void HandlePacket(Packet* packet) {
Game::server->Disconnect(it->second.sysAddr, eServerDisconnectIdentifiers::INVALID_SESSION_KEY); Game::server->Disconnect(it->second.sysAddr, eServerDisconnectIdentifiers::INVALID_SESSION_KEY);
return; return;
} else { } else {
Game::logger->Log("WorldServer", "User %s authenticated with correct key.", username.c_str()); Game::logger->Log("WorldServer", "User %s authenticated with correct key.", username.string.c_str());
UserManager::Instance()->DeleteUser(packet->systemAddress); UserManager::Instance()->DeleteUser(packet->systemAddress);
//Create our user and send them in: //Create our user and send them in:
UserManager::Instance()->CreateUser(it->second.sysAddr, username, userHash); UserManager::Instance()->CreateUser(it->second.sysAddr, username.string, userHash);
auto zone = Game::zoneManager->GetZone(); auto zone = Game::zoneManager->GetZone();
if (zone) { if (zone) {
@ -799,12 +805,12 @@ void HandlePacket(Packet* packet) {
UserManager::Instance()->RequestCharacterList(it->second.sysAddr); UserManager::Instance()->RequestCharacterList(it->second.sysAddr);
} }
m_PendingUsers.erase(username); m_PendingUsers.erase(username.string);
//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);
@ -814,13 +820,14 @@ void HandlePacket(Packet* packet) {
break; break;
} }
case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: { case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: {
const uint64_t requestID = PacketUtils::ReadPacketU64(8, packet); CINSTREAM_SKIP_HEADER;
uint64_t requestID;
inStream.Read(requestID);
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);
@ -875,18 +882,19 @@ void HandlePacket(Packet* packet) {
switch (static_cast<eWorldMessageType>(packet->data[3])) { switch (static_cast<eWorldMessageType>(packet->data[3])) {
case eWorldMessageType::VALIDATION: { case eWorldMessageType::VALIDATION: {
std::string username = PacketUtils::ReadString(0x08, packet, true); CINSTREAM_SKIP_HEADER;
std::string sessionKey = PacketUtils::ReadString(74, packet, true); LUWString username(33);
std::string clientDatabaseChecksum = PacketUtils::ReadString(packet->length - 33, packet, false); inStream.Read(username);
LUWString sessionKey(33);
// sometimes client puts a null terminator at the end of the checksum and sometimes doesn't, weird inStream.Read(sessionKey);
clientDatabaseChecksum = clientDatabaseChecksum.substr(0, 32); LUString clientDatabaseChecksum(32);
inStream.Read(clientDatabaseChecksum);
// If the check is turned on, validate the client's database checksum. // If the check is turned on, validate the client's database checksum.
if (Game::config->GetValue("check_fdb") == "1" && !databaseChecksum.empty()) { if (Game::config->GetValue("check_fdb") == "1" && !databaseChecksum.empty()) {
uint32_t gmLevel = 0; uint32_t gmLevel = 0;
auto* stmt = Database::CreatePreppedStmt("SELECT gm_level FROM accounts WHERE name=? LIMIT 1;"); auto* stmt = Database::CreatePreppedStmt("SELECT gm_level FROM accounts WHERE name=? LIMIT 1;");
stmt->setString(1, username.c_str()); stmt->setString(1, username.GetAsString().c_str());
auto* res = stmt->executeQuery(); auto* res = stmt->executeQuery();
while (res->next()) { while (res->next()) {
@ -897,24 +905,24 @@ void HandlePacket(Packet* packet) {
delete res; delete res;
// Developers may skip this check // Developers may skip this check
if (gmLevel < 8 && clientDatabaseChecksum != databaseChecksum) { if (clientDatabaseChecksum.string != databaseChecksum) {
Game::logger->Log("WorldServer", "Client's database checksum does not match the server's, aborting connection."); Game::logger->Log("WorldServer", "Client's database checksum does not match the server's, aborting connection.");
Game::server->Disconnect(packet->systemAddress, eServerDisconnectIdentifiers::WRONG_GAME_VERSION); Game::server->Disconnect(packet->systemAddress, eServerDisconnectIdentifiers::WRONG_GAME_VERSION);
return; return;
} } else Game::logger->Log("WorldServer", "checksum was good");
} }
//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(username);
Game::server->SendToMaster(&bitStream); Game::server->SendToMaster(&bitStream);
//Insert info into our pending list //Insert info into our pending list
tempSessionInfo info; tempSessionInfo info;
info.sysAddr = SystemAddress(packet->systemAddress); info.sysAddr = SystemAddress(packet->systemAddress);
info.hash = sessionKey; info.hash = sessionKey.GetAsString();
m_PendingUsers.insert(std::make_pair(username, info)); m_PendingUsers.insert(std::make_pair(username.GetAsString(), info));
break; break;
} }
@ -980,7 +988,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);
} }
@ -1129,7 +1137,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);
@ -1170,7 +1178,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++) {
@ -1221,7 +1229,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;
@ -1347,6 +1355,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);
}