WorldSocket Class Reference

#include <WorldSocket.h>

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)
ConnectionType	GetConnectionType () const
void	SendAuthResponseError (uint32 code)
void	SetWorldSession (WorldSession *session)
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	AsyncReadWithCallback (void(WorldSocket::*callback)(boost::system::error_code, std::size_t))
void	QueuePacket (MessageBuffer &&buffer)
bool	IsOpen () const
void	CloseSocket ()
void	DelayedCloseSocket ()
	Marks the socket for closing after write buffer becomes empty. More...
MessageBuffer &	GetReadBuffer ()

Protected Types
enum	ReadDataHandlerResult { ReadDataHandlerResult::Ok = 0, ReadDataHandlerResult::Error = 1, ReadDataHandlerResult::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)
Stream &	underlying_stream ()

Private Types
typedef Socket< WorldSocket >	BaseSocket

Private Member Functions
void	CheckIpCallback (PreparedQueryResult result)
void	InitializeHandler (boost::system::error_code error, std::size_t transferedBytes)
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 More...
void	WritePacketToBuffer (EncryptablePacket const &packet, MessageBuffer &buffer)
uint32	CompressPacket (uint8 *buffer, WorldPacket const &packet)
void	HandleSendAuthSession ()
void	HandleAuthSession (std::shared_ptr< WorldPackets::Auth::AuthSession > authSession)
void	HandleAuthSessionCallback (std::shared_ptr< WorldPackets::Auth::AuthSession > authSession, PreparedQueryResult result)
void	HandleAuthContinuedSession (std::shared_ptr< WorldPackets::Auth::AuthContinuedSession > authSession)
void	HandleAuthContinuedSessionCallback (std::shared_ptr< WorldPackets::Auth::AuthContinuedSession > authSession, PreparedQueryResult result)
void	LoadSessionPermissionsCallback (PreparedQueryResult result)
void	HandleConnectToFailed (WorldPackets::Auth::ConnectToFailed &connectToFailed)
bool	HandlePing (WorldPacket &recvPacket)
void	ExtractOpcodeAndSize (ClientPktHeader const *header, uint32 &opcode, uint32 &size) const

Private Attributes
ConnectionType	_type
BigNumber	_serverChallenge
WorldPacketCrypt	_authCrypt
BigNumber	_encryptSeed
BigNumber	_decryptSeed
std::chrono::steady_clock::time_point	_LastPingTime
uint32	_OverSpeedPings
std::mutex	_worldSessionLock
WorldSession *	_worldSession
bool	_authed
MessageBuffer	_headerBuffer
MessageBuffer	_packetBuffer
MPSCQueue< EncryptablePacket >	_bufferQueue
z_stream_s *	_compressionStream
PreparedQueryResultFuture	_queryFuture
std::function< void(PreparedQueryResult &&)>	_queryCallback
std::string	_ipCountry

Static Private Attributes
static uint32 const	ConnectionInitializeMagic = 0xF5EB1CE
static std::string const	ServerConnectionInitialize
static std::string const	ClientConnectionInitialize
static uint32 const	MinSizeForCompression = 0x400
static uint8 const	AuthCheckSeed [16] = { 0xC5, 0xC6, 0x98, 0x95, 0x76, 0x3F, 0x1D, 0xCD, 0xB6, 0xA1, 0x37, 0x28, 0xB3, 0x12, 0xFF, 0x8A }
static uint8 const	SessionKeySeed [16] = { 0x58, 0xCB, 0xCF, 0x40, 0xFE, 0x2E, 0xCE, 0xA6, 0x5A, 0x90, 0xB8, 0x01, 0x68, 0x6C, 0x28, 0x0B }
static uint8 const	ContinuedSessionSeed [16] = { 0x16, 0xAD, 0x0C, 0xD4, 0x46, 0xF9, 0x4F, 0xB2, 0xEF, 0x7D, 0xEA, 0x2A, 0x17, 0x66, 0x4D, 0x2F }

Member Typedef Documentation

typedef Socket<WorldSocket> WorldSocket::BaseSocket

private

Member Enumeration Documentation

enum WorldSocket::ReadDataHandlerResult

strongprotected

Enumerator
Ok
Error
WaitingForQuery

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

Constructor & Destructor Documentation

WorldSocket::WorldSocket

(

tcp::socket &&

socket

)

 : Socket(std::move(socket)),
 _type(CONNECTION_TYPE_REALM), _OverSpeedPings(0),
 _worldSession(nullptr), _authed(false), _compressionStream(nullptr)
{
 _serverChallenge.SetRand(8 * 16);
 _headerBuffer.Resize(SizeOfClientHeader[0]);
}

