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

chore: convert all auth packets to LUBitStreams

Browse Source 
Split things out to their correct files as well
This commit is contained in:
Aaron Kimbrell
2025-09-10 23:04:55 -05:00
parent 824d563fd2
commit e854d6f56a
17 changed files with 476 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
dAuthServer/AuthServer.cpp
View File

@@ -20,6 +20,7 @@
//Auth includes: //Auth includes:
#include "AuthPackets.h" #include "AuthPackets.h"
#include "CommonPackets.h"
#include "ServiceType.h" #include "ServiceType.h"
#include "MessageType/Server.h" #include "MessageType/Server.h"
#include "MessageType/Auth.h" #include "MessageType/Auth.h"
@@ -166,15 +167,14 @@ int main(int argc, char** argv) {
void HandlePacket(Packet* packet) { void HandlePacket(Packet* packet) {
if (packet->length < 4) return; if (packet->length < 4) return;
if (packet->data[0] == ID_USER_PACKET_ENUM) { CINSTREAM;
if (static_cast<ServiceType>(packet->data[1]) == ServiceType::COMMON) { LUBitStream luBitStream;
if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) { if (!luBitStream.ReadHeader(inStream)) return;
AuthPackets::HandleHandshake(Game::server, packet); LOG_DEBUG("got packet for service %i", luBitStream.connectionType);
}
} else if (static_cast<ServiceType>(packet->data[1]) == ServiceType::AUTH) { if (luBitStream.connectionType == ServiceType::COMMON) {
if (static_cast<MessageType::Auth>(packet->data[3]) == MessageType::Auth::LOGIN_REQUEST) { CommonPackets::Handle(inStream, packet->systemAddress);
AuthPackets::HandleLoginRequest(Game::server, packet); } else if (luBitStream.connectionType == ServiceType::AUTH) {
} AuthPackets::Handle(inStream, packet->systemAddress);
}
} }
} }

24
dCommon/dEnums/eLoginResponse.h
View File

@@ -1,24 +0,0 @@
#ifndef __ELOGINRESPONSE__H__
#define __ELOGINRESPONSE__H__
#include <cstdint>
enum class eLoginResponse : uint8_t {
GENERAL_FAILED = 0,
SUCCESS,
BANNED,
// Unused 3
// Unused 4
PERMISSIONS_NOT_HIGH_ENOUGH = 5,
INVALID_USER,
ACCOUNT_LOCKED,
WRONG_PASS,
ACCOUNT_ACTIVATION_PENDING,
ACCOUNT_DISABLED,
GAME_TIME_EXPIRED,
FREE_TRIAL_ENDED,
PLAY_SCHEDULE_TIME_UP,
ACCOUNT_NOT_ACTIVATED
};
#endif //!__ELOGINRESPONSE__H__

24
dCommon/dEnums/eServerDisconnectIdentifiers.h
View File

@@ -1,24 +0,0 @@
#ifndef __ESERVERDISCONNECTIDENTIFIERS__H__
#define __ESERVERDISCONNECTIDENTIFIERS__H__
#include <cstdint>
enum class eServerDisconnectIdentifiers : uint32_t {
UNKNOWN_SERVER_ERROR = 0,
WRONG_GAME_VERSION,
WRONG_SERVER_VERSION,
CONNECTION_ON_INVALID_PORT,
DUPLICATE_LOGIN,
SERVER_SHUTDOWN,
SERVER_MAP_LOAD_FAILURE,
INVALID_SESSION_KEY,
ACCOUNT_NOT_IN_PENDING_LIST,
CHARACTER_NOT_FOUND,
CHARACTER_CORRUPTED,
KICK,
SAVE_FAILURE,
FREE_TRIAL_EXPIRED,
PLAY_SCHEDULE_TIME_DONE
};
#endif //!__ESERVERDISCONNECTIDENTIFIERS__H__

7
dGame/User.cpp
View File

