WorldSocket Class Reference

#include "WorldSocket.h"

Inheritance diagram for WorldSocket:

Public Member Functions
	WorldSocket (tcp::socket &&socket)
	~WorldSocket ()
	WorldSocket (WorldSocket const &right)=delete
WorldSocket &	operator= (WorldSocket const &right)=delete
void	Start () override
bool	Update () override
void	SendPacket (WorldPacket const &packet)
void	SetSendBufferSize (std::size_t sendBufferSize)
Public Member Functions inherited from Socket< WorldSocket >
	Socket (tcp::socket &&socket)
virtual	~Socket ()
boost::asio::ip::address	GetRemoteIpAddress () const
uint16	GetRemotePort () const
void	AsyncRead ()
void	AsyncReadProxyHeader ()
void	AsyncReadWithCallback (void(T::*callback)(boost::system::error_code, std::size_t))
void	QueuePacket (MessageBuffer &&buffer)
ProxyHeaderReadingState	GetProxyHeaderReadingState () const
bool	IsOpen () const
void	CloseSocket ()
void	DelayedCloseSocket ()
	Marks the socket for closing after write buffer becomes empty.
MessageBuffer &	GetReadBuffer ()

Protected Types
enum class	ReadDataHandlerResult {   Ok = 0 ,   Error = 1 ,   WaitingForQuery = 2 }

Protected Member Functions
void	OnClose () override
void	ReadHandler () override
bool	ReadHeaderHandler ()
ReadDataHandlerResult	ReadDataHandler ()
Protected Member Functions inherited from Socket< WorldSocket >
bool	AsyncProcessQueue ()
void	SetNoDelay (bool enable)

Private Types
typedef Socket< WorldSocket >	BaseSocket

Private Member Functions
void	CheckIpCallback (PreparedQueryResult result)
void	LogOpcodeText (OpcodeClient opcode, std::unique_lock< std::mutex > const &guard) const
void	SendPacketAndLogOpcode (WorldPacket const &packet)
	sends and logs network.opcode without accessing WorldSession
void	HandleSendAuthSession ()
void	HandleAuthSession (WorldPacket &recvPacket)
void	HandleAuthSessionCallback (std::shared_ptr< AuthSession > authSession, PreparedQueryResult result)
void	LoadSessionPermissionsCallback (PreparedQueryResult result)
void	SendAuthResponseError (uint8 code)
bool	HandlePing (WorldPacket &recvPacket)

Private Attributes
std::array< uint8, 4 >	_authSeed
AuthCrypt	_authCrypt
TimePoint	_LastPingTime
uint32	_OverSpeedPings
std::mutex	_worldSessionLock
WorldSession *	_worldSession
bool	_authed
MessageBuffer	_headerBuffer
MessageBuffer	_packetBuffer
MPSCQueue< EncryptableAndCompressiblePacket, &EncryptableAndCompressiblePacket::SocketQueueLink >	_bufferQueue
std::size_t	_sendBufferSize
QueryCallbackProcessor	_queryProcessor
std::string	_ipCountry

Detailed Description

Member Typedef Documentation

BaseSocket

typedef Socket<WorldSocket> WorldSocket::BaseSocket

private

Member Enumeration Documentation

ReadDataHandlerResult

enum class WorldSocket::ReadDataHandlerResult

strongprotected

Enumerator
Ok
Error
WaitingForQuery

    {
        Ok = 0,
        Error = 1,
        WaitingForQuery = 2
    };

Constructor & Destructor Documentation

WorldSocket() [1/2]

WorldSocket::WorldSocket

(

tcp::socket &&

socket

)

    : Socket(std::move(socket)), _OverSpeedPings(0), _worldSession(nullptr), _authed(false), _sendBufferSize(4096)
{
    Acore::Crypto::GetRandomBytes(_authSeed);
    _headerBuffer.Resize(sizeof(ClientPktHeader));
}

References _authSeed, _headerBuffer, Acore::Crypto::GetRandomBytes(), and MessageBuffer::Resize().

~WorldSocket()

WorldSocket::~WorldSocket ( )

default

WorldSocket() [2/2]

WorldSocket::WorldSocket ( WorldSocket const &  right )

delete

Member Function Documentation

CheckIpCallback()

void WorldSocket::CheckIpCallback ( PreparedQueryResult  result )

private