Here is the call graph for this function:

WorldSocket::~WorldSocket

(

)

{
 if (_compressionStream)
 {
 deflateEnd(_compressionStream);
 delete _compressionStream;
 }
}

WorldSocket::WorldSocket ( WorldSocket const &  right )

delete

Member Function Documentation

void WorldSocket::CheckIpCallback ( PreparedQueryResult  result )

private

{
 if (result)
 {
 bool banned = false;
 do
 {
 Field* fields = result->Fetch();
 if (fields[0].GetUInt64() != 0)
 banned = true;

 if (!fields[1].GetString().empty())
 _ipCountry = fields[1].GetString();

 } while (result->NextRow());

 if (banned)
 {
 TC_LOG_ERROR("network", "WorldSocket::CheckIpCallback: Sent Auth Response (IP %s banned).", GetRemoteIpAddress().to_string().c_str());
 DelayedCloseSocket();
 return;
 }
 }

 _packetBuffer.Resize(4 + 2 + ClientConnectionInitialize.length());

 AsyncReadWithCallback(&WorldSocket::InitializeHandler);

 MessageBuffer initializer;
 ServerPktHeader header;
 header.Setup.Size = ServerConnectionInitialize.size();
 initializer.Write(&ConnectionInitializeMagic, sizeof(ConnectionInitializeMagic));
 initializer.Write(&header, sizeof(header.Setup.Size));
 initializer.Write(ServerConnectionInitialize.c_str(), ServerConnectionInitialize.length());

 // - io_service.run thread, safe.
 QueuePacket(std::move(initializer));
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 WorldSocket::CompressPacket ( uint8 *  buffer, WorldPacket const &  packet  )

private

{
 uint32 opcode = packet.GetOpcode();
 uint32 bufferSize = deflateBound(_compressionStream, packet.size() + sizeof(uint16));

 _compressionStream->next_out = buffer;
 _compressionStream->avail_out = bufferSize;
 _compressionStream->next_in = (Bytef*)&opcode;
 _compressionStream->avail_in = sizeof(uint16);

 int32 z_res = deflate(_compressionStream, Z_NO_FLUSH);
 if (z_res != Z_OK)
 {
 TC_LOG_ERROR("network", "Can't compress packet opcode (zlib: deflate) Error code: %i (%s, msg: %s)", z_res, zError(z_res), _compressionStream->msg);
 return 0;
 }

 _compressionStream->next_in = (Bytef*)packet.contents();
 _compressionStream->avail_in = packet.size();

 z_res = deflate(_compressionStream, Z_SYNC_FLUSH);
 if (z_res != Z_OK)
 {
 TC_LOG_ERROR("network", "Can't compress packet data (zlib: deflate) Error code: %i (%s, msg: %s)", z_res, zError(z_res), _compressionStream->msg);
 return 0;
 }

 return bufferSize - _compressionStream->avail_out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::ExtractOpcodeAndSize ( ClientPktHeader const *  header, uint32 &  opcode, uint32 &  size  ) const

private

{
 if (_authCrypt.IsInitialized())
 {
 opcode = header->Normal.Command;
 size = header->Normal.Size - 2;
 }
 else
 {
 opcode = header->Setup.Command;
 size = header->Setup.Size - 2;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConnectionType WorldSocket::GetConnectionType ( ) const

inline

{ return _type; }

Here is the caller graph for this function:

void WorldSocket::HandleAuthContinuedSession ( std::shared_ptr< WorldPackets::Auth::AuthContinuedSession >  authSession )

private

{
 WorldSession::ConnectToKey key;
 key.Raw = authSession->Key;

 _type = ConnectionType(key.Fields.ConnectionType);
 if (_type != CONNECTION_TYPE_INSTANCE)
 {
 SendAuthResponseError(ERROR_DENIED);
 DelayedCloseSocket();
 return;
 }

 // Client switches packet headers after sending CMSG_AUTH_CONTINUED_SESSION
 _headerBuffer.Resize(SizeOfClientHeader[1]);

 uint32 accountId = uint32(key.Fields.AccountId);
 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_CONTINUED_SESSION);
 stmt->setUInt32(0, accountId);

 _queryCallback = std::bind(&WorldSocket::HandleAuthContinuedSessionCallback, this, authSession, std::placeholders::_1);
 _queryFuture = LoginDatabase.AsyncQuery(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::HandleAuthContinuedSessionCallback ( std::shared_ptr< WorldPackets::Auth::AuthContinuedSession >  authSession, PreparedQueryResult  result  )

private

{
 if (!result)
 {
 SendAuthResponseError(ERROR_DENIED);
 DelayedCloseSocket();
 return;
 }

 WorldSession::ConnectToKey key;
 key.Raw = authSession->Key;

 uint32 accountId = uint32(key.Fields.AccountId);
 Field* fields = result->Fetch();
 std::string login = fields[0].GetString();
 BigNumber k;
 k.SetHexStr(fields[1].GetCString());

 _authCrypt.Init(&k, _encryptSeed.AsByteArray().get(), _decryptSeed.AsByteArray().get());

 HmacSha256 hmac(40, k.AsByteArray(40).get());
 hmac.UpdateData(reinterpret_cast<uint8 const*>(&authSession->Key), sizeof(authSession->Key));
 hmac.UpdateData(authSession->LocalChallenge.data(), authSession->LocalChallenge.size());
 hmac.UpdateData(_serverChallenge.AsByteArray(16).get(), 16);
 hmac.UpdateData(ContinuedSessionSeed, 16);
 hmac.Finalize();

 if (memcmp(hmac.GetDigest(), authSession->Digest.data(), authSession->Digest.size()))
 {
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthContinuedSession: Authentication failed for account: %u ('%s') address: %s", accountId, login.c_str(), GetRemoteIpAddress().to_string().c_str());
 DelayedCloseSocket();
 return;
 }

 sWorld->AddInstanceSocket(shared_from_this(), authSession->Key);
 AsyncRead();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::HandleAuthSession ( std::shared_ptr< WorldPackets::Auth::AuthSession >  authSession )

private

{
 // Client switches packet headers after sending CMSG_AUTH_SESSION
 _headerBuffer.Resize(SizeOfClientHeader[1]);

 // Get the account information from the auth database
 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_INFO_BY_NAME);
 stmt->setInt32(0, int32(realm.Id.Realm));
 stmt->setString(1, authSession->RealmJoinTicket);

 _queryCallback = std::bind(&WorldSocket::HandleAuthSessionCallback, this, authSession, std::placeholders::_1);
 _queryFuture = LoginDatabase.AsyncQuery(stmt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

private

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

Negative mutetime indicates amount of seconds 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.
 TC_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 = GetRemoteIpAddress().to_string();

 HmacSha256 hmac(SHA256_DIGEST_LENGTH, account.Game.SessionKey.AsByteArray(SHA256_DIGEST_LENGTH).get());
 hmac.UpdateData(authSession->LocalChallenge.data(), authSession->LocalChallenge.size());
 hmac.UpdateData(_serverChallenge.AsByteArray(16).get(), 16);
 hmac.UpdateData(AuthCheckSeed, 16);
 hmac.Finalize();

 // Check that Key and account name are the same on client and server
 if (memcmp(hmac.GetDigest(), authSession->Digest.data(), authSession->Digest.size()) != 0)
 {
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthSession: Authentication failed for account: %u ('%s') address: %s", account.Game.Id, authSession->RealmJoinTicket.c_str(), address.c_str());
 DelayedCloseSocket();
 return;
 }

 HmacSha256 sessionKeyHmac(SHA256_DIGEST_LENGTH, account.Game.SessionKey.AsByteArray(SHA256_DIGEST_LENGTH).get());
 sessionKeyHmac.UpdateData(_serverChallenge.AsByteArray(16).get(), 16);
 sessionKeyHmac.UpdateData(authSession->LocalChallenge.data(), authSession->LocalChallenge.size());
 sessionKeyHmac.UpdateData(SessionKeySeed, 16);
 sessionKeyHmac.Finalize();

 uint8 sessionKey[40];
 SessionKeyGenerator<SHA256Hash> sessionKeyGenerator(sessionKeyHmac.GetDigest(), sessionKeyHmac.GetLength());
 sessionKeyGenerator.Generate(sessionKey, 40);

 BigNumber K;
 K.SetBinary(sessionKey, 40);

 _authCrypt.Init(&K);

 // As we don't know if attempted login process by ip works, we update last_attempt_ip right away
 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LAST_ATTEMPT_IP);
 stmt->setString(0, address);
 stmt->setString(1, authSession->RealmJoinTicket);
 LoginDatabase.Execute(stmt);
 // This also allows to check for possible "hack" attempts on account

 stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_INFO_CONTINUED_SESSION);
 stmt->setString(0, K.AsHexStr());
 stmt->setUInt32(1, account.Game.Id);
 LoginDatabase.Execute(stmt);

 // First reject the connection if packet contains invalid data or realm state doesn't allow logging in
 if (sWorld->IsClosed())
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthSession: World closed, denying client (%s).", GetRemoteIpAddress().to_string().c_str());
 DelayedCloseSocket();
 return;
 }

 if (authSession->RealmID != realm.Id.Realm)
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthSession: Client %s requested connecting with realm id %u but this realm has id %u set in config.",
 GetRemoteIpAddress().to_string().c_str(), authSession->RealmID, realm.Id.Realm);
 DelayedCloseSocket();
 return;
 }

 // Must be done before WorldSession is created
 bool wardenActive = sWorld->getBoolConfig(CONFIG_WARDEN_ENABLED);
 if (wardenActive && account.Game.OS != "Win" && account.Game.OS != "Wn64" && account.Game.OS != "Mc64")
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthSession: Client %s attempted to log in using invalid client OS (%s).", address.c_str(), account.Game.OS.c_str());
 DelayedCloseSocket();
 return;
 }

 if (account.BattleNet.IsLockedToIP)
 {
 if (account.BattleNet.LastIP != address)
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account IP differs. Original IP: %s, new IP: %s).", account.BattleNet.LastIP.c_str(), address.c_str());
 // 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.Game.Id);
 DelayedCloseSocket();
 return;
 }
 }
 else if (!account.BattleNet.LockCountry.empty() && account.BattleNet.LockCountry != "00" && !_ipCountry.empty())
 {
 if (account.BattleNet.LockCountry != _ipCountry)
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account country differs. Original country: %s, new country: %s).", account.BattleNet.LockCountry.c_str(), _ipCountry.c_str());
 // 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.Game.Id);
 DelayedCloseSocket();
 return;
 }
 }

 int64 mutetime = account.Game.MuteTime;
 if (mutetime < 0)
 {
 mutetime = time(NULL) + llabs(mutetime);

 stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME_LOGIN);
 stmt->setInt64(0, mutetime);
 stmt->setUInt32(1, account.Game.Id);
 LoginDatabase.Execute(stmt);
 }

 if (account.IsBanned())
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_ERROR("network", "WorldSocket::HandleAuthSession: Sent Auth Response (Account banned).");
 sScriptMgr->OnFailedAccountLogin(account.Game.Id);
 DelayedCloseSocket();
 return;
 }

 // Check locked state for server
 AccountTypes allowedAccountType = sWorld->GetPlayerSecurityLimit();
 TC_LOG_DEBUG("network", "Allowed Level: %u Player Level %u", allowedAccountType, account.Game.Security);
 if (allowedAccountType > SEC_PLAYER && account.Game.Security < allowedAccountType)
 {
 SendAuthResponseError(ERROR_DENIED);
 TC_LOG_DEBUG("network", "WorldSocket::HandleAuthSession: User tries to login but his security level is not enough");
 sScriptMgr->OnFailedAccountLogin(account.Game.Id);
 DelayedCloseSocket();
 return;
 }

 TC_LOG_DEBUG("network", "WorldSocket::HandleAuthSession: Client '%s' authenticated successfully from %s.", authSession->RealmJoinTicket.c_str(), address.c_str());

 // Update the last_ip in the database as it was successful for login
 stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_LAST_IP);

 stmt->setString(0, address);
 stmt->setString(1, authSession->RealmJoinTicket);

 LoginDatabase.Execute(stmt);

 // At this point, we can safely hook a successful login
 sScriptMgr->OnAccountLogin(account.Game.Id);

 _authed = true;
 _worldSession = new WorldSession(account.Game.Id, std::move(authSession->RealmJoinTicket), account.BattleNet.Id, shared_from_this(), account.Game.Security,
 account.Game.Expansion, mutetime, account.Game.OS, account.BattleNet.Locale, account.Game.Recruiter, account.Game.IsRectuiter);
 _worldSession->ReadAddonsInfo(authSession->AddonInfo);

 // Initialize Warden system only if it is enabled by config
 if (wardenActive)
 _worldSession->InitWarden(&account.Game.SessionKey);

 _queryCallback = std::bind(&WorldSocket::LoadSessionPermissionsCallback, this, std::placeholders::_1);
 _queryFuture = _worldSession->LoadPermissionsAsync();
 AsyncRead();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::HandleConnectToFailed ( WorldPackets::Auth::ConnectToFailed &  connectToFailed )