@@ -5,8 +5,8 @@
#include "Logger.h" #include "Logger.h"
#include "Game.h" #include "Game.h"
#include "dZoneManager.h" #include "dZoneManager.h"
#include "eServerDisconnectIdentifiers.h"
#include "eGameMasterLevel.h" #include "eGameMasterLevel.h"
#include "CommonPackets.h"
User::User(const SystemAddress& sysAddr, const std::string& username, const std::string& sessionKey) { User::User(const SystemAddress& sysAddr, const std::string& username, const std::string& sessionKey) {
m_AccountID = 0; m_AccountID = 0;
@@ -108,7 +108,10 @@ void User::UserOutOfSync() {
if (m_AmountOfTimesOutOfSync > m_MaxDesyncAllowed) { if (m_AmountOfTimesOutOfSync > m_MaxDesyncAllowed) {
//YEET //YEET
LOG("User %s was out of sync %i times out of %i, disconnecting for suspected speedhacking.", m_Username.c_str(), m_AmountOfTimesOutOfSync, m_MaxDesyncAllowed); LOG("User %s was out of sync %i times out of %i, disconnecting for suspected speedhacking.", m_Username.c_str(), m_AmountOfTimesOutOfSync, m_MaxDesyncAllowed);
Game::server->Disconnect(this->m_SystemAddress, eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE;
notification.Send(this->m_SystemAddress);
Game::server->Disconnect(this->m_SystemAddress);
} }
} }

1
dGame/dUtilities/Mail.h
View File

@@ -105,7 +105,6 @@ namespace Mail {
struct MailLUBitStream : public LUBitStream { struct MailLUBitStream : public LUBitStream {
eMessageID messageID = eMessageID::UnknownError; eMessageID messageID = eMessageID::UnknownError;
SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
Entity* player = nullptr; Entity* player = nullptr;
MailLUBitStream() = default; MailLUBitStream() = default;

13
dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp
View File

@@ -3,6 +3,7 @@
// Classes // Classes
#include "Character.h" #include "Character.h"
#include "ChatPackets.h" #include "ChatPackets.h"
#include "CommonPackets.h"
#include "dServer.h" #include "dServer.h"
#include "PlayerManager.h" #include "PlayerManager.h"
#include "User.h" #include "User.h"
@@ -16,7 +17,6 @@
// Enums // Enums
#include "MessageType/Chat.h" #include "MessageType/Chat.h"
#include "eServerDisconnectIdentifiers.h"
#include "eObjectBits.h" #include "eObjectBits.h"
namespace GMGreaterThanZeroCommands { namespace GMGreaterThanZeroCommands {
@@ -31,8 +31,10 @@ namespace GMGreaterThanZeroCommands {
ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + username); ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + username);
return; return;
} }
CommonPackets::DisconnectNotify notification;
Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::KICK); notification.disconnectID = eServerDisconnectIdentifiers::KICK;
notification.Send(player->GetSystemAddress());
Game::server->Disconnect(player->GetSystemAddress());
ChatPackets::SendSystemMessage(sysAddr, u"Kicked: " + username); ChatPackets::SendSystemMessage(sysAddr, u"Kicked: " + username);
} else { } else {
@@ -69,7 +71,10 @@ namespace GMGreaterThanZeroCommands {
if (accountId != 0) Database::Get()->UpdateAccountBan(accountId, true); if (accountId != 0) Database::Get()->UpdateAccountBan(accountId, true);
if (player != nullptr) { if (player != nullptr) {
Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::FREE_TRIAL_EXPIRED); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::FREE_TRIAL_EXPIRED;
notification.Send(player->GetSystemAddress());
Game::server->Disconnect(player->GetSystemAddress());
} }
ChatPackets::SendSystemMessage(sysAddr, u"Banned: " + GeneralUtils::ASCIIToUTF16(splitArgs[0])); ChatPackets::SendSystemMessage(sysAddr, u"Banned: " + GeneralUtils::ASCIIToUTF16(splitArgs[0]));

377
dNet/AuthPackets.cpp
View File

@@ -17,84 +17,25 @@
#include "Game.h" #include "Game.h"
#include "dConfig.h" #include "dConfig.h"
#include "eServerDisconnectIdentifiers.h"
#include "eLoginResponse.h"
#include "ServiceType.h" #include "ServiceType.h"
#include "MessageType/Server.h" #include "MessageType/Server.h"
#include "MessageType/Master.h" #include "MessageType/Master.h"
#include "eGameMasterLevel.h" #include "eGameMasterLevel.h"
#include "StringifiedEnum.h" #include "StringifiedEnum.h"
#include "CommonPackets.h"
#include "ClientPackets.h"
namespace { namespace {
std::vector<uint32_t> claimCodes; std::vector<uint32_t> claimCodes;
} }
void Stamp::Serialize(RakNet::BitStream& outBitStream) {
outBitStream.Write(type);
outBitStream.Write(value);
outBitStream.Write(timestamp);
};
namespace AuthPackets { namespace AuthPackets {
std::map<eMessageID, std::function<std::unique_ptr<AuthLUBitStream>()>> g_Handlers = { std::map<MessageType::Auth, std::function<std::unique_ptr<LUBitStream>()>> g_Handlers = {
{eMessageID::HandshakeRequest, []() { {MessageType::Auth::LOGIN_REQUEST, []() {
return std::make_unique<HandshakeRequest>();
}},
{eMessageID::LoginRequest, []() {
return std::make_unique<LoginRequest>(); return std::make_unique<LoginRequest>();
}}, }}
}; };
void AuthLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(messageID);
}
bool AuthLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
VALIDATE_READ(bitstream.Read(messageID));
return true;
}
bool HandshakeRequest::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(clientVersion));
bitStream.IgnoreBytes(4);
VALIDATE_READ(bitStream.Read(serviceType));
if (serviceType != ServiceType::CLIENT) LOG("WARNING: Service is not a Client!");
bitStream.IgnoreBytes(2);
VALIDATE_READ(bitStream.Read(processID));
VALIDATE_READ(bitStream.Read(port));
if (port != sysAddr.port) LOG("WARNING: Port written in packet does not match the port the client is connecting over!");
bitStream.IgnoreBytes(33);
return true;
}
void HandshakeRequest::Handle() {
LOG_DEBUG("Client Data [Version: %i, Service: %s, Process: %u, Port: %u, Sysaddr Port: %u]",
clientVersion, StringifiedEnum::ToString(serviceType).data(), processID, port, sysAddr.port);
HandshakeResponse response(server->GetIP(), server->GetPort(), server->GetServerType());
response.server = server;
response.Send(sysAddr);
}
void HandshakeResponse::Serialize(RakNet::BitStream& bitStream) const {
BitStreamUtils::WriteHeader(bitStream, ServiceType::COMMON, MessageType::Server::VERSION_CONFIRM);
const auto& clientNetVersionString = Game::config->GetValue("client_net_version");
const uint32_t clientNetVersion = GeneralUtils::TryParse<uint32_t>(clientNetVersionString).value_or(171022);
bitStream.Write<uint32_t>(clientNetVersion);
bitStream.Write<uint32_t>(861228100);
bitStream.Write(static_cast<uint32_t>(serverType));
bitStream.Write<uint64_t>(219818307120);
}
std::string CleanReceivedString(const std::string& str) {
std::string toReturn = str;
const auto removed = std::ranges::find_if(toReturn, [](unsigned char c) { return isprint(c) == 0 && isblank(c) == 0; });
toReturn.erase(removed, toReturn.end());
return toReturn;
}
bool LoginRequest::Deserialize(RakNet::BitStream& bitStream) { bool LoginRequest::Deserialize(RakNet::BitStream& bitStream) {
LUWString usernameLUString; LUWString usernameLUString;
VALIDATE_READ(bitStream.Read(usernameLUString)); VALIDATE_READ(bitStream.Read(usernameLUString));
@@ -103,64 +44,86 @@ namespace AuthPackets {
LUWString passwordLUString(41); LUWString passwordLUString(41);
VALIDATE_READ(bitStream.Read(passwordLUString)); VALIDATE_READ(bitStream.Read(passwordLUString));
password = passwordLUString.GetAsString(); password = passwordLUString.GetAsString();
VALIDATE_READ(bitStream.Read(locale_id)); VALIDATE_READ(bitStream.Read(locale_id));
LOG_DEBUG("Locale ID: %s", StringifiedEnum::ToString(locale_id).data());
VALIDATE_READ(bitStream.Read(clientOS)); VALIDATE_READ(bitStream.Read(clientOS));
LOG_DEBUG("Operating System: %s", StringifiedEnum::ToString(clientOS).data());
LUWString memoryStatsLU(256); LUWString memoryStatsLU(256);
VALIDATE_READ(bitStream.Read(memoryStatsLU)); VALIDATE_READ(bitStream.Read(memoryStatsLU));
computerInfo.memoryStats = CleanReceivedString(memoryStatsLU.GetAsString()); computerInfo.memoryStats = memoryStatsLU.GetAsString();
LOG_DEBUG("Memory Stats [%s]", computerInfo.memoryStats.c_str());
LUWString videoCardLU(128); LUWString videoCardLU(128);
VALIDATE_READ(bitStream.Read(videoCardLU)); VALIDATE_READ(bitStream.Read(videoCardLU));
computerInfo.videoCard = CleanReceivedString(videoCardLU.GetAsString()); computerInfo.videoCard = videoCardLU.GetAsString();
LOG_DEBUG("VideoCard Info: [%s]", computerInfo.videoCard.c_str());
// Processor/CPU info // Processor/CPU info
VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.count)); VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.count));
VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.type)); VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.type));
VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.level)); VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.level));
VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.revision)); VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.revision));
LOG_DEBUG("CPU Info: [#Processors: %i, Processor Type: %s, Processor Level: %s, Processor Revision: %s]",
computerInfo.processorInfo.count,
StringifiedEnum::ToString(computerInfo.processorInfo.type).data(),
StringifiedEnum::ToString(computerInfo.processorInfo.level).data(),
StringifiedEnum::ToString(computerInfo.processorInfo.revision).data()
);
// OS Info // OS Info
VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.infoSize)); VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.infoSize));
VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.version)); VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.majorVersion));
VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.minorVersion));
VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.buildNumber)); VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.buildNumber));
VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.platformID)); VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.platformID));
LOG_DEBUG("OS Info: [Size: %i, Version: %s, Buid#: %s, platformID: %s]",
computerInfo.osVersionInfo.infoSize,
StringifiedEnum::ToString(computerInfo.osVersionInfo.version).data(),
StringifiedEnum::ToString(computerInfo.osVersionInfo.buildNumber).data(),
StringifiedEnum::ToString(computerInfo.osVersionInfo.platformID).data()
);
return true; return true;
} }
void LoginRequest::Handle() { void LoginRequest::Handle() {
std::vector<Stamp> stamps; LOG_DEBUG("Login Request from %s", username.c_str());
stamps.emplace_back(eStamps::PASSPORT_AUTH_START, 0); LOG_DEBUG("Password: %s", password.c_str());
stamps.emplace_back(eStamps::PASSPORT_AUTH_CLIENT_OS, 0);
LOG_DEBUG("Locale ID: %s", StringifiedEnum::ToString(locale_id).data());
LOG_DEBUG("Operating System: %s", StringifiedEnum::ToString(clientOS).data());
LOG_DEBUG("Memory Stats [%s]", computerInfo.memoryStats.c_str());
LOG_DEBUG("VideoCard Info: [%s]", computerInfo.videoCard.c_str());
LOG_DEBUG("CPU Info: [#Processors: %i, Processor Type: %i, Processor Level: %i, Processor Revision: %i]",
computerInfo.processorInfo.count,
computerInfo.processorInfo.type,
computerInfo.processorInfo.level,
computerInfo.processorInfo.revision
);
LOG_DEBUG("OS Info: [Size: %i, Version: %i.%i, Buid#: %i, platformID: %i]",
computerInfo.osVersionInfo.infoSize,
computerInfo.osVersionInfo.majorVersion,
computerInfo.osVersionInfo.minorVersion,
computerInfo.osVersionInfo.buildNumber,
computerInfo.osVersionInfo.platformID
);
ClientPackets::LoginResponse response;
response.sysAddr = this->sysAddr;
response.stamps.emplace_back(eStamps::PASSPORT_AUTH_START, 0);
response.stamps.emplace_back(eStamps::PASSPORT_AUTH_CLIENT_OS, 0);
response.events.push_back(LUString(Game::config->GetValue("event_1")));
response.events.push_back(LUString(Game::config->GetValue("event_2")));
response.events.push_back(LUString(Game::config->GetValue("event_3")));
response.events.push_back(LUString(Game::config->GetValue("event_4")));
response.events.push_back(LUString(Game::config->GetValue("event_5")));
response.events.push_back(LUString(Game::config->GetValue("event_6")));
response.events.push_back(LUString(Game::config->GetValue("event_7")));
response.events.push_back(LUString(Game::config->GetValue("event_8")));
response.version_major = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_major")).value_or(ClientVersion::major);
response.version_current = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_current")).value_or(ClientVersion::current);
response.version_minor = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_minor")).value_or(ClientVersion::minor);
uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
std::string userHash = std::to_string(sessionKey);
response.userKey = md5(userHash);
// Fetch account details // Fetch account details
auto accountInfo = Database::Get()->GetAccountInfo(username); auto accountInfo = Database::Get()->GetAccountInfo(username);
if (!accountInfo) { if (!accountInfo) {
LOG("No user by name %s found!", username.c_str()); LOG("No user by name %s found!", username.c_str());
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::INVALID_USER, "", "", 2001, username, stamps);
response.server = server;
response.Send(sysAddr); response.Send(sysAddr);
return; return;
} }
@@ -168,9 +131,7 @@ namespace AuthPackets {
//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)) && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) { if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
stamps.emplace_back(eStamps::GM_REQUIRED, 1); response.stamps.emplace_back(eStamps::GM_REQUIRED, 1);
LoginResponse response(eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username, stamps);
response.server = server;
response.Send(sysAddr); response.Send(sysAddr);
return; return;
} }
@@ -178,9 +139,9 @@ namespace AuthPackets {
if (Game::config->GetValue("dont_use_keys") != "1" && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) { if (Game::config->GetValue("dont_use_keys") != "1" && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
//Check to see if we have a play key: //Check to see if we have a play key:
if (accountInfo->playKeyId == 0) { if (accountInfo->playKeyId == 0) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username, stamps); response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
response.server = server; response.errorMessage = "Your account doesn't have a play key associated with it!";
response.Send(sysAddr); response.Send(sysAddr);
LOG("User %s tried to log in, but they don't have a play key.", username.c_str()); LOG("User %s tried to log in, but they don't have a play key.", username.c_str());
return; return;
@@ -190,37 +151,37 @@ namespace AuthPackets {
auto playKeyStatus = Database::Get()->IsPlaykeyActive(accountInfo->playKeyId); auto playKeyStatus = Database::Get()->IsPlaykeyActive(accountInfo->playKeyId);
if (!playKeyStatus) { if (!playKeyStatus) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a valid play key associated with it!", "", 2001, username, stamps); response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
response.server = server; response.errorMessage = "Your account doesn't have a valid play key associated with it!";
response.Send(sysAddr); response.Send(sysAddr);
return; return;
} }
if (!playKeyStatus.value()) { if (!playKeyStatus.value()) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username, stamps); response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
response.server = server; response.errorMessage = "Your play key has been disabled.";
response.Send(sysAddr); response.Send(sysAddr);
LOG("User %s tried to log in, but their play key was disabled", username.c_str()); LOG("User %s tried to log in, but their play key was disabled", username.c_str());
return; return;
} }
} else if (Game::config->GetValue("dont_use_keys") == "1" || accountInfo->maxGmLevel > eGameMasterLevel::CIVILIAN) { } else if (Game::config->GetValue("dont_use_keys") == "1" || accountInfo->maxGmLevel > eGameMasterLevel::CIVILIAN) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_BYPASS, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_BYPASS, 1);
} }
if (accountInfo->banned) { if (accountInfo->banned) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::BANNED, "", "", 2001, username, stamps); response.responseCode = eLoginResponse::BANNED;
response.server = server; response.errorMessage = "Your account has been banned.";
response.Send(sysAddr); response.Send(sysAddr);
return; return;
} }
if (accountInfo->locked) { if (accountInfo->locked) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, username, stamps); response.responseCode = eLoginResponse::ACCOUNT_LOCKED;
response.server = server; response.errorMessage = "Your account is locked.";
response.Send(sysAddr); response.Send(sysAddr);
return; return;
} }
@@ -228,189 +189,61 @@ namespace AuthPackets {
bool loginSuccess = ::bcrypt_checkpw(password.c_str(), accountInfo->bcryptPassword.c_str()) == 0; bool loginSuccess = ::bcrypt_checkpw(password.c_str(), accountInfo->bcryptPassword.c_str()) == 0;
if (!loginSuccess) { if (!loginSuccess) {
stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1); response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
LoginResponse response(eLoginResponse::WRONG_PASS, "", "", 2001, username, stamps); response.responseCode = eLoginResponse::WRONG_PASS;
response.server = server;
response.Send(sysAddr); response.Send(sysAddr);
LOG("Wrong password used");
} else { } else {
SystemAddress system = sysAddr; //Copy the sysAddr ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, 0, 0, false, [this, response, sessionKey](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) mutable {
auto serverPtr = server; response.responseCode = eLoginResponse::SUCCESS;
auto usernameCopy = username; response.worldServerIP = LUString(zoneIP);
ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, serverPtr, usernameCopy, stamps](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) mutable { response.worldServerPort = zonePort;
LoginResponse response(eLoginResponse::SUCCESS, "", zoneIP, zonePort, usernameCopy, stamps); response.Send();
response.server = serverPtr;
response.Send(system); CBITSTREAM;
return; BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::SET_SESSION_KEY);
} bitStream.Write(sessionKey);
); LOG_DEBUG("Sending session key for %s to master server", this->username.c_str());
bitStream.Write(LUString(this->username));
Game::server->SendToMaster(bitStream);
});
for (auto const code : claimCodes) { for (auto const code : claimCodes) {
Database::Get()->InsertRewardCode(accountInfo->id, code); Database::Get()->InsertRewardCode(accountInfo->id, code);
} }
} }
} }
}
void LoginResponse::Serialize(RakNet::BitStream& bitStream) const { // Non Stuct Functions
std::vector<Stamp> mutableStamps = stamps; void AuthPackets::LoadClaimCodes() {
mutableStamps.emplace_back(eStamps::PASSPORT_AUTH_IM_LOGIN_START, 1); if (!claimCodes.empty()) return;
auto rcstring = Game::config->GetValue("rewardcodes");
auto codestrings = GeneralUtils::SplitString(rcstring, ',');
for (auto const& codestring : codestrings) {
const auto code = GeneralUtils::TryParse<uint32_t>(codestring);
BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::LOGIN_RESPONSE); if (code && code.value() != -1) claimCodes.push_back(code.value());
bitStream.Write(responseCode);
// Event Gating
bitStream.Write(LUString(Game::config->GetValue("event_1")));
bitStream.Write(LUString(Game::config->GetValue("event_2")));
bitStream.Write(LUString(Game::config->GetValue("event_3")));
bitStream.Write(LUString(Game::config->GetValue("event_4")));
bitStream.Write(LUString(Game::config->GetValue("event_5")));
bitStream.Write(LUString(Game::config->GetValue("event_6")));
bitStream.Write(LUString(Game::config->GetValue("event_7")));
bitStream.Write(LUString(Game::config->GetValue("event_8")));
const uint16_t version_major =
GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_major")).value_or(ClientVersion::major);
const uint16_t version_current =
GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_current")).value_or(ClientVersion::current);
const uint16_t version_minor =
GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_minor")).value_or(ClientVersion::minor);
bitStream.Write(version_major);
bitStream.Write(version_current);
bitStream.Write(version_minor);
// Writes the user key
uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
std::string userHash = std::to_string(sessionKey);
userHash = md5(userHash);
bitStream.Write(LUWString(userHash));
// World Server IP
bitStream.Write(LUString(wServerIP));
// Chat Server IP (unused)
bitStream.Write(LUString(""));
// World Server Redirect port
bitStream.Write(wServerPort);
// Char Server Redirect port (unused)
bitStream.Write(static_cast<uint16_t>(0));
// CDN Key
bitStream.Write(LUString(""));
// CDN Ticket
bitStream.Write(LUString("00000000-0000-0000-0000-000000000000", 37));
// Language
bitStream.Write(Language::en_US);
// Write the localization
bitStream.Write(LUString("US", 3));
bitStream.Write<uint8_t>(false); // Just upgraded from F2P
bitStream.Write<uint8_t>(false); // User is F2P
bitStream.Write<uint64_t>(0); // Time Remaining in F2P
// Write custom error message
bitStream.Write<uint16_t>(errorMsg.length());
bitStream.Write(LUWString(errorMsg, static_cast<uint32_t>(errorMsg.length())));
mutableStamps.emplace_back(eStamps::PASSPORT_AUTH_WORLD_COMMUNICATION_FINISH, 1);
bitStream.Write<uint32_t>((sizeof(Stamp) * mutableStamps.size()) + sizeof(uint32_t));
for (auto& stamp : mutableStamps) stamp.Serialize(bitStream);
//Inform the master server that we've created a session for this user:
if (responseCode == eLoginResponse::SUCCESS && server) {
uint32_t masterSessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
RakNet::BitStream masterBitStream;
BitStreamUtils::WriteHeader(masterBitStream, ServiceType::MASTER, MessageType::Master::SET_SESSION_KEY);
masterBitStream.Write(masterSessionKey);
masterBitStream.Write(LUString(username));
server->SendToMaster(masterBitStream);
LOG("Set sessionKey: %i for user %s", masterSessionKey, username.c_str());
}
}
void LoadClaimCodes() {
if(!claimCodes.empty()) return;
auto rcstring = Game::config->GetValue("rewardcodes");
auto codestrings = GeneralUtils::SplitString(rcstring, ',');
for(auto const &codestring: codestrings){
const auto code = GeneralUtils::TryParse<uint32_t>(codestring);
if (code && code.value() != -1) claimCodes.push_back(code.value());
}
} }
} }
// Legacy wrapper functions for backward compatibility // Non Stuct Functions
void AuthPackets::HandleHandshake(dServer* server, Packet* packet) { void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
CINSTREAM_SKIP_HEADER; inStream.ResetReadPointer();
LUBitStream lubitstream;
if (!lubitstream.ReadHeader(inStream)) return;
HandshakeRequest request; auto it = g_Handlers.find(static_cast<MessageType::Auth>(lubitstream.internalPacketID));
request.sysAddr = packet->systemAddress;
request.server = server;
if (request.Deserialize(inStream)) {
request.Handle();
} else {
LOG_DEBUG("Error Reading Handshake Request");
}
}
void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServiceType serverType) {
HandshakeResponse response(nextServerIP, nextServerPort, serverType);
response.server = server;
response.Send(sysAddr);
}
void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
CINSTREAM_SKIP_HEADER;
LoginRequest request;
request.sysAddr = packet->systemAddress;
request.server = server;
if (request.Deserialize(inStream)) {
request.Handle();
} else {
LOG_DEBUG("Error Reading Login Request");
}
}
void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username, std::vector<Stamp>& stamps) {
LoginResponse response(responseCode, errorMsg, wServerIP, wServerPort, username, stamps);
response.server = server;
response.Send(sysAddr);
}
// Non Struct Functions
void AuthPackets::HandleAuth(RakNet::BitStream& inStream, const SystemAddress& sysAddr, dServer* server) {
AuthLUBitStream data;
if (!data.Deserialize(inStream)) {
LOG_DEBUG("Error Reading Auth header");
return;
}
auto it = g_Handlers.find(data.messageID);
if (it != g_Handlers.end()) { if (it != g_Handlers.end()) {
auto request = it->second(); auto request = it->second();
request->sysAddr = sysAddr; request->sysAddr = sysAddr;
request->server = server;
if (!request->Deserialize(inStream)) { if (!request->Deserialize(inStream)) {
LOG_DEBUG("Error Reading Auth Request: %s", StringifiedEnum::ToString(data.messageID).data()); LOG_DEBUG("Error Reading Auth Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Auth>(lubitstream.internalPacketID)).data());
return; return;
} }
LOG("Received auth message %s", StringifiedEnum::ToString(data.messageID).data()); LOG_DEBUG("Received Auth Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Auth>(lubitstream.internalPacketID)).data());
request->Handle(); request->Handle();
} else { } else {
LOG_DEBUG("Unhandled Auth Request with ID: %i", data.messageID); LOG_DEBUG("Unhandled Auth Packet with ID: %i", lubitstream.internalPacketID);
} }
} }

265
dNet/AuthPackets.h
View File

@@ -8,77 +8,12 @@
#include "BitStream.h" #include "BitStream.h"
#include "RakNetTypes.h" #include "RakNetTypes.h"
#include "BitStreamUtils.h" #include "BitStreamUtils.h"
#include <functional> #include "MessageType/Auth.h"
#include <memory>
enum class eLoginResponse : uint8_t; enum class eLoginResponse : uint8_t;
enum class ServiceType : uint16_t; enum class ServiceType : uint16_t;
class dServer; class dServer;
enum class eMessageID : uint32_t {
HandshakeRequest = 0,
HandshakeResponse,
LoginRequest,
LoginResponse,
UnknownError
};
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
};
struct Stamp {
eStamps type;
uint32_t value;
uint64_t timestamp;
Stamp(eStamps type, uint32_t value, uint64_t timestamp = time(nullptr)){
this->type = type;
this->value = value;
this->timestamp = timestamp;
}
void Serialize(RakNet::BitStream& outBitStream);
};
enum class ClientOS : uint8_t { enum class ClientOS : uint8_t {
UNKNOWN, UNKNOWN,
WINDOWS, WINDOWS,
@@ -91,171 +26,15 @@ enum class LanguageCodeID : uint16_t {
en_GB = 0x0809 en_GB = 0x0809
}; };
// For more info on these values, go to this link
// https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info
enum class ProcessorType : uint32_t {
UNKNOWN = 0,
INTEL_386 = 386, // Intel 80386
INTEL_486 = 486, // Intel 80486
PENTIUM = 586, // Intel Pentium
MIPS = 4000, // MIPS R4000
ALPHA = 21064, // Alpha 21064
PPC = 601, // PowerPC 601
SHX = 103, // SuperH SHX
INTEL_IA64 = 2200, // Intel Itanium
AMD_X8664 = 8664, // x64 (AMD or Intel EM64T)
ARM = 448, // ARM (0x01C0 in hex, 448 in decimal)
ARM64 = 43620 // ARM64 (0xAA64 in hex, 43620 in decimal)
};
enum class ProcessorLevel : uint16_t {
INTEL_386 = 3,
INTEL_486 = 4,
PENTIUM = 5,
INTEL_P6 = 6, // Pentium Pro/II/III/4 or later
ITANIUM = 0xA,
X64 = 0xE,
ARM = 0x14,
ARM64 = 0x15,
UNKNOWN = 0xFFFF
};
// ProcessorRevision is typically a 16-bit value, but we can define some common values for reference
// For x86: high byte = model, low byte = stepping
// For other architectures, refer to documentation
enum class ProcessorRevision : uint16_t {
// Intel 80386
INTEL_386_MODEL_0_STEPPING_0 = 0x0000,
INTEL_386_MODEL_0_STEPPING_1 = 0x0001,
// Intel 80486
INTEL_486_MODEL_0_STEPPING_0 = 0x0000,
INTEL_486_MODEL_0_STEPPING_1 = 0x0001,
// Intel Pentium
PENTIUM_MODEL_1_STEPPING_1 = 0x0101,
PENTIUM_MODEL_2_STEPPING_3 = 0x0203,
// Intel Pentium Pro/II/III/4
P6_MODEL_3_STEPPING_3 = 0x0303,
P6_MODEL_5_STEPPING_7 = 0x0507,
// Intel Itanium
ITANIUM_MODEL_1_STEPPING_0 = 0x0100,
// AMD x64
AMD_X64_MODEL_15_STEPPING_65 = 0x0F41,
AMD_X64_MODEL_23_STEPPING_1 = 0x1701,
// Intel x64
INTEL_X64_MODEL_6_STEPPING_10 = 0x060A,
INTEL_X64_MODEL_15_STEPPING_11 = 0x0F0B,
// ARM/ARM64 (values are typically implementation-specific)
ARM_MODEL_0_STEPPING_0 = 0x0000,
ARM64_MODEL_0_STEPPING_0 = 0x0000,
// Unknown
UNKNOWN = 0xFFFF
};
// Windows version enum based on OSVERSIONINFOEXA major/minor values
// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfoexa
enum class WindowsVersion : uint32_t {
UNKNOWN = 0,
WIN_2000 = 0x0500, // Major: 5, Minor: 0
WIN_XP = 0x0501, // Major: 5, Minor: 1
WIN_SERVER_2003 = 0x0502, // Major: 5, Minor: 2
WIN_VISTA = 0x0600, // Major: 6, Minor: 0
WIN_7 = 0x0601, // Major: 6, Minor: 1
WIN_8 = 0x0602, // Major: 6, Minor: 2
WIN_8_1 = 0x0603, // Major: 6, Minor: 3
WIN_10 = 0x0A00, // Major: 10, Minor: 0
WIN_11 = 0x0A00 // Major: 10, Minor: 0 (distinguish by build number)
};
// Windows Platform ID enum based on OSVERSIONINFOEXA documentation
// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfoexa
enum class WindowsPlatformID : uint32_t {
UNKNOWN = 0,
WIN32s = 0, // Windows 3.x
WIN32_WINDOWS = 1, // Windows 95/98/ME
WIN32_NT = 2, // Windows NT and later
WIN32_CE = 3 // Windows CE
};
// Windows Build Number enum (common values)
enum class WindowsBuildNumber : uint32_t {
UNKNOWN = 0,
WIN_2000 = 2195,
WIN_XP = 2600,
WIN_SERVER_2003 = 3790,
WIN_VISTA = 6000,
WIN_7 = 7600,
WIN_7_SP1 = 7601,
WIN_8 = 9200,
WIN_8_1 = 9600,
WIN_10_1507 = 10240,
WIN_10_1511 = 10586,
WIN_10_1607 = 14393,
WIN_10_1703 = 15063,
WIN_10_1709 = 16299,
WIN_10_1803 = 17134,
WIN_10_1809 = 17763,
WIN_10_1903 = 18362,
WIN_10_1909 = 18363,
WIN_10_2004 = 19041,
WIN_10_20H2 = 19042,
WIN_10_21H1 = 19043,
WIN_10_21H2 = 19044,
WIN_10_22H2 = 19045,
WIN_11_21H2 = 22000,
WIN_11_22H2 = 22621,
WIN_11_23H2 = 22631
};
template <> template <>
struct magic_enum::customize::enum_range<LanguageCodeID> { struct magic_enum::customize::enum_range<LanguageCodeID> {
static constexpr int min = 1031; static constexpr int min = 1031;
static constexpr int max = 2057; static constexpr int max = 2057;
}; };
enum class Language : uint32_t {
en_US,
pl_US,
de_DE,
en_GB,
};
namespace AuthPackets { namespace AuthPackets {
struct AuthLUBitStream : public LUBitStream {
eMessageID messageID = eMessageID::UnknownError;
SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
dServer* server = nullptr;
AuthLUBitStream() = default; struct LoginRequest : public LUBitStream {
AuthLUBitStream(eMessageID _messageID) : messageID{_messageID} {};
virtual void Serialize(RakNet::BitStream& bitStream) const override;
virtual bool Deserialize(RakNet::BitStream& bitStream) override;
virtual void Handle() override {};
};
struct HandshakeRequest : public AuthLUBitStream {
uint32_t clientVersion = 0;
ServiceType serviceType;
uint32_t processID = 0;
uint16_t port = 0;
HandshakeRequest() : AuthLUBitStream(eMessageID::HandshakeRequest) {}
bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override;
};
struct HandshakeResponse : public AuthLUBitStream {
std::string nextServerIP;
uint16_t nextServerPort = 0;
ServiceType serverType;
HandshakeResponse() : AuthLUBitStream(eMessageID::HandshakeResponse) {}
HandshakeResponse(const std::string& ip, uint16_t port, ServiceType type)
: AuthLUBitStream(eMessageID::HandshakeResponse), nextServerIP(ip), nextServerPort(port), serverType(type) {}
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct LoginRequest : public AuthLUBitStream {
std::string username; std::string username;
std::string password; std::string password;
LanguageCodeID locale_id; LanguageCodeID locale_id;
@@ -265,46 +44,28 @@ namespace AuthPackets {
std::string videoCard; std::string videoCard;
struct ProcessorInfo { struct ProcessorInfo {
uint32_t count = 0; uint32_t count = 0;
ProcessorType type = ProcessorType::UNKNOWN; uint32_t type = 0;
ProcessorLevel level = ProcessorLevel::UNKNOWN; uint16_t level = 0;
ProcessorRevision revision = ProcessorRevision::UNKNOWN; uint16_t revision = 0;
} processorInfo; } processorInfo;
struct OSVersionInfo { struct OSVersionInfo {
uint32_t infoSize = 0; uint32_t infoSize = 0;
WindowsVersion version = WindowsVersion::UNKNOWN; uint32_t majorVersion = 0;
WindowsBuildNumber buildNumber = WindowsBuildNumber::UNKNOWN; uint32_t minorVersion = 0;
WindowsPlatformID platformID = WindowsPlatformID::UNKNOWN; uint32_t buildNumber = 0;
uint32_t platformID = 0;
} osVersionInfo; } osVersionInfo;
} computerInfo; } computerInfo;
LoginRequest() : AuthLUBitStream(eMessageID::LoginRequest) {} LoginRequest() : LUBitStream(ServiceType::AUTH, MessageType::Auth::LOGIN_REQUEST) {}
bool Deserialize(RakNet::BitStream& bitStream) override; bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override; void Handle() override;
}; };
struct LoginResponse : public AuthLUBitStream { // Non struct functions
eLoginResponse responseCode;
std::string errorMsg;
std::string wServerIP;
uint16_t wServerPort = 0;
std::string username;
std::vector<Stamp> stamps;
LoginResponse() : AuthLUBitStream(eMessageID::LoginResponse) {}
LoginResponse(eLoginResponse code, const std::string& error, const std::string& ip, uint16_t port, const std::string& user, std::vector<Stamp>& s)
: AuthLUBitStream(eMessageID::LoginResponse), responseCode(code), errorMsg(error), wServerIP(ip), wServerPort(port), username(user), stamps(s) {}
void Serialize(RakNet::BitStream& bitStream) const override;
};
// Legacy function signatures maintained for backward compatibility
void HandleHandshake(dServer* server, Packet* packet);
void SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServiceType serverType);
void HandleLoginRequest(dServer* server, Packet* packet);
void SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username, std::vector<Stamp>& stamps);
void HandleAuth(RakNet::BitStream& inStream, const SystemAddress& sysAddr, dServer* server);
void LoadClaimCodes(); void LoadClaimCodes();
void Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr);
} }
#endif // AUTHPACKETS_H #endif // AUTHPACKETS_H