{
    if (result)
    {
        bool banned = false;
        do
        {
            Field* fields = result->Fetch();
            if (fields[0].Get<uint64>() != 0)
                banned = true;
 
        } while (result->NextRow());
 
        if (banned)
        {
            SendAuthResponseError(AUTH_REJECT);
            LOG_ERROR("network", "WorldSocket::CheckIpCallback: Sent Auth Response (IP {} banned).", GetRemoteIpAddress().to_string());
            DelayedCloseSocket();
            return;
        }
    }
 
    AsyncRead();
    HandleSendAuthSession();
}

References Socket< WorldSocket >::AsyncRead(), AUTH_REJECT, Socket< WorldSocket >::DelayedCloseSocket(), Socket< WorldSocket >::GetRemoteIpAddress(), HandleSendAuthSession(), LOG_ERROR, and SendAuthResponseError().

Referenced by Start().

HandleAuthSession()

void WorldSocket::HandleAuthSession ( WorldPacket &  recvPacket )

private

{
    std::shared_ptr<AuthSession> authSession = std::make_shared<AuthSession>();
 
    // Read the content of the packet
    recvPacket >> authSession->Build;
    recvPacket >> authSession->LoginServerID;
    recvPacket >> authSession->Account;
    recvPacket >> authSession->LoginServerType;
    recvPacket.read(authSession->LocalChallenge);
    recvPacket >> authSession->RegionID;
    recvPacket >> authSession->BattlegroupID;
    recvPacket >> authSession->RealmID;               // realmId from auth_database.realmlist table
    recvPacket >> authSession->DosResponse;
    recvPacket.read(authSession->Digest);
    authSession->AddonInfo.resize(recvPacket.size() - recvPacket.rpos());
    recvPacket.read(authSession->AddonInfo.contents(), authSession->AddonInfo.size()); // .contents will throw if empty, thats what we want
 
    // Get the account information from the auth database
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_BY_NAME);
    stmt->SetData(0, int32(realm.Id.Realm));
    stmt->SetData(1, authSession->Account);
 
    _queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback(std::bind(&WorldSocket::HandleAuthSessionCallback, this, authSession, std::placeholders::_1)));
}

References _queryProcessor, AsyncCallbackProcessor< T >::AddCallback(), HandleAuthSessionCallback(), Realm::Id, LOGIN_SEL_ACCOUNT_INFO_BY_NAME, LoginDatabase, ByteBuffer::read(), realm, RealmHandle::Realm, ByteBuffer::rpos(), PreparedStatementBase::SetData(), and ByteBuffer::size().

Referenced by ReadDataHandler().

HandleAuthSessionCallback()

void WorldSocket::HandleAuthSessionCallback ( std::shared_ptr< AuthSession >  authSession, PreparedQueryResult  result  )

private

• Re-check ip locking (same check as in auth).

Negative mutetime indicates amount of minutes to be muted effective on next login - which is now.