private

{
 if (_worldSession)
 {
 if (_worldSession->PlayerLoading())
 {
 switch (connectToFailed.Serial)
 {
 case WorldPackets::Auth::ConnectToSerial::WorldAttempt1:
 _worldSession->SendConnectToInstance(WorldPackets::Auth::ConnectToSerial::WorldAttempt2);
 break;
 case WorldPackets::Auth::ConnectToSerial::WorldAttempt2:
 _worldSession->SendConnectToInstance(WorldPackets::Auth::ConnectToSerial::WorldAttempt3);
 break;
 case WorldPackets::Auth::ConnectToSerial::WorldAttempt3:
 _worldSession->SendConnectToInstance(WorldPackets::Auth::ConnectToSerial::WorldAttempt4);
 break;
 case WorldPackets::Auth::ConnectToSerial::WorldAttempt4:
 _worldSession->SendConnectToInstance(WorldPackets::Auth::ConnectToSerial::WorldAttempt5);
 break;
 case WorldPackets::Auth::ConnectToSerial::WorldAttempt5:
 {
 TC_LOG_ERROR("network", "%s failed to connect 5 times to world socket, aborting login", _worldSession->GetPlayerInfo().c_str());
 _worldSession->AbortLogin(WorldPackets::Character::LoginFailureReason::NoWorld);
 break;
 }
 default:
 return;
 }
 }
 //else
 //{
 // transfer_aborted when/if we get map node redirection
 // SendPacketAndLogOpcode(*WorldPackets::Auth::ResumeComms().Write());
 //}
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 && !_worldSession->HasPermission(rbac::RBAC_PERM_SKIP_CHECK_OVERSPEED_PING))
 {
 TC_LOG_ERROR("network", "WorldSocket::HandlePing: %s kicked for over-speed pings (address: %s)",
 _worldSession->GetPlayerInfo().c_str(), GetRemoteIpAddress().to_string().c_str());

 return false;
 }
 }
 }
 else
 _OverSpeedPings = 0;
 }

 {
 std::lock_guard<std::mutex> sessionGuard(_worldSessionLock);

 if (_worldSession)
 {
 _worldSession->SetLatency(latency);
 _worldSession->ResetClientTimeDelay();
 }
 else
 {
 TC_LOG_ERROR("network", "WorldSocket::HandlePing: peer sent CMSG_PING, but is not authenticated or got recently kicked, address = %s", GetRemoteIpAddress().to_string().c_str());
 return false;
 }
 }

 WorldPacket packet(SMSG_PONG, 4);
 packet << ping;
 SendPacketAndLogOpcode(packet);
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::HandleSendAuthSession ( )