2
dNet/BitStreamUtils.h
View File

@@ -49,6 +49,7 @@ struct LUWString {
struct LUBitStream { struct LUBitStream {
ServiceType connectionType = ServiceType::UNKNOWN; ServiceType connectionType = ServiceType::UNKNOWN;
uint32_t internalPacketID = 0xFFFFFFFF; uint32_t internalPacketID = 0xFFFFFFFF;
SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
LUBitStream() = default; LUBitStream() = default;
@@ -61,6 +62,7 @@ struct LUBitStream {
void WriteHeader(RakNet::BitStream& bitStream) const; void WriteHeader(RakNet::BitStream& bitStream) const;
bool ReadHeader(RakNet::BitStream& bitStream); bool ReadHeader(RakNet::BitStream& bitStream);
void Send(const SystemAddress& sysAddr) const; void Send(const SystemAddress& sysAddr) const;
void Send() const { Send(this->sysAddr); };
void Broadcast() const { Send(UNASSIGNED_SYSTEM_ADDRESS); }; void Broadcast() const { Send(UNASSIGNED_SYSTEM_ADDRESS); };
virtual void Serialize(RakNet::BitStream& bitStream) const {} virtual void Serialize(RakNet::BitStream& bitStream) const {}

4
dNet/CMakeLists.txt
View File

@@ -2,12 +2,14 @@ set(DNET_SOURCES "AuthPackets.cpp"
"BitStreamUtils.cpp" "BitStreamUtils.cpp"
"ChatPackets.cpp" "ChatPackets.cpp"
"ClientPackets.cpp" "ClientPackets.cpp"
"CommonPackets.cpp"
"dServer.cpp" "dServer.cpp"
"MailInfo.cpp" "MailInfo.cpp"
"MasterPackets.cpp" "MasterPackets.cpp"
"PacketUtils.cpp" "PacketUtils.cpp"
"WorldPackets.cpp" "WorldPackets.cpp"
"ZoneInstanceManager.cpp") "ZoneInstanceManager.cpp"
)
add_library(dNet STATIC ${DNET_SOURCES}) add_library(dNet STATIC ${DNET_SOURCES})
target_link_libraries(dNet PRIVATE bcrypt MD5 glm::glm) target_link_libraries(dNet PRIVATE bcrypt MD5 glm::glm)

41
dNet/ClientPackets.cpp
View File

@@ -6,6 +6,47 @@
#include "ClientPackets.h" #include "ClientPackets.h"
#include "dCommonVars.h" #include "dCommonVars.h"
#include "PositionUpdate.h" #include "PositionUpdate.h"
#include "StringifiedEnum.h"
namespace ClientPackets {
void Stamp::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(type);
bitStream.Write(value);
bitStream.Write(timestamp);
};
void LoginResponse::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(responseCode);
bitStream.Write(events[0]);
bitStream.Write(events[1]);
bitStream.Write(events[2]);
bitStream.Write(events[3]);
bitStream.Write(events[4]);
bitStream.Write(events[5]);
bitStream.Write(events[6]);
bitStream.Write(events[7]);
bitStream.Write(version_major);
bitStream.Write(version_current);
bitStream.Write(version_minor);
bitStream.Write(userKey);
bitStream.Write(worldServerIP);
bitStream.Write(chatServerIP);
bitStream.Write(worldServerPort);
bitStream.Write(chatServerPort);
bitStream.Write(cdnKey);
bitStream.Write(cdnTicket);
bitStream.Write(language);
bitStream.Write(localization);
bitStream.Write(static_cast<uint8_t>(justUpgradedFromF2P));
bitStream.Write(static_cast<uint8_t>(isF2P));
bitStream.Write(membershipTimeLeft);
bitStream.Write<uint16_t>(errorMessage.length());
bitStream.Write(LUWString(errorMessage, static_cast<uint32_t>(errorMessage.length())));
bitStream.Write<uint32_t>((sizeof(Stamp) * stamps.size()) + sizeof(uint32_t));
for (const auto& stampData : stamps) stampData.Serialize(bitStream);
};
}
ChatMessage ClientPackets::HandleChatMessage(Packet* packet) { ChatMessage ClientPackets::HandleChatMessage(Packet* packet) {
CINSTREAM_SKIP_HEADER; CINSTREAM_SKIP_HEADER;

111
dNet/ClientPackets.h
View File

@@ -8,6 +8,8 @@
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#include "BitStreamUtils.h"
#include "MessageType/Client.h"
class PositionUpdate; class PositionUpdate;
@@ -26,11 +28,120 @@ struct ChatModerationRequest {
std::string message; std::string message;
}; };
enum class eLoginResponse : uint8_t {
GENERAL_FAILED = 0,
SUCCESS,
BANNED,
// Unused 3
// Unused 4
PERMISSIONS_NOT_HIGH_ENOUGH = 5,
INVALID_USER,
ACCOUNT_LOCKED,
WRONG_PASS,
ACCOUNT_ACTIVATION_PENDING,
ACCOUNT_DISABLED,
GAME_TIME_EXPIRED,
FREE_TRIAL_ENDED,
PLAY_SCHEDULE_TIME_UP,
ACCOUNT_NOT_ACTIVATED
};
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
};
enum class Language : uint32_t {
en_US,
pl_US,
de_DE,
en_GB,
};
namespace ClientPackets { namespace ClientPackets {
struct Stamp {
eStamps type;
uint32_t value;
uint64_t timestamp;
Stamp(eStamps type, uint32_t value, uint64_t timestamp = time(nullptr)) {
this->type = type;
this->value = value;
this->timestamp = timestamp;
}
void Serialize(RakNet::BitStream& bitStream) const;
};
struct LoginResponse : public LUBitStream {
eLoginResponse responseCode = eLoginResponse::GENERAL_FAILED;
std::vector<LUString> events;
uint16_t version_major = 0;
uint16_t version_current = 0;
uint16_t version_minor = 0;
LUWString userKey;
LUString worldServerIP;
LUString chatServerIP = LUString(""); // unused
uint16_t worldServerPort = 0;
uint16_t chatServerPort = 0; // unused
LUString cdnKey = LUString("");
LUString cdnTicket = LUString("00000000-0000-0000-0000-000000000000", 37);
Language language = Language::en_US;
LUString localization = LUString("US", 3);
bool justUpgradedFromF2P = false; // written as uint8_t
bool isF2P = false; // written as uint8_t
uint64_t membershipTimeLeft = 0;
std::string errorMessage;
std::vector<Stamp> stamps;
LoginResponse() : LUBitStream(ServiceType::CLIENT, MessageType::Client::LOGIN_RESPONSE) {}
void Serialize(RakNet::BitStream& bitStream) const override;
};
ChatMessage HandleChatMessage(Packet* packet); ChatMessage HandleChatMessage(Packet* packet);
PositionUpdate HandleClientPositionUpdate(Packet* packet); PositionUpdate HandleClientPositionUpdate(Packet* packet);
ChatModerationRequest HandleChatModerationRequest(Packet* packet); ChatModerationRequest HandleChatModerationRequest(Packet* packet);
int32_t SendTop5HelpIssues(Packet* packet); int32_t SendTop5HelpIssues(Packet* packet);
}; };
#endif // CLIENTPACKETS_H #endif // CLIENTPACKETS_H

86
dNet/CommonPackets.cpp Normal file
View File

@@ -0,0 +1,86 @@
#include "CommonPackets.h"
#include "dServer.h"
#include "Logger.h"
#include "Game.h"
#include "dServer.h"
#include "dConfig.h"
#include "StringifiedEnum.h"
#include "GeneralUtils.h"
namespace CommonPackets {
std::map<MessageType::Server, std::function<std::unique_ptr<LUBitStream>()>> g_Handlers = {
{MessageType::Server::VERSION_CONFIRM, []() {
return std::make_unique<VersionConfirm>();
}},
{MessageType::Server::DISCONNECT_NOTIFY, []() {
return std::make_unique<DisconnectNotify>();
}},
{MessageType::Server::GENERAL_NOTIFY, []() {
return std::make_unique<GeneralNotify>();
}}
};
void VersionConfirm::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write<uint32_t>(netVersion);
bitStream.Write<uint32_t>(861228100);
bitStream.Write(static_cast<uint32_t>(serviceType));
bitStream.Write<uint64_t>(219818307120);
}
bool VersionConfirm::Deserialize(RakNet::BitStream& bitStream) {
VALIDATE_READ(bitStream.Read(netVersion));
uint32_t unknown = 0;
VALIDATE_READ(bitStream.Read(unknown));
VALIDATE_READ(bitStream.Read(serviceType));
uint16_t unknown2 = 0;
VALIDATE_READ(bitStream.Read(unknown2));
VALIDATE_READ(bitStream.Read(processID));
VALIDATE_READ(bitStream.Read(port));
LUString unknownString;
VALIDATE_READ(bitStream.Read(unknownString));
return true;
}
void VersionConfirm::Handle() {
LOG_DEBUG("Client Data [Version: %i, Service: %s, Process: %u, Port: %u, Sysaddr Port: %u]", netVersion, StringifiedEnum::ToString(serviceType).data(), processID, port, sysAddr.port);
VersionConfirm response;
auto& serverNetVersionString = Game::config->GetValue("client_net_version");
const uint32_t serverNetVersion = GeneralUtils::TryParse<uint32_t>(serverNetVersionString).value_or(171022);
response.netVersion = serverNetVersion;
response.serviceType = Game::server->GetServerType();
response.Send(sysAddr);
}
void DisconnectNotify::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(disconnectID);
}
void GeneralNotify::Serialize(RakNet::BitStream& bitStream) const {
bitStream.Write(notifyID);
bitStream.Write(notifyUser);
}
}
void CommonPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
inStream.ResetReadPointer();
LUBitStream lubitstream;
if (!lubitstream.ReadHeader(inStream)) return;
auto it = g_Handlers.find(static_cast<MessageType::Server>(lubitstream.internalPacketID));
if (it != g_Handlers.end()) {
auto request = it->second();
request->sysAddr = sysAddr;
if (!request->Deserialize(inStream)) {
LOG_DEBUG("Error Reading Common Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Server>(lubitstream.internalPacketID)).data());
return;
}
LOG_DEBUG("Received Common Packet: %s", StringifiedEnum::ToString(static_cast<MessageType::Server>(lubitstream.internalPacketID)).data());
request->Handle();
} else {
LOG_DEBUG("Unhandled Common Packet with ID: %i", lubitstream.internalPacketID);
}
}