{
    // Stop if the account is not found
    if (!result)
    {
        // We can not log here, as we do not know the account. Thus, no accountId.
        SendAuthResponseError(AUTH_UNKNOWN_ACCOUNT);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: Sent Auth Response (unknown account).");
        DelayedCloseSocket();
        return;
    }
 
    AccountInfo account(result->Fetch());
 
    // For hook purposes, we get Remoteaddress at this point.
    std::string address = sConfigMgr->GetOption<bool>("AllowLoggingIPAddressesInDatabase", true, true) ? GetRemoteIpAddress().to_string() : "0.0.0.0";
 
    LoginDatabasePreparedStatement* stmt = nullptr;
 
    // As we don't know if attempted login process by ip works, we update last_attempt_ip right away
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LAST_ATTEMPT_IP);
    stmt->SetData(0, address);
    stmt->SetData(1, authSession->Account);
    LoginDatabase.Execute(stmt);
    // This also allows to check for possible "hack" attempts on account
 
    // even if auth credentials are bad, try using the session key we have - client cannot read auth response error without it
    _authCrypt.Init(account.SessionKey);
 
    // First reject the connection if packet contains invalid data or realm state doesn't allow logging in
    if (sWorld->IsClosed())
    {
        SendAuthResponseError(AUTH_REJECT);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: World closed, denying client ({}).", GetRemoteIpAddress().to_string());
        DelayedCloseSocket();
        return;
    }
 
    if (authSession->RealmID != realm.Id.Realm)
    {
        SendAuthResponseError(REALM_LIST_REALM_NOT_FOUND);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: Client {} requested connecting with realm id {} but this realm has id {} set in config.",
            GetRemoteIpAddress().to_string(), authSession->RealmID, realm.Id.Realm);
        DelayedCloseSocket();
        return;
    }
 
    // Must be done before WorldSession is created
    bool wardenActive = sWorld->getBoolConfig(CONFIG_WARDEN_ENABLED);
    if (wardenActive && account.OS != "Win" && account.OS != "OSX")
    {
        SendAuthResponseError(AUTH_REJECT);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: Client {} attempted to log in using invalid client OS ({}).", address, account.OS);
        DelayedCloseSocket();
        return;
    }
 
    // Check that Key and account name are the same on client and server
    uint8 t[4] = { 0x00,0x00,0x00,0x00 };
 
    Acore::Crypto::SHA1 sha;
    sha.UpdateData(authSession->Account);
    sha.UpdateData(t);
    sha.UpdateData(authSession->LocalChallenge);
    sha.UpdateData(_authSeed);
    sha.UpdateData(account.SessionKey);
    sha.Finalize();
 
    if (sha.GetDigest() != authSession->Digest)
    {
        SendAuthResponseError(AUTH_FAILED);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: Authentication failed for account: {} ('{}') address: {}", account.Id, authSession->Account, address);
        DelayedCloseSocket();
        return;
    }
 
    if (IpLocationRecord const* location = sIPLocation->GetLocationRecord(address))
        _ipCountry = location->CountryCode;
 
    if (account.IsLockedToIP)
    {
        if (account.LastIP != address)
        {
            SendAuthResponseError(AUTH_FAILED);
            LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account IP differs. Original IP: {}, new IP: {}).", account.LastIP, address);
            // We could log on hook only instead of an additional db log, however action logger is config based. Better keep DB logging as well
            sScriptMgr->OnFailedAccountLogin(account.Id);
            DelayedCloseSocket();
            return;
        }
    }
    else if (!account.LockCountry.empty() && account.LockCountry != "00" && !_ipCountry.empty())
    {
        if (account.LockCountry != _ipCountry)
        {
            SendAuthResponseError(AUTH_FAILED);
            LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account country differs. Original country: {}, new country: {}).", account.LockCountry, _ipCountry);
            // We could log on hook only instead of an additional db log, however action logger is config based. Better keep DB logging as well
            sScriptMgr->OnFailedAccountLogin(account.Id);
            DelayedCloseSocket();
            return;
        }
    }
 
    if (account.MuteTime < 0)
    {
        account.MuteTime = GameTime::GetGameTime().count() + std::llabs(account.MuteTime);
 
        auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME_LOGIN);
        stmt->SetData(0, account.MuteTime);
        stmt->SetData(1, account.Id);
        LoginDatabase.Execute(stmt);
    }
 
    if (account.IsBanned)
    {
        SendAuthResponseError(AUTH_BANNED);
        LOG_ERROR("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account banned).");
        sScriptMgr->OnFailedAccountLogin(account.Id);
        DelayedCloseSocket();
        return;
    }
 
    // Check locked state for server
    AccountTypes allowedAccountType = sWorld->GetPlayerSecurityLimit();
    LOG_DEBUG("network", "Allowed Level: {} Player Level {}", allowedAccountType, account.Security);
    if (allowedAccountType > SEC_PLAYER && account.Security < allowedAccountType)
    {
        SendAuthResponseError(AUTH_UNAVAILABLE);
        LOG_DEBUG("network", "WorldSocket::HandleAuthSession: User tries to login but his security level is not enough");
        sScriptMgr->OnFailedAccountLogin(account.Id);
        DelayedCloseSocket();
        return;
    }
 
    LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Client '{}' authenticated successfully from {}.", authSession->Account, address);
 
    // Update the last_ip in the database as it was successful for login
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LAST_IP);
    stmt->SetData(0, address);
    stmt->SetData(1, authSession->Account);
 
    LoginDatabase.Execute(stmt);
 
    // At this point, we can safely hook a successful login
    sScriptMgr->OnAccountLogin(account.Id);
 
    _authed = true;
 
    sScriptMgr->OnLastIpUpdate(account.Id, address);
 
    _worldSession = new WorldSession(account.Id, std::move(authSession->Account), account.Flags, shared_from_this(), account.Security,
        account.Expansion, account.MuteTime, account.Locale, account.Recruiter, account.IsRectuiter, account.Security ? true : false, account.TotalTime);
 
    _worldSession->ReadAddonsInfo(authSession->AddonInfo);
 
    // Initialize Warden system only if it is enabled by config
    if (wardenActive)
    {
        _worldSession->InitWarden(account.SessionKey, account.OS);
    }
 
    _worldSession->ValidateAccountFlags();
 
    sWorldSessionMgr->AddSession(_worldSession);
 
    AsyncRead();
}