private

{
 _encryptSeed.SetRand(16 * 8);
 _decryptSeed.SetRand(16 * 8);

 WorldPackets::Auth::AuthChallenge challenge;
 memcpy(challenge.Challenge.data(), _serverChallenge.AsByteArray(16).get(), 16);
 memcpy(&challenge.DosChallenge[0], _encryptSeed.AsByteArray(16).get(), 16);
 memcpy(&challenge.DosChallenge[4], _decryptSeed.AsByteArray(16).get(), 16);
 challenge.DosZeroBits = 1;

 SendPacketAndLogOpcode(*challenge.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::InitializeHandler ( boost::system::error_code  error, std::size_t  transferedBytes  )

private

{
 if (error)
 {
 CloseSocket();
 return;
 }

 GetReadBuffer().WriteCompleted(transferedBytes);

 MessageBuffer& packet = GetReadBuffer();
 if (packet.GetActiveSize() > 0)
 {
 if (_packetBuffer.GetRemainingSpace() > 0)
 {
 // need to receive the header
 std::size_t readHeaderSize = std::min(packet.GetActiveSize(), _packetBuffer.GetRemainingSpace());
 _packetBuffer.Write(packet.GetReadPointer(), readHeaderSize);
 packet.ReadCompleted(readHeaderSize);

 if (_packetBuffer.GetRemainingSpace() > 0)
 {
 // Couldn't receive the whole header this time.
 ASSERT(packet.GetActiveSize() == 0);
 AsyncReadWithCallback(&WorldSocket::InitializeHandler);
 return;
 }

 uint32 magic;
 uint16 length;
 ByteBuffer buffer(std::move(_packetBuffer));

 buffer >> magic;
 buffer >> length;
 std::string initializer = buffer.ReadString(length);
 if (magic != ConnectionInitializeMagic || initializer != ClientConnectionInitialize)
 {
 CloseSocket();
 return;
 }

 _compressionStream = new z_stream();
 _compressionStream->zalloc = (alloc_func)NULL;
 _compressionStream->zfree = (free_func)NULL;
 _compressionStream->opaque = (voidpf)NULL;
 _compressionStream->avail_in = 0;
 _compressionStream->next_in = NULL;
 int32 z_res = deflateInit2(_compressionStream, sWorld->getIntConfig(CONFIG_COMPRESSION), Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
 if (z_res != Z_OK)
 {
 CloseSocket();
 TC_LOG_ERROR("network", "Can't initialize packet compression (zlib: deflateInit) Error code: %i (%s)", z_res, zError(z_res));
 return;
 }

 _packetBuffer.Reset();
 HandleSendAuthSession();
 AsyncRead();
 return;
 }
 }

 AsyncReadWithCallback(&WorldSocket::InitializeHandler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::LoadSessionPermissionsCallback ( PreparedQueryResult  result )

private

{
 // RBAC must be loaded before adding session to check for skip queue permission
 _worldSession->GetRBACData()->LoadFromDBCallback(result);

 sWorld->AddSession(_worldSession);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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)
 {
 TC_LOG_TRACE("network.opcode", "C->S: %s %s", GetRemoteIpAddress().to_string().c_str(), GetOpcodeNameForLogging(opcode).c_str());
 }
 else
 {
 TC_LOG_TRACE("network.opcode", "C->S: %s %s", (_worldSession ? _worldSession->GetPlayerInfo() : GetRemoteIpAddress().to_string()).c_str(),
 GetOpcodeNameForLogging(opcode).c_str());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::OnClose ( )

overrideprotectedvirtual

Reimplemented from Socket< WorldSocket >.

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

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

delete

WorldSocket::ReadDataHandlerResult WorldSocket::ReadDataHandler ( )

protected

{
    ClientPktHeader* header = reinterpret_cast<ClientPktHeader*>(_headerBuffer.GetReadPointer());
    uint32 cmd;
    uint32 size;

    ExtractOpcodeAndSize(header, cmd, size);

    OpcodeClient opcode = static_cast<OpcodeClient>(cmd);

    WorldPacket packet(opcode, std::move(_packetBuffer), GetConnectionType());

    if (sPacketLog->CanLogPacket())
        sPacketLog->LogPacket(packet, CLIENT_TO_SERVER, GetRemoteIpAddress(), GetRemotePort(), GetConnectionType());

    std::unique_lock<std::mutex> sessionGuard(_worldSessionLock, std::defer_lock);

    switch (opcode)
    {
        case CMSG_PING:
            LogOpcodeText(opcode, sessionGuard);
            return HandlePing(packet) ? ReadDataHandlerResult::Ok : 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())
                    TC_LOG_ERROR("network", "WorldSocket::ProcessIncoming: received duplicate CMSG_AUTH_SESSION from %s", _worldSession->GetPlayerInfo().c_str());
                return ReadDataHandlerResult::Error;
            }

            std::shared_ptr<WorldPackets::Auth::AuthSession> authSession = std::make_shared<WorldPackets::Auth::AuthSession>(std::move(packet));
            authSession->Read();
            HandleAuthSession(authSession);
            return ReadDataHandlerResult::WaitingForQuery;
        }
        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 %s", _worldSession->GetPlayerInfo().c_str());
                return ReadDataHandlerResult::Error;
            }

            std::shared_ptr<WorldPackets::Auth::AuthContinuedSession> authSession = std::make_shared<WorldPackets::Auth::AuthContinuedSession>(std::move(packet));
            authSession->Read();
            HandleAuthContinuedSession(authSession);
            return ReadDataHandlerResult::WaitingForQuery;
        }
        case CMSG_KEEP_ALIVE:
            LogOpcodeText(opcode, sessionGuard);
            break;
        case CMSG_LOG_DISCONNECT:
            LogOpcodeText(opcode, sessionGuard);
            packet.rfinish();   // contains uint32 disconnectReason;
            break;
        case CMSG_ENABLE_NAGLE:
            LogOpcodeText(opcode, sessionGuard);
            SetNoDelay(false);
            break;
        case CMSG_CONNECT_TO_FAILED:
        {
            sessionGuard.lock();

            LogOpcodeText(opcode, sessionGuard);
            WorldPackets::Auth::ConnectToFailed connectToFailed(std::move(packet));
            connectToFailed.Read();
            HandleConnectToFailed(connectToFailed);
            break;
        }
        default:
        {
            sessionGuard.lock();

            LogOpcodeText(opcode, sessionGuard);

            if (!_worldSession)
            {
                TC_LOG_ERROR("network.opcode", "ProcessIncoming: Client not authed opcode = %u", uint32(opcode));
                return ReadDataHandlerResult::Error;
            }

            OpcodeHandler const* handler = opcodeTable[opcode];
            if (!handler)
            {
                TC_LOG_ERROR("network.opcode", "No defined handler for opcode %s sent by %s", GetOpcodeNameForLogging(static_cast<OpcodeClient>(packet.GetOpcode())).c_str(), _worldSession->GetPlayerInfo().c_str());
                break;
            }

            // Our Idle timer will reset on any non PING opcodes.
            // Catches people idling on the login screen and any lingering ingame connections.
            _worldSession->ResetTimeOutTime();

            // Copy the packet to the heap before enqueuing
            _worldSession->QueuePacket(new WorldPacket(std::move(packet)));
            break;
        }
    }

    return ReadDataHandlerResult::Ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

bool WorldSocket::ReadHeaderHandler ( )

protected

{
    ASSERT(_headerBuffer.GetActiveSize() == SizeOfClientHeader[_authCrypt.IsInitialized()], "Header size " SZFMTD " different than expected %u", _headerBuffer.GetActiveSize(), SizeOfClientHeader[_authCrypt.IsInitialized()]);

    _authCrypt.DecryptRecv(_headerBuffer.GetReadPointer(), 4);

    ClientPktHeader* header = reinterpret_cast<ClientPktHeader*>(_headerBuffer.GetReadPointer());
    uint32 opcode;
    uint32 size;

    ExtractOpcodeAndSize(header, opcode, size);

    if (!ClientPktHeader::IsValidSize(size) || !ClientPktHeader::IsValidOpcode(opcode))
    {
        TC_LOG_ERROR("network", "WorldSocket::ReadHeaderHandler(): client %s sent malformed packet (size: %u, cmd: %u)",
            GetRemoteIpAddress().to_string().c_str(), size, opcode);
        return false;
    }

    _packetBuffer.Resize(size);
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::SendAuthResponseError

(

uint32

code

)

{
    WorldPackets::Auth::AuthResponse response;
    response.Result = code;
    SendPacketAndLogOpcode(*response.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::SendPacket

(

WorldPacket const &

packet

)

{
    if (!IsOpen())
        return;

    if (sPacketLog->CanLogPacket())
        sPacketLog->LogPacket(packet, SERVER_TO_CLIENT, GetRemoteIpAddress(), GetRemotePort(), GetConnectionType());

    _bufferQueue.Enqueue(new EncryptablePacket(packet, _authCrypt.IsInitialized()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::SendPacketAndLogOpcode ( WorldPacket const &  packet )

private

sends and logs network.opcode without accessing WorldSession

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

Here is the call graph for this function:

Here is the caller graph for this function:

void WorldSocket::SetWorldSession

(

WorldSession *

session

)

{
    std::lock_guard<std::mutex> sessionGuard(_worldSessionLock);
    _worldSession = session;
    _authed = true;
}

void WorldSocket::Start ( )

overridevirtual

Implements Socket< WorldSocket >.

{
    std::string ip_address = GetRemoteIpAddress().to_string();
    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_IP_INFO);
    stmt->setString(0, ip_address);
    stmt->setUInt32(1, inet_addr(ip_address.c_str()));

    _queryCallback = std::bind(&WorldSocket::CheckIpCallback, this, std::placeholders::_1);
    _queryFuture = LoginDatabase.AsyncQuery(stmt);
}

Here is the call graph for this function:

bool WorldSocket::Update ( )

overridevirtual

Reimplemented from Socket< WorldSocket >.

{
    EncryptablePacket* queued;
    MessageBuffer buffer;
    while (_bufferQueue.Dequeue(queued))
    {
        uint32 sizeOfHeader = SizeOfServerHeader[queued->NeedsEncryption()];
        uint32 packetSize = queued->size();
        if (packetSize > MinSizeForCompression && queued->NeedsEncryption())
            packetSize = compressBound(packetSize) + sizeof(CompressedWorldPacket);

        if (buffer.GetRemainingSpace() < packetSize + sizeOfHeader)
        {
            QueuePacket(std::move(buffer));
            buffer.Resize(4096);
        }

        if (buffer.GetRemainingSpace() >= packetSize + sizeOfHeader)
            WritePacketToBuffer(*queued, buffer);
        else    // single packet larger than 4096 bytes
        {
            MessageBuffer packetBuffer(packetSize + sizeOfHeader);
            WritePacketToBuffer(*queued, packetBuffer);
            QueuePacket(std::move(packetBuffer));
        }

        delete queued;
    }

    if (buffer.GetActiveSize() > 0)
        QueuePacket(std::move(buffer));

    if (!BaseSocket::Update())
        return false;

    if (_queryFuture.valid() && _queryFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
    {
        auto callback = _queryCallback;
        _queryCallback = nullptr;
        callback(_queryFuture.get());
    }

    return true;
}

Here is the call graph for this function:

void WorldSocket::WritePacketToBuffer ( EncryptablePacket const &  packet, MessageBuffer &  buffer  )

private

{
    ServerPktHeader header;
    uint32 sizeOfHeader = SizeOfServerHeader[packet.NeedsEncryption()];
    uint32 opcode = packet.GetOpcode();
    uint32 packetSize = packet.size();

    // Reserve space for buffer
    uint8* headerPos = buffer.GetWritePointer();
    buffer.WriteCompleted(sizeOfHeader);

    if (packetSize > MinSizeForCompression && packet.NeedsEncryption())
    {
        CompressedWorldPacket cmp;
        cmp.UncompressedSize = packetSize + 2;
        cmp.UncompressedAdler = adler32(adler32(0x9827D8F1, (Bytef*)&opcode, 2), packet.contents(), packetSize);

        // Reserve space for compression info - uncompressed size and checksums
        uint8* compressionInfo = buffer.GetWritePointer();
        buffer.WriteCompleted(sizeof(CompressedWorldPacket));

        uint32 compressedSize = CompressPacket(buffer.GetWritePointer(), packet);

        cmp.CompressedAdler = adler32(0x9827D8F1, buffer.GetWritePointer(), compressedSize);

        memcpy(compressionInfo, &cmp, sizeof(CompressedWorldPacket));
        buffer.WriteCompleted(compressedSize);
        packetSize = compressedSize + sizeof(CompressedWorldPacket);

        opcode = SMSG_COMPRESSED_PACKET;
    }
    else if (!packet.empty())
        buffer.Write(packet.contents(), packet.size());

    packetSize += 2 /*opcode*/;

    if (packet.NeedsEncryption())
    {
        header.Normal.Size = packetSize;
        header.Normal.Command = opcode;
        _authCrypt.EncryptSend((uint8*)&header, 4);
    }
    else
    {
        header.Setup.Size = packetSize;
        header.Setup.Command = opcode;
    }

    memcpy(headerPos, &header, sizeOfHeader);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

WorldPacketCrypt WorldSocket::_authCrypt

private

bool WorldSocket::_authed

private

MPSCQueue<EncryptablePacket> WorldSocket::_bufferQueue

private

z_stream_s* WorldSocket::_compressionStream

private

BigNumber WorldSocket::_decryptSeed

private

BigNumber WorldSocket::_encryptSeed

private

MessageBuffer WorldSocket::_headerBuffer

private

std::string WorldSocket::_ipCountry

private

std::chrono::steady_clock::time_point WorldSocket::_LastPingTime

private

uint32 WorldSocket::_OverSpeedPings

private

MessageBuffer WorldSocket::_packetBuffer

private

std::function<void(PreparedQueryResult&&)> WorldSocket::_queryCallback

private

PreparedQueryResultFuture WorldSocket::_queryFuture

private

BigNumber WorldSocket::_serverChallenge

private

ConnectionType WorldSocket::_type

private

WorldSession* WorldSocket::_worldSession

private

std::mutex WorldSocket::_worldSessionLock

private

uint8 const WorldSocket::AuthCheckSeed = { 0xC5, 0xC6, 0x98, 0x95, 0x76, 0x3F, 0x1D, 0xCD, 0xB6, 0xA1, 0x37, 0x28, 0xB3, 0x12, 0xFF, 0x8A }

staticprivate

std::string const WorldSocket::ClientConnectionInitialize

staticprivate

uint32 const WorldSocket::ConnectionInitializeMagic = 0xF5EB1CE

staticprivate

uint8 const WorldSocket::ContinuedSessionSeed = { 0x16, 0xAD, 0x0C, 0xD4, 0x46, 0xF9, 0x4F, 0xB2, 0xEF, 0x7D, 0xEA, 0x2A, 0x17, 0x66, 0x4D, 0x2F }

staticprivate

uint32 const WorldSocket::MinSizeForCompression = 0x400

staticprivate

std::string const WorldSocket::ServerConnectionInitialize

staticprivate

uint8 const WorldSocket::SessionKeySeed = { 0x58, 0xCB, 0xCF, 0x40, 0xFE, 0x2E, 0xCE, 0xA6, 0x5A, 0x90, 0xB8, 0x01, 0x68, 0x6C, 0x28, 0x0B }

staticprivate

---

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

• src/server/game/Server/WorldSocket.h
• src/server/game/Server/WorldSocket.cpp