57
dNet/CommonPackets.h Normal file
View File

@@ -0,0 +1,57 @@
#include "dCommonVars.h"
#include "dNetCommon.h"
#include "BitStreamUtils.h"
#include "MessageType/Server.h"
enum class eServerDisconnectIdentifiers : uint32_t {
UNKNOWN_SERVER_ERROR = 0,
WRONG_GAME_VERSION,
WRONG_SERVER_VERSION,
CONNECTION_ON_INVALID_PORT,
DUPLICATE_LOGIN,
SERVER_SHUTDOWN,
SERVER_MAP_LOAD_FAILURE,
INVALID_SESSION_KEY,
ACCOUNT_NOT_IN_PENDING_LIST,
CHARACTER_NOT_FOUND,
CHARACTER_CORRUPTED,
KICK,
SAVE_FAILURE,
FREE_TRIAL_EXPIRED,
PLAY_SCHEDULE_TIME_DONE
};
// Packet Struct Functions
namespace CommonPackets {
struct VersionConfirm : public LUBitStream {
uint32_t netVersion = 0;
ServiceType serviceType;
uint32_t processID = 0;
uint16_t port = 0;
VersionConfirm() : LUBitStream(ServiceType::COMMON, MessageType::Server::VERSION_CONFIRM) {}
void Serialize(RakNet::BitStream& bitStream) const override;
bool Deserialize(RakNet::BitStream& bitStream) override;
void Handle() override;
};
struct DisconnectNotify : public LUBitStream {
eServerDisconnectIdentifiers disconnectID = eServerDisconnectIdentifiers::UNKNOWN_SERVER_ERROR;
DisconnectNotify() : LUBitStream(ServiceType::COMMON, MessageType::Server::DISCONNECT_NOTIFY) {}
void Serialize(RakNet::BitStream& bitStream) const override;
};
struct GeneralNotify : public LUBitStream {
uint32_t notifyID = 0; // only one known value: 0, which is Duplicate account login
bool notifyUser = true;
GeneralNotify() : LUBitStream(ServiceType::COMMON, MessageType::Server::GENERAL_NOTIFY) {}
void Serialize(RakNet::BitStream& bitStream) const override;
};
// Non Struct functions
void Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr);
}