References _authCrypt, _authed, _authSeed, _ipCountry, _worldSession, Socket< WorldSocket >::AsyncRead(), AUTH_BANNED, AUTH_FAILED, AUTH_REJECT, AUTH_UNAVAILABLE, AUTH_UNKNOWN_ACCOUNT, CONFIG_WARDEN_ENABLED, Socket< WorldSocket >::DelayedCloseSocket(), AccountInfo::Expansion, Acore::Impl::GenericHash< HashCreator, DigestLength >::Finalize(), AccountInfo::Flags, Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigest(), GameTime::GetGameTime(), Socket< WorldSocket >::GetRemoteIpAddress(), AccountInfo::Id, Realm::Id, AuthCrypt::Init(), WorldSession::InitWarden(), AccountInfo::IsBanned, AccountInfo::IsLockedToIP, AccountInfo::IsRectuiter, AccountInfo::LastIP, AccountInfo::Locale, AccountInfo::LockCountry, LOG_DEBUG, LOG_ERROR, LOGIN_UPD_LAST_ATTEMPT_IP, LOGIN_UPD_LAST_IP, LOGIN_UPD_MUTE_TIME_LOGIN, LoginDatabase, AccountInfo::MuteTime, AccountInfo::OS, WorldSession::ReadAddonsInfo(), realm, RealmHandle::Realm, REALM_LIST_REALM_NOT_FOUND, AccountInfo::Recruiter, sConfigMgr, SEC_PLAYER, AccountInfo::Security, SendAuthResponseError(), AccountInfo::SessionKey, PreparedStatementBase::SetData(), sIPLocation, sScriptMgr, sWorld, sWorldSessionMgr, AccountInfo::TotalTime, Acore::Impl::GenericHash< HashCreator, DigestLength >::UpdateData(), and WorldSession::ValidateAccountFlags().

Referenced by HandleAuthSession().

HandlePing()

bool WorldSocket::HandlePing ( WorldPacket &  recvPacket )

private

{
    using namespace std::chrono;
 
    uint32 ping;
    uint32 latency;
 
    // Get the ping packet content
    recvPacket >> ping;
    recvPacket >> latency;
 
    if (_LastPingTime == steady_clock::time_point())
    {
        _LastPingTime = steady_clock::now();
    }
    else
    {
        steady_clock::time_point now = steady_clock::now();
        steady_clock::duration diff = now - _LastPingTime;
 
        _LastPingTime = now;
 
        if (diff < seconds(27))
        {
            ++_OverSpeedPings;
 
            uint32 maxAllowed = sWorld->getIntConfig(CONFIG_MAX_OVERSPEED_PINGS);
 
            if (maxAllowed && _OverSpeedPings > maxAllowed)
            {
                std::unique_lock<std::mutex> sessionGuard(_worldSessionLock);
 
                if (_worldSession && AccountMgr::IsPlayerAccount(_worldSession->GetSecurity()))
                {
                    LOG_ERROR("network", "WorldSocket::HandlePing: {} kicked for over-speed pings (address: {})",
                        _worldSession->GetPlayerInfo(), GetRemoteIpAddress().to_string());
 
                    return false;
                }
            }
        }
        else
        {
            _OverSpeedPings = 0;
        }
    }
 
    {
        std::lock_guard<std::mutex> sessionGuard(_worldSessionLock);
 
        if (_worldSession)
            _worldSession->SetLatency(latency);
        else
        {
            LOG_ERROR("network", "WorldSocket::HandlePing: peer sent CMSG_PING, but is not authenticated or got recently kicked, address = {}", GetRemoteIpAddress().to_string());
            return false;
        }
    }
 
    WorldPacket packet(SMSG_PONG, 4);
    packet << ping;
    SendPacketAndLogOpcode(packet);
 
    return true;
}

References _LastPingTime, _OverSpeedPings, _worldSession, _worldSessionLock, CONFIG_MAX_OVERSPEED_PINGS, WorldSession::GetPlayerInfo(), Socket< WorldSocket >::GetRemoteIpAddress(), WorldSession::GetSecurity(), AccountMgr::IsPlayerAccount(), LOG_ERROR, SendPacketAndLogOpcode(), WorldSession::SetLatency(), SMSG_PONG, and sWorld.

Referenced by ReadDataHandler().

HandleSendAuthSession()

void WorldSocket::HandleSendAuthSession ( )

private

