From 345091244cddfbe850bf6de2cd159ec6c538ecff Mon Sep 17 00:00:00 2001 From: Shauren Date: Sun, 18 Jan 2026 17:00:29 +0100 Subject: [PATCH] Core/Network: Move parsing of EarlyProcessClientPacket from WorldSocket::ReadDataHandlerResult to their handler functions --- .../Server/Packets/AuthenticationPackets.cpp | 5 + .../Server/Packets/AuthenticationPackets.h | 12 + src/server/game/Server/WorldSession.cpp | 4 +- src/server/game/Server/WorldSession.h | 2 +- src/server/game/Server/WorldSocket.cpp | 270 +++++++++--------- src/server/game/Server/WorldSocket.h | 42 ++- 6 files changed, 178 insertions(+), 157 deletions(-) diff --git a/src/server/game/Server/Packets/AuthenticationPackets.cpp b/src/server/game/Server/Packets/AuthenticationPackets.cpp index 64e69e90134..a4ecec4d3fa 100644 --- a/src/server/game/Server/Packets/AuthenticationPackets.cpp +++ b/src/server/game/Server/Packets/AuthenticationPackets.cpp @@ -60,6 +60,11 @@ WorldPacket const* Pong::Write() return &_worldPacket; } +void LogDisconnect::Read() +{ + _worldPacket >> Reason; +} + WorldPacket const* AuthChallenge::Write() { _worldPacket.append(DosChallenge.data(), DosChallenge.size()); diff --git a/src/server/game/Server/Packets/AuthenticationPackets.h b/src/server/game/Server/Packets/AuthenticationPackets.h index 8055110f1c4..537cdf1cd48 100644 --- a/src/server/game/Server/Packets/AuthenticationPackets.h +++ b/src/server/game/Server/Packets/AuthenticationPackets.h @@ -73,6 +73,18 @@ namespace WorldPackets uint32 Serial = 0; }; + class LogDisconnect final : public EarlyProcessClientPacket + { + public: + explicit LogDisconnect(WorldPacket&& packet) : EarlyProcessClientPacket(CMSG_LOG_DISCONNECT, std::move(packet)) { } + + uint32 Reason = 0; + + private: + friend EarlyProcessClientPacket; + void Read() override; + }; + class AuthChallenge final : public ServerPacket { public: diff --git a/src/server/game/Server/WorldSession.cpp b/src/server/game/Server/WorldSession.cpp index a336b5790ad..0dfed8f0959 100644 --- a/src/server/game/Server/WorldSession.cpp +++ b/src/server/game/Server/WorldSession.cpp @@ -325,9 +325,9 @@ void WorldSession::AddInstanceConnection(WorldSession* session, std::weak_ptr const WorldSocket::EncryptionKeySeed = { 0x71, 0xC9, 0xED, 0x5D, 0xA1, 0x48, 0xC8, 0x30, 0x47, 0x4A, 0xDE, 0xF6, 0x0D, 0x6C, 0xBE, 0x6F, 0xE4, 0x55, 0x73 }; WorldSocket::WorldSocket(Trinity::Net::IoContextTcpSocket&& socket) : BaseSocket(std::move(socket)), - _type(CONNECTION_TYPE_REALM), _key(0), _serverChallenge(), _sessionKey(), _encryptKey(), _OverSpeedPings(0), + _type(CONNECTION_TYPE_REALM), _key(0), _serverChallenge(), _sessionKey(), _encryptKey(), _overSpeedPings(0), _worldSession(nullptr), _authed(false), _canRequestHotfixes(true), _headerBuffer(sizeof(IncomingPacketHeader)), _sendBufferSize(4096), _compressionStream(nullptr) { } @@ -379,129 +379,53 @@ WorldSocket::ReadDataHandlerResult WorldSocket::ReadDataHandler() if (sPacketLog->CanLogPacket()) sPacketLog->LogPacket(packet, CLIENT_TO_SERVER, GetRemoteIpAddress(), GetRemotePort(), GetConnectionType()); - std::unique_lock sessionGuard(_worldSessionLock, std::defer_lock); - switch (opcode) { case CMSG_PING: - { - LogOpcodeText(opcode, sessionGuard); - WorldPackets::Auth::Ping ping(std::move(packet)); - if (!ping.ReadNoThrow()) - { - TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_PING", GetRemoteIpAddress()); - return ReadDataHandlerResult::Error; - } - if (!HandlePing(ping)) - return ReadDataHandlerResult::Error; - break; - } + return HandlePing(std::move(packet)); case CMSG_AUTH_SESSION: - { - LogOpcodeText(opcode, sessionGuard); - if (_authed) - { - // locking just to safely log offending user is probably overkill but we are disconnecting him anyway - if (sessionGuard.try_lock()) - TC_LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_SESSION from {}", _worldSession->GetPlayerInfo()); - return ReadDataHandlerResult::Error; - } - - std::shared_ptr authSession = std::make_shared(std::move(packet)); - if (!authSession->ReadNoThrow()) - { - TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_AUTH_SESSION", GetRemoteIpAddress()); - return ReadDataHandlerResult::Error; - } - HandleAuthSession(authSession); - return ReadDataHandlerResult::WaitingForQuery; - } + return HandleAuthSession(std::move(packet)); case CMSG_AUTH_CONTINUED_SESSION: - { - LogOpcodeText(opcode, sessionGuard); - if (_authed) - { - // locking just to safely log offending user is probably overkill but we are disconnecting him anyway - if (sessionGuard.try_lock()) - TC_LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_CONTINUED_SESSION from {}", _worldSession->GetPlayerInfo()); - return ReadDataHandlerResult::Error; - } - - std::shared_ptr authSession = std::make_shared(std::move(packet)); - if (!authSession->ReadNoThrow()) - { - TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_AUTH_CONTINUED_SESSION", GetRemoteIpAddress()); - return ReadDataHandlerResult::Error; - } - HandleAuthContinuedSession(authSession); - return ReadDataHandlerResult::WaitingForQuery; - } + return HandleAuthContinuedSession(std::move(packet)); case CMSG_KEEP_ALIVE: - sessionGuard.lock(); - LogOpcodeText(opcode, sessionGuard); - if (_worldSession) - { - _worldSession->ResetTimeOutTime(true); - return ReadDataHandlerResult::Ok; - } - TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler: client {} sent CMSG_KEEP_ALIVE without being authenticated", GetRemoteIpAddress()); - return ReadDataHandlerResult::Error; + return HandleKeepAlive(); case CMSG_LOG_DISCONNECT: - LogOpcodeText(opcode, sessionGuard); - TC_LOG_DEBUG("network", "WorldSocket::ReadDataHandler: client {} sent CMSG_LOG_DISCONNECT reason {}", GetRemoteIpAddress(), packet.read()); - break; + return HandleLogDisconnect(std::move(packet)); case CMSG_ENABLE_NAGLE: - LogOpcodeText(opcode, sessionGuard); + LogOpcodeText(CMSG_ENABLE_NAGLE); SetNoDelay(false); break; case CMSG_CONNECT_TO_FAILED: - { - sessionGuard.lock(); - - LogOpcodeText(opcode, sessionGuard); - WorldPackets::Auth::ConnectToFailed connectToFailed(std::move(packet)); - if (!connectToFailed.ReadNoThrow()) - { - TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_CONNECT_TO_FAILED", GetRemoteIpAddress()); - return ReadDataHandlerResult::Error; - } - HandleConnectToFailed(connectToFailed); - break; - } + return HandleConnectToFailed(std::move(packet)); case CMSG_ENTER_ENCRYPTED_MODE_ACK: - LogOpcodeText(opcode, sessionGuard); - HandleEnterEncryptedModeAck(); - break; - case CMSG_HOTFIX_REQUEST: - _canRequestHotfixes = false; - [[fallthrough]]; + return HandleEnterEncryptedModeAck(); default: { if (opcode == CMSG_TIME_SYNC_RESPONSE || opcode == CMSG_MOVE_INIT_ACTIVE_MOVER_COMPLETE || opcode == CMSG_QUEUED_MESSAGES_END) packet.SetReceiveTime(std::chrono::steady_clock::now()); + else if (opcode == CMSG_HOTFIX_REQUEST) + _canRequestHotfixes = false; - sessionGuard.lock(); + std::scoped_lock sessionGuard(_worldSessionLock); LogOpcodeText(opcode, sessionGuard); if (!_worldSession) { - TC_LOG_ERROR("network.opcode", "ProcessIncoming: Client not authed opcode = {}", uint32(opcode)); + TC_LOG_ERROR("network.opcode", "WorldSocket::ReadDataHandler: Client not authed opcode {}", GetOpcodeNameForLogging(opcode)); return ReadDataHandlerResult::Error; } - ClientOpcodeHandler const* handler = opcodeTable[opcode]; - if (!handler) + if (!opcodeTable[opcode]) { - TC_LOG_ERROR("network.opcode", "No defined handler for opcode {} sent by {}", GetOpcodeNameForLogging(static_cast(packet.GetOpcode())), _worldSession->GetPlayerInfo()); + TC_LOG_ERROR("network.opcode", "WorldSocket::ReadDataHandler: No defined handler for opcode {} sent by {}", GetOpcodeNameForLogging(opcode), _worldSession->GetPlayerInfo()); break; } // Our Idle timer will reset on any non PING opcodes on login screen, allowing us to catch people idling. _worldSession->ResetTimeOutTime(false); - // Copy the packet to the heap before enqueuing - _worldSession->QueuePacket(new WorldPacket(std::move(packet))); + _worldSession->QueuePacket(std::move(packet)); break; } } @@ -509,9 +433,14 @@ WorldSocket::ReadDataHandlerResult WorldSocket::ReadDataHandler() return ReadDataHandlerResult::Ok; } -void WorldSocket::LogOpcodeText(OpcodeClient opcode, std::unique_lock const& guard) const +void WorldSocket::LogOpcodeText(OpcodeClient opcode) const { - if (!guard || !_worldSession) + TC_LOG_TRACE("network.opcode", "C->S: {} {}", GetRemoteIpAddress(), GetOpcodeNameForLogging(opcode)); +} + +void WorldSocket::LogOpcodeText(OpcodeClient opcode, std::scoped_lock const& /*guard*/) const +{ + if (!_worldSession) { TC_LOG_TRACE("network.opcode", "C->S: {} {}", GetRemoteIpAddress(), GetOpcodeNameForLogging(opcode)); } @@ -677,29 +606,45 @@ struct AccountInfo } }; -void WorldSocket::HandleAuthSession(std::shared_ptr authSession) +WorldSocket::ReadDataHandlerResult WorldSocket::HandleAuthSession(WorldPacket&& packet) { - std::shared_ptr joinTicket = std::make_shared(); - if (!JSON::Deserialize(authSession->RealmJoinTicket, joinTicket.get())) + LogOpcodeText(CMSG_AUTH_SESSION); + + if (_authed) + { + std::scoped_lock guard(_worldSessionLock); + TC_LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_SESSION from {}", _worldSession->GetPlayerInfo()); + return ReadDataHandlerResult::Error; + } + + std::shared_ptr callbackData = std::make_shared>( + std::piecewise_construct, std::forward_as_tuple(std::move(packet)), std::forward_as_tuple()); + if (!callbackData->first.ReadNoThrow()) + { + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_AUTH_SESSION", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; + } + + if (!JSON::Deserialize(callbackData->first.RealmJoinTicket, &callbackData->second)) { SendAuthResponseError(ERROR_WOW_SERVICES_INVALID_JOIN_TICKET); DelayedCloseSocket(); - return; + return ReadDataHandlerResult::Error; } // Get the account information from the auth database LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_BY_NAME); stmt->setInt32(0, int32(sRealmList->GetCurrentRealmId().Realm)); - stmt->setString(1, joinTicket->gameaccount()); + stmt->setString(1, callbackData->second.gameaccount()); - QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession), joinTicket = std::move(joinTicket)](PreparedQueryResult result) mutable + QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, callbackData = std::move(callbackData)](PreparedQueryResult const& result) mutable { - HandleAuthSessionCallback(std::move(authSession), std::move(joinTicket), std::move(result)); + HandleAuthSessionCallback(&callbackData->first, &callbackData->second, result.get()); })); + return ReadDataHandlerResult::WaitingForQuery; } -void WorldSocket::HandleAuthSessionCallback(std::shared_ptr authSession, - std::shared_ptr joinTicket, PreparedQueryResult result) +void WorldSocket::HandleAuthSessionCallback(WorldPackets::Auth::AuthSession const* authSession, JSON::RealmList::RealmJoinTicket* joinTicket, PreparedResultSet const* result) { // Stop if the account is not found if (!result) @@ -712,7 +657,7 @@ void WorldSocket::HandleAuthSessionCallback(std::shared_ptrGetRBACData()->LoadFromDBCallback(result); + _worldSession->GetRBACData()->LoadFromDBCallback(std::move(result)); SendPacketAndLogOpcode(*WorldPackets::Auth::EnterEncryptedMode(_encryptKey, true).Write()); } -void WorldSocket::HandleAuthContinuedSession(std::shared_ptr authSession) +WorldSocket::ReadDataHandlerResult WorldSocket::HandleAuthContinuedSession(WorldPacket&& packet) { + LogOpcodeText(CMSG_AUTH_CONTINUED_SESSION); + + if (_authed) + { + std::scoped_lock guard(_worldSessionLock); + TC_LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_CONTINUED_SESSION from {}", _worldSession->GetPlayerInfo()); + return ReadDataHandlerResult::Error; + } + + std::shared_ptr authSession = std::make_shared(std::move(packet)); + if (!authSession->ReadNoThrow()) + { + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_AUTH_CONTINUED_SESSION", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; + } + WorldSession::ConnectToKey key; key.Raw = authSession->Key; @@ -921,20 +882,21 @@ void WorldSocket::HandleAuthContinuedSession(std::shared_ptrsetUInt32(0, accountId); - QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession)](PreparedQueryResult result) mutable + QueueQuery(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback([this, authSession = std::move(authSession)](PreparedQueryResult const& result) mutable { - HandleAuthContinuedSessionCallback(std::move(authSession), std::move(result)); + HandleAuthContinuedSessionCallback(authSession.get(), result.get()); })); + return ReadDataHandlerResult::WaitingForQuery; } -void WorldSocket::HandleAuthContinuedSessionCallback(std::shared_ptr authSession, PreparedQueryResult result) +void WorldSocket::HandleAuthContinuedSessionCallback(WorldPackets::Auth::AuthContinuedSession const* authSession, PreparedResultSet const* result) { if (!result) { @@ -978,8 +940,50 @@ void WorldSocket::HandleAuthContinuedSessionCallback(std::shared_ptr{ .Socket = this }); } -void WorldSocket::HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& connectToFailed) +WorldSocket::ReadDataHandlerResult WorldSocket::HandleKeepAlive() { + std::scoped_lock sessionGuard(_worldSessionLock); + + LogOpcodeText(CMSG_KEEP_ALIVE, sessionGuard); + + if (!_worldSession) + { + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler: client {} sent CMSG_KEEP_ALIVE without being authenticated", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; + } + + _worldSession->ResetTimeOutTime(true); + return ReadDataHandlerResult::Ok; +} + +WorldSocket::ReadDataHandlerResult WorldSocket::HandleLogDisconnect(WorldPacket&& packet) const +{ + LogOpcodeText(CMSG_LOG_DISCONNECT); + + WorldPackets::Auth::LogDisconnect logDisconnect(std::move(packet)); + if (!logDisconnect.ReadNoThrow()) + { + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_LOG_DISCONNECT", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; + } + + TC_LOG_DEBUG("network", "WorldSocket::ReadDataHandler: client {} sent CMSG_LOG_DISCONNECT reason {}", GetRemoteIpAddress(), logDisconnect.Reason); + return ReadDataHandlerResult::Ok; +} + +WorldSocket::ReadDataHandlerResult WorldSocket::HandleConnectToFailed(WorldPacket&& packet) +{ + std::scoped_lock sessionGuard(_worldSessionLock); + + LogOpcodeText(CMSG_CONNECT_TO_FAILED, sessionGuard); + + WorldPackets::Auth::ConnectToFailed connectToFailed(std::move(packet)); + if (!connectToFailed.ReadNoThrow()) + { + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_CONNECT_TO_FAILED", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; + } + if (_worldSession) { if (_worldSession->PlayerLoading()) @@ -1005,7 +1009,7 @@ void WorldSocket::HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& con break; } default: - return; + break; } } //else @@ -1014,15 +1018,21 @@ void WorldSocket::HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& con // SendPacketAndLogOpcode(*WorldPackets::Auth::ResumeComms().Write()); //} } + + return ReadDataHandlerResult::Ok; } -void WorldSocket::HandleEnterEncryptedModeAck() +WorldSocket::ReadDataHandlerResult WorldSocket::HandleEnterEncryptedModeAck() { + LogOpcodeText(CMSG_ENTER_ENCRYPTED_MODE_ACK); + _authCrypt.Init(_encryptKey); if (_type == CONNECTION_TYPE_REALM) sWorld->AddSession(_worldSession); else sWorld->AddInstanceSocket(static_pointer_cast(shared_from_this()), _key); + + return ReadDataHandlerResult::Ok; } void WorldSocket::SendAuthResponseError(uint32 code) @@ -1032,29 +1042,30 @@ void WorldSocket::SendAuthResponseError(uint32 code) SendPacketAndLogOpcode(*response.Write()); } -bool WorldSocket::HandlePing(WorldPackets::Auth::Ping& ping) +WorldSocket::ReadDataHandlerResult WorldSocket::HandlePing(WorldPacket&& packet) { - using namespace std::chrono; + LogOpcodeText(CMSG_PING); - if (_LastPingTime == steady_clock::time_point()) + WorldPackets::Auth::Ping ping(std::move(packet)); + if (!ping.ReadNoThrow()) { - _LastPingTime = steady_clock::now(); + TC_LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_PING", GetRemoteIpAddress()); + return ReadDataHandlerResult::Error; } - else + + TimePoint lastPingTime = std::exchange(_lastPingTime, TimePoint::clock::now()); + + if (lastPingTime != TimePoint()) { - steady_clock::time_point now = steady_clock::now(); - - steady_clock::duration diff = now - _LastPingTime; - - _LastPingTime = now; + TimePoint::duration diff = _lastPingTime - lastPingTime; if (diff < 27s) { - ++_OverSpeedPings; + ++_overSpeedPings; uint32 maxAllowed = sWorld->getIntConfig(CONFIG_MAX_OVERSPEED_PINGS); - if (maxAllowed && _OverSpeedPings > maxAllowed) + if (maxAllowed && _overSpeedPings > maxAllowed) { bool ignoresOverspeedPingsLimit = [&] { @@ -1067,12 +1078,12 @@ bool WorldSocket::HandlePing(WorldPackets::Auth::Ping& ping) TC_LOG_ERROR("network", "WorldSocket::HandlePing: {} kicked for over-speed pings (address: {})", _worldSession->GetPlayerInfo(), GetRemoteIpAddress()); - return false; + return ReadDataHandlerResult::Error; } } } else - _OverSpeedPings = 0; + _overSpeedPings = 0; } bool success = [&] @@ -1089,10 +1100,9 @@ bool WorldSocket::HandlePing(WorldPackets::Auth::Ping& ping) if (!success) { TC_LOG_ERROR("network", "WorldSocket::HandlePing: peer sent CMSG_PING, but is not authenticated or got recently kicked, address = {}", GetRemoteIpAddress()); - return false; - + return ReadDataHandlerResult::Error; } SendPacketAndLogOpcode(*WorldPackets::Auth::Pong(ping.Serial).Write()); - return true; + return ReadDataHandlerResult::Ok; } diff --git a/src/server/game/Server/WorldSocket.h b/src/server/game/Server/WorldSocket.h index b5388532b4d..6f18ef4c52c 100644 --- a/src/server/game/Server/WorldSocket.h +++ b/src/server/game/Server/WorldSocket.h @@ -21,13 +21,12 @@ #include "AsyncCallbackProcessor.h" #include "AuthDefines.h" #include "DatabaseEnvFwd.h" +#include "MPSCQueue.h" #include "MessageBuffer.h" #include "Socket.h" #include "WorldPacket.h" #include "WorldPacketCrypt.h" -#include "MPSCQueue.h" #include -#include #include namespace JSON::RealmList @@ -58,16 +57,10 @@ private: bool _encrypt; }; -namespace WorldPackets +namespace WorldPackets::Auth { - class ServerPacket; - namespace Auth - { - class AuthSession; - class AuthContinuedSession; - class ConnectToFailed; - class Ping; - } + class AuthSession; + class AuthContinuedSession; } #pragma pack(push, 1) @@ -99,7 +92,7 @@ class TC_GAME_API WorldSocket final : public Trinity::Net::Socket<> using BaseSocket = Socket; public: - WorldSocket(Trinity::Net::IoContextTcpSocket&& socket); + explicit WorldSocket(Trinity::Net::IoContextTcpSocket&& socket); ~WorldSocket(); WorldSocket(WorldSocket const& right) = delete; @@ -139,22 +132,23 @@ protected: ReadDataHandlerResult ReadDataHandler(); private: /// writes network.opcode log - /// accessing WorldSession is not threadsafe, only do it when holding _worldSessionLock - void LogOpcodeText(OpcodeClient opcode, std::unique_lock const& guard) const; + void LogOpcodeText(OpcodeClient opcode) const; + void LogOpcodeText(OpcodeClient opcode, std::scoped_lock const& guard) const; /// sends and logs network.opcode without accessing WorldSession void SendPacketAndLogOpcode(WorldPacket const& packet); void WritePacketToBuffer(EncryptablePacket const& packet, MessageBuffer& buffer); uint32 CompressPacket(uint8* buffer, WorldPacket const& packet); - void HandleAuthSession(std::shared_ptr authSession); - void HandleAuthSessionCallback(std::shared_ptr authSession, - std::shared_ptr joinTicket, PreparedQueryResult result); - void HandleAuthContinuedSession(std::shared_ptr authSession); - void HandleAuthContinuedSessionCallback(std::shared_ptr authSession, PreparedQueryResult result); + ReadDataHandlerResult HandleAuthSession(WorldPacket&& packet); + void HandleAuthSessionCallback(WorldPackets::Auth::AuthSession const* authSession, JSON::RealmList::RealmJoinTicket* joinTicket, PreparedResultSet const* result); + ReadDataHandlerResult HandleAuthContinuedSession(WorldPacket&& packet); + void HandleAuthContinuedSessionCallback(WorldPackets::Auth::AuthContinuedSession const* authSession, PreparedResultSet const* result); void LoadSessionPermissionsCallback(PreparedQueryResult result); - void HandleConnectToFailed(WorldPackets::Auth::ConnectToFailed& connectToFailed); - bool HandlePing(WorldPackets::Auth::Ping& ping); - void HandleEnterEncryptedModeAck(); + ReadDataHandlerResult HandleKeepAlive(); + ReadDataHandlerResult HandleLogDisconnect(WorldPacket&& packet) const; + ReadDataHandlerResult HandleConnectToFailed(WorldPacket&& packet); + ReadDataHandlerResult HandlePing(WorldPacket&& packet); + ReadDataHandlerResult HandleEnterEncryptedModeAck(); ConnectionType _type; uint64 _key; @@ -164,8 +158,8 @@ private: SessionKey _sessionKey; std::array _encryptKey; - TimePoint _LastPingTime; - uint32 _OverSpeedPings; + TimePoint _lastPingTime; + uint32 _overSpeedPings; std::mutex _worldSessionLock; WorldSession* _worldSession;