7
dNet/dServer.cpp
View File

@@ -197,12 +197,7 @@ void dServer::SendToMaster(RakNet::BitStream& bitStream) {
mMasterPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, mMasterSystemAddress, false); mMasterPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, mMasterSystemAddress, false);
} }
void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) { void dServer::Disconnect(const SystemAddress& sysAddr) {
RakNet::BitStream bitStream;
BitStreamUtils::WriteHeader(bitStream, ServiceType::COMMON, MessageType::Server::DISCONNECT_NOTIFY);
bitStream.Write(disconNotifyID);
mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false);
mPeer->CloseConnection(sysAddr, true); mPeer->CloseConnection(sysAddr, true);
} }

2
dNet/dServer.h
View File

@@ -43,7 +43,7 @@ public:
virtual void Send(RakNet::BitStream& bitStream, const SystemAddress& sysAddr, bool broadcast); virtual void Send(RakNet::BitStream& bitStream, const SystemAddress& sysAddr, bool broadcast);
void SendToMaster(RakNet::BitStream& bitStream); void SendToMaster(RakNet::BitStream& bitStream);
void Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID); void Disconnect(const SystemAddress& sysAddr);
bool IsConnected(const SystemAddress& sysAddr); bool IsConnected(const SystemAddress& sysAddr);
const std::string& GetIP() const { return mIP; } const std::string& GetIP() const { return mIP; }