{
    WorldPacket packet(SMSG_AUTH_CHALLENGE, 40);
    packet << uint32(1);                                    // 1...31
    packet.append(_authSeed);
 
    packet.append(Acore::Crypto::GetRandomBytes<32>());               // new encryption seeds
 
    SendPacketAndLogOpcode(packet);
}

References _authSeed, ByteBuffer::append(), SendPacketAndLogOpcode(), and SMSG_AUTH_CHALLENGE.

Referenced by CheckIpCallback().

LoadSessionPermissionsCallback()

void WorldSocket::LoadSessionPermissionsCallback ( PreparedQueryResult  result )

private

LogOpcodeText()

void WorldSocket::LogOpcodeText ( OpcodeClient  opcode, std::unique_lock< std::mutex > const &  guard  ) const

private

writes network.opcode log accessing WorldSession is not threadsafe, only do it when holding _worldSessionLock

{
    if (!guard)
    {
        LOG_TRACE("network.opcode", "C->S: {} {}", GetRemoteIpAddress().to_string(), GetOpcodeNameForLogging(opcode));
    }
    else
    {
        LOG_TRACE("network.opcode", "C->S: {} {}", (_worldSession ? _worldSession->GetPlayerInfo() : GetRemoteIpAddress().to_string()),
            GetOpcodeNameForLogging(opcode));
    }
}

References _worldSession, GetOpcodeNameForLogging(), WorldSession::GetPlayerInfo(), Socket< WorldSocket >::GetRemoteIpAddress(), and LOG_TRACE.

Referenced by ReadDataHandler().

OnClose()

void WorldSocket::OnClose ( )

overrideprotectedvirtual

Reimplemented from Socket< WorldSocket >.

{
    {
        std::lock_guard<std::mutex> sessionGuard(_worldSessionLock);
        _worldSession = nullptr;
    }
}

References _worldSession, and _worldSessionLock.

operator=()

WorldSocket & WorldSocket::operator= ( WorldSocket const &  right )

delete

ReadDataHandler()

WorldSocket::ReadDataHandlerResult WorldSocket::ReadDataHandler ( )

protected

Todo:

: handle this packet in the same way of CMSG_TIME_SYNC_RESP

{
    ClientPktHeader* header = reinterpret_cast<ClientPktHeader*>(_headerBuffer.GetReadPointer());
    OpcodeClient opcode = static_cast<OpcodeClient>(header->cmd);
 
    WorldPacket packet(opcode, std::move(_packetBuffer));
    WorldPacket* packetToQueue;
 
    if (sPacketLog->CanLogPacket())
        sPacketLog->LogPacket(packet, CLIENT_TO_SERVER, GetRemoteIpAddress(), GetRemotePort());
 
    std::unique_lock<std::mutex> sessionGuard(_worldSessionLock, std::defer_lock);
 
    switch (opcode)
    {
        case CMSG_PING:
        {
            LogOpcodeText(opcode, sessionGuard);
            try
            {
                return HandlePing(packet) ? ReadDataHandlerResult::Ok : ReadDataHandlerResult::Error;
            }
            catch (ByteBufferException const&)
            {
            }
            LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_PING", GetRemoteIpAddress().to_string());
            return ReadDataHandlerResult::Error;
        }
        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())
                    LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_SESSION from {}", _worldSession->GetPlayerInfo());
                return ReadDataHandlerResult::Error;
            }
 
            try
            {
                HandleAuthSession(packet);
                return ReadDataHandlerResult::WaitingForQuery;
            }
            catch (ByteBufferException const&) { }
 
            LOG_ERROR("network", "WorldSocket::ReadDataHandler(): client {} sent malformed CMSG_AUTH_SESSION", GetRemoteIpAddress().to_string());
            return ReadDataHandlerResult::Error;
        }
        case CMSG_KEEP_ALIVE: 
            sessionGuard.lock();
            LogOpcodeText(opcode, sessionGuard);
            if (_worldSession)
            {
                _worldSession->ResetTimeOutTime(true);
                return ReadDataHandlerResult::Ok;
            }
            LOG_ERROR("network", "WorldSocket::ReadDataHandler: client {} sent CMSG_KEEP_ALIVE without being authenticated", GetRemoteIpAddress().to_string());
            return ReadDataHandlerResult::Error;
        case CMSG_TIME_SYNC_RESP:
            packetToQueue = new WorldPacket(std::move(packet), GameTime::Now());
            break;
        default:
            packetToQueue = new WorldPacket(std::move(packet));
            break;
    }
 
    sessionGuard.lock();
 
    LogOpcodeText(opcode, sessionGuard);
 
    if (!_worldSession)
    {
        LOG_ERROR("network.opcode", "ProcessIncoming: Client not authed opcode = {}", uint32(opcode));
        delete packetToQueue;
        return ReadDataHandlerResult::Error;
    }
 
    OpcodeHandler const* handler = opcodeTable[opcode];
    if (!handler)
    {
        LOG_ERROR("network.opcode", "No defined handler for opcode {} sent by {}", GetOpcodeNameForLogging(static_cast<OpcodeClient>(packetToQueue->GetOpcode())), _worldSession->GetPlayerInfo());
        delete packetToQueue;
        return ReadDataHandlerResult::Error;
    }
 
    // Our Idle timer will reset on any non PING opcodes on login screen, allowing us to catch people idling.
    if (packetToQueue->GetOpcode() != CMSG_WARDEN_DATA)
    {
        _worldSession->ResetTimeOutTime(false);
    }
 
    // Copy the packet to the heap before enqueuing
    _worldSession->QueuePacket(packetToQueue);
 
    return ReadDataHandlerResult::Ok;
}

References _authed, _headerBuffer, _packetBuffer, _worldSession, _worldSessionLock, CLIENT_TO_SERVER, ClientPktHeader::cmd, CMSG_AUTH_SESSION, CMSG_KEEP_ALIVE, CMSG_PING, CMSG_TIME_SYNC_RESP, CMSG_WARDEN_DATA, Error, WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), WorldSession::GetPlayerInfo(), MessageBuffer::GetReadPointer(), Socket< WorldSocket >::GetRemoteIpAddress(), Socket< WorldSocket >::GetRemotePort(), HandleAuthSession(), HandlePing(), LOG_ERROR, LogOpcodeText(), GameTime::Now(), Ok, opcodeTable, WorldSession::QueuePacket(), WorldSession::ResetTimeOutTime(), sPacketLog, and WaitingForQuery.

Referenced by ReadHandler().

ReadHandler()

void WorldSocket::ReadHandler ( )

overrideprotectedvirtual

Implements Socket< WorldSocket >.

{
    if (!IsOpen())
        return;
 
    MessageBuffer& packet = GetReadBuffer();
    while (packet.GetActiveSize() > 0)
    {
        if (_headerBuffer.GetRemainingSpace() > 0)
        {
            // need to receive the header
            std::size_t readHeaderSize = std::min(packet.GetActiveSize(), _headerBuffer.GetRemainingSpace());
            _headerBuffer.Write(packet.GetReadPointer(), readHeaderSize);
            packet.ReadCompleted(readHeaderSize);
 
            if (_headerBuffer.GetRemainingSpace() > 0)
            {
                // Couldn't receive the whole header this time.
                ASSERT(packet.GetActiveSize() == 0);
                break;
            }
 
            // We just received nice new header
            if (!ReadHeaderHandler())
            {
                CloseSocket();
                return;
            }
        }
 
        // We have full read header, now check the data payload
        if (_packetBuffer.GetRemainingSpace() > 0)
        {
            // need more data in the payload
            std::size_t readDataSize = std::min(packet.GetActiveSize(), _packetBuffer.GetRemainingSpace());
            _packetBuffer.Write(packet.GetReadPointer(), readDataSize);
            packet.ReadCompleted(readDataSize);
 
            if (_packetBuffer.GetRemainingSpace() > 0)
            {
                // Couldn't receive the whole data this time.
                ASSERT(packet.GetActiveSize() == 0);
                break;
            }
        }
 
        // just received fresh new payload
        ReadDataHandlerResult result = ReadDataHandler();
        _headerBuffer.Reset();
 
        if (result != ReadDataHandlerResult::Ok)
        {
            if (result != ReadDataHandlerResult::WaitingForQuery)
            {
                CloseSocket();
            }
 
            return;
        }
    }
 
    AsyncRead();
}

References _headerBuffer, _packetBuffer, ASSERT, Socket< WorldSocket >::AsyncRead(), Socket< WorldSocket >::CloseSocket(), MessageBuffer::GetActiveSize(), Socket< WorldSocket >::GetReadBuffer(), MessageBuffer::GetReadPointer(), MessageBuffer::GetRemainingSpace(), Socket< WorldSocket >::IsOpen(), Ok, MessageBuffer::ReadCompleted(), ReadDataHandler(), ReadHeaderHandler(), MessageBuffer::Reset(), WaitingForQuery, and MessageBuffer::Write().

ReadHeaderHandler()

bool WorldSocket::ReadHeaderHandler ( )

protected