50
dWorldServer/WorldServer.cpp
View File

@@ -40,6 +40,7 @@
#include "dChatFilter.h" #include "dChatFilter.h"
#include "ClientPackets.h" #include "ClientPackets.h"
#include "CharacterComponent.h" #include "CharacterComponent.h"
#include "CommonPackets.h"
#include "EntityManager.h" #include "EntityManager.h"
#include "EntityInfo.h" #include "EntityInfo.h"
@@ -62,7 +63,6 @@
#include "eBlueprintSaveResponseType.h" #include "eBlueprintSaveResponseType.h"
#include "Amf3.h" #include "Amf3.h"
#include "NiPoint3.h" #include "NiPoint3.h"
#include "eServerDisconnectIdentifiers.h"
#include "eObjectBits.h" #include "eObjectBits.h"
#include "ServiceType.h" #include "ServiceType.h"
#include "MessageType/Server.h" #include "MessageType/Server.h"
@@ -78,7 +78,6 @@
#include "Server.h" #include "Server.h"
#include "PositionUpdate.h" #include "PositionUpdate.h"
#include "PlayerManager.h" #include "PlayerManager.h"
#include "eLoginResponse.h"
#include "MissionComponent.h" #include "MissionComponent.h"
#include "SlashCommandHandler.h" #include "SlashCommandHandler.h"
#include "InventoryComponent.h" #include "InventoryComponent.h"
@@ -703,7 +702,10 @@ void HandleMasterPacket(Packet* packet) {
//Verify it: //Verify it:
if (userHash != it->second.hash) { if (userHash != it->second.hash) {
LOG("SOMEONE IS TRYING TO HACK? SESSION KEY MISMATCH: ours: %s != master: %s", userHash.c_str(), it->second.hash.c_str()); LOG("SOMEONE IS TRYING TO HACK? SESSION KEY MISMATCH: ours: %s != master: %s", userHash.c_str(), it->second.hash.c_str());
Game::server->Disconnect(it->second.sysAddr, eServerDisconnectIdentifiers::INVALID_SESSION_KEY); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::INVALID_SESSION_KEY;
notification.Send(it->second.sysAddr);
Game::server->Disconnect(it->second.sysAddr);
return; return;
} else { } else {
LOG("User %s authenticated with correct key.", username.GetAsString().c_str()); LOG("User %s authenticated with correct key.", username.GetAsString().c_str());
@@ -786,7 +788,10 @@ void HandleMasterPacket(Packet* packet) {
//Check the key: //Check the key:
if (sessionKey != std::atoi(user->GetSessionKey().c_str())) { if (sessionKey != std::atoi(user->GetSessionKey().c_str())) {
LOG("But the session key is invalid!", username.string.c_str()); LOG("But the session key is invalid!", username.string.c_str());
Game::server->Disconnect(user->GetSystemAddress(), eServerDisconnectIdentifiers::INVALID_SESSION_KEY); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::INVALID_SESSION_KEY;
notification.Send(user->GetSystemAddress());
Game::server->Disconnect(user->GetSystemAddress());
return; return;
} }
break; break;
@@ -855,13 +860,10 @@ void HandlePacket(Packet* packet) {
luBitStream.ReadHeader(inStream); luBitStream.ReadHeader(inStream);
if (luBitStream.connectionType == ServiceType::COMMON) { if (luBitStream.connectionType == ServiceType::COMMON) {
if (static_cast<MessageType::Server>(luBitStream.internalPacketID) == MessageType::Server::VERSION_CONFIRM) { CommonPackets::Handle(inStream, packet->systemAddress);
AuthPackets::HandleHandshake(Game::server, packet);
}
} }
if (luBitStream.connectionType != ServiceType::WORLD) return; if (luBitStream.connectionType != ServiceType::WORLD) return;
switch (static_cast<MessageType::World>(luBitStream.internalPacketID)) { switch (static_cast<MessageType::World>(luBitStream.internalPacketID)) {
case MessageType::World::VALIDATION: { case MessageType::World::VALIDATION: {
CINSTREAM_SKIP_HEADER; CINSTREAM_SKIP_HEADER;
@@ -879,7 +881,10 @@ void HandlePacket(Packet* packet) {
auto accountInfo = Database::Get()->GetAccountInfo(username.GetAsString()); auto accountInfo = Database::Get()->GetAccountInfo(username.GetAsString());
if (!accountInfo) { if (!accountInfo) {
LOG("Client's account does not exist in the database, aborting connection."); LOG("Client's account does not exist in the database, aborting connection.");
Game::server->Disconnect(packet->systemAddress, eServerDisconnectIdentifiers::CHARACTER_NOT_FOUND); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::CHARACTER_NOT_FOUND;
notification.Send(packet->systemAddress);
Game::server->Disconnect(packet->systemAddress);
return; return;
} }
@@ -888,13 +893,13 @@ void HandlePacket(Packet* packet) {
if (accountInfo->maxGmLevel < eGameMasterLevel::DEVELOPER) { if (accountInfo->maxGmLevel < eGameMasterLevel::DEVELOPER) {
LOG("Client's database checksum does not match the server's, aborting connection."); LOG("Client's database checksum does not match the server's, aborting connection.");
std::vector<Stamp> stamps;
// Using the LoginResponse here since the UI is still in the login screen state // Using the LoginResponse here since the UI is still in the login screen state
// and we have a way to send a message about the client mismatch. // and we have a way to send a message about the client mismatch.
AuthPackets::SendLoginResponse( ClientPackets::LoginResponse response;
Game::server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, response.sysAddr = packet->systemAddress;
Game::config->GetValue("cdclient_mismatch_message"), "", 0, "", stamps); response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
response.errorMessage= Game::config->GetValue("cdclient_mismatch_message");
response.Send(packet->systemAddress);
return; return;
} else { } else {
AMFArrayValue args; AMFArrayValue args;
@@ -1207,7 +1212,10 @@ void HandlePacket(Packet* packet) {
} }
} else { } else {
LOG("Couldn't find character to log in with for user %s (%i)!", user->GetUsername().c_str(), user->GetAccountID()); LOG("Couldn't find character to log in with for user %s (%i)!", user->GetUsername().c_str(), user->GetAccountID());
Game::server->Disconnect(packet->systemAddress, eServerDisconnectIdentifiers::CHARACTER_NOT_FOUND); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::CHARACTER_NOT_FOUND;
notification.Send(packet->systemAddress);
Game::server->Disconnect(packet->systemAddress);
} }
} else { } else {
LOG("Couldn't get user for level load complete!"); LOG("Couldn't get user for level load complete!");
@@ -1386,7 +1394,11 @@ void HandlePacket(Packet* packet) {
if (user) { if (user) {
user->UserOutOfSync(); user->UserOutOfSync();
} else { } else {
Game::server->Disconnect(packet->systemAddress, eServerDisconnectIdentifiers::KICK); CommonPackets::DisconnectNotify notification;
notification.disconnectID = eServerDisconnectIdentifiers::KICK;
notification.Send(packet->systemAddress);
Game::server->Disconnect(packet->systemAddress);
} }
break; break;
} }
@@ -1463,8 +1475,10 @@ void WorldShutdownProcess(uint32_t zoneId) {
while (Game::server->GetReplicaManager()->GetParticipantCount() > 0) { while (Game::server->GetReplicaManager()->GetParticipantCount() > 0) {
const auto& player = Game::server->GetReplicaManager()->GetParticipantAtIndex(0); const auto& player = Game::server->GetReplicaManager()->GetParticipantAtIndex(0);
CommonPackets::DisconnectNotify notification;
Game::server->Disconnect(player, eServerDisconnectIdentifiers::SERVER_SHUTDOWN); notification.disconnectID = eServerDisconnectIdentifiers::SERVER_SHUTDOWN;
notification.Send(player);
Game::server->Disconnect(player);
} }
SendShutdownMessageToMaster(); SendShutdownMessageToMaster();
} }