{
    ASSERT(_headerBuffer.GetActiveSize() == sizeof(ClientPktHeader));
 
    if (_authCrypt.IsInitialized())
    {
        _authCrypt.DecryptRecv(_headerBuffer.GetReadPointer(), sizeof(ClientPktHeader));
    }
 
    ClientPktHeader* header = reinterpret_cast<ClientPktHeader*>(_headerBuffer.GetReadPointer());
    EndianConvertReverse(header->size);
    EndianConvert(header->cmd);
 
    if (!header->IsValidSize() || !header->IsValidOpcode())
    {
        LOG_ERROR("network", "WorldSocket::ReadHeaderHandler(): client {} sent malformed packet (size: {}, cmd: {})",
            GetRemoteIpAddress().to_string(), header->size, header->cmd);
 
        return false;
    }
 
    header->size -= sizeof(header->cmd);
    _packetBuffer.Resize(header->size);
 
    return true;
}

References _authCrypt, _headerBuffer, _packetBuffer, ASSERT, ClientPktHeader::cmd, AuthCrypt::DecryptRecv(), EndianConvert(), EndianConvertReverse(), MessageBuffer::GetActiveSize(), MessageBuffer::GetReadPointer(), Socket< WorldSocket >::GetRemoteIpAddress(), AuthCrypt::IsInitialized(), ClientPktHeader::IsValidOpcode(), ClientPktHeader::IsValidSize(), LOG_ERROR, MessageBuffer::Resize(), and ClientPktHeader::size.

Referenced by ReadHandler().

SendAuthResponseError()

void WorldSocket::SendAuthResponseError ( uint8  code )

private

{
    WorldPacket packet(SMSG_AUTH_RESPONSE, 1);
    packet << uint8(code);
 
    SendPacketAndLogOpcode(packet);
}

References SendPacketAndLogOpcode(), and SMSG_AUTH_RESPONSE.

Referenced by CheckIpCallback(), and HandleAuthSessionCallback().

SendPacket()

void WorldSocket::SendPacket

(

WorldPacket const &

packet

)

{
    if (!IsOpen())
        return;
 
    if (sPacketLog->CanLogPacket())
        sPacketLog->LogPacket(packet, SERVER_TO_CLIENT, GetRemoteIpAddress(), GetRemotePort());
 
    _bufferQueue.Enqueue(new EncryptableAndCompressiblePacket(packet, _authCrypt.IsInitialized()));
}

References _authCrypt, _bufferQueue, Socket< WorldSocket >::GetRemoteIpAddress(), Socket< WorldSocket >::GetRemotePort(), AuthCrypt::IsInitialized(), Socket< WorldSocket >::IsOpen(), SERVER_TO_CLIENT, and sPacketLog.

Referenced by SendPacketAndLogOpcode().

SendPacketAndLogOpcode()

void WorldSocket::SendPacketAndLogOpcode ( WorldPacket const &  packet )

private

sends and logs network.opcode without accessing WorldSession

{
    LOG_TRACE("network.opcode", "S->C: {} {}", GetRemoteIpAddress().to_string(), GetOpcodeNameForLogging(static_cast<OpcodeServer>(packet.GetOpcode())));
    SendPacket(packet);
}

References WorldPacket::GetOpcode(), GetOpcodeNameForLogging(), Socket< WorldSocket >::GetRemoteIpAddress(), LOG_TRACE, and SendPacket().

Referenced by HandlePing(), HandleSendAuthSession(), and SendAuthResponseError().

SetSendBufferSize()

void WorldSocket::SetSendBufferSize ( std::size_t  sendBufferSize )

inline

{ _sendBufferSize = sendBufferSize; }

Start()

void WorldSocket::Start ( )

overridevirtual

Implements Socket< WorldSocket >.

{
    std::string ip_address = GetRemoteIpAddress().to_string();
 
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
    stmt->SetData(0, ip_address);
 
    _queryProcessor.AddCallback(LoginDatabase.AsyncQuery(stmt).WithPreparedCallback(std::bind(&WorldSocket::CheckIpCallback, this, std::placeholders::_1)));
}

References _queryProcessor, AsyncCallbackProcessor< T >::AddCallback(), CheckIpCallback(), Socket< WorldSocket >::GetRemoteIpAddress(), LOGIN_SEL_IP_INFO, LoginDatabase, and PreparedStatementBase::SetData().

Update()

bool WorldSocket::Update ( )

overridevirtual

Reimplemented from Socket< WorldSocket >.

{
    EncryptableAndCompressiblePacket* queued;
    if (_bufferQueue.Dequeue(queued))
    {
        // Allocate buffer only when it's needed but not on every Update() call.
        MessageBuffer buffer(_sendBufferSize);
        std::size_t currentPacketSize;
        do
        {
            queued->CompressIfNeeded();
            ServerPktHeader header(queued->size() + 2, queued->GetOpcode());
            if (queued->NeedsEncryption())
                _authCrypt.EncryptSend(header.header, header.getHeaderLength());
 
            currentPacketSize = queued->size() + header.getHeaderLength();
 
            if (buffer.GetRemainingSpace() < currentPacketSize)
            {
                QueuePacket(std::move(buffer));
                buffer.Resize(_sendBufferSize);
            }
 
            if (buffer.GetRemainingSpace() >= currentPacketSize)
            {
                buffer.Write(header.header, header.getHeaderLength());
                if (!queued->empty())
                    buffer.Write(queued->contents(), queued->size());
            }
            else    // Single packet larger than current buffer size
            {
                // Resize buffer to fit current packet
                buffer.Resize(currentPacketSize);
 
                // Grow future buffers to current packet size if still below limit
                if (currentPacketSize <= 65536)
                    _sendBufferSize = currentPacketSize;
 
                buffer.Write(header.header, header.getHeaderLength());
                if (!queued->empty())
                    buffer.Write(queued->contents(), queued->size());
            }
 
            delete queued;
        } while (_bufferQueue.Dequeue(queued));
 
        if (buffer.GetActiveSize() > 0)
            QueuePacket(std::move(buffer));
    }
 
    if (!BaseSocket::Update())
        return false;
 
    _queryProcessor.ProcessReadyCallbacks();
 
    return true;
}

References _authCrypt, _bufferQueue, _queryProcessor, _sendBufferSize, EncryptableAndCompressiblePacket::CompressIfNeeded(), ByteBuffer::contents(), ByteBuffer::empty(), AuthCrypt::EncryptSend(), MessageBuffer::GetActiveSize(), ServerPktHeader::getHeaderLength(), WorldPacket::GetOpcode(), MessageBuffer::GetRemainingSpace(), ServerPktHeader::header, EncryptableAndCompressiblePacket::NeedsEncryption(), AsyncCallbackProcessor< T >::ProcessReadyCallbacks(), Socket< WorldSocket >::QueuePacket(), MessageBuffer::Resize(), ByteBuffer::size(), Socket< WorldSocket >::Update(), and MessageBuffer::Write().

Member Data Documentation

_authCrypt

AuthCrypt WorldSocket::_authCrypt

private

Referenced by HandleAuthSessionCallback(), ReadHeaderHandler(), SendPacket(), and Update().

_authed

bool WorldSocket::_authed

private

Referenced by HandleAuthSessionCallback(), and ReadDataHandler().

_authSeed

std::array<uint8, 4> WorldSocket::_authSeed

private

Referenced by HandleAuthSessionCallback(), HandleSendAuthSession(), and WorldSocket().

_bufferQueue

MPSCQueue<EncryptableAndCompressiblePacket, &EncryptableAndCompressiblePacket::SocketQueueLink> WorldSocket::_bufferQueue

private

Referenced by SendPacket(), and Update().

_headerBuffer

MessageBuffer WorldSocket::_headerBuffer

private

Referenced by ReadDataHandler(), ReadHandler(), ReadHeaderHandler(), and WorldSocket().

_ipCountry

std::string WorldSocket::_ipCountry

private

Referenced by HandleAuthSessionCallback().

_LastPingTime

TimePoint WorldSocket::_LastPingTime

private

Referenced by HandlePing().

_OverSpeedPings

uint32 WorldSocket::_OverSpeedPings

private

Referenced by HandlePing().

_packetBuffer

MessageBuffer WorldSocket::_packetBuffer

private

Referenced by ReadDataHandler(), ReadHandler(), and ReadHeaderHandler().

_queryProcessor

QueryCallbackProcessor WorldSocket::_queryProcessor

private

Referenced by HandleAuthSession(), Start(), and Update().

_sendBufferSize

std::size_t WorldSocket::_sendBufferSize

private

Referenced by Update().

_worldSession

WorldSession* WorldSocket::_worldSession

private

Referenced by HandleAuthSessionCallback(), HandlePing(), LogOpcodeText(), OnClose(), and ReadDataHandler().

_worldSessionLock

std::mutex WorldSocket::_worldSessionLock

private

Referenced by HandlePing(), OnClose(), and ReadDataHandler().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Server/WorldSocket.h
• azerothcore-wotlk/src/server/game/Server/WorldSocket.cpp