#include <Session.h>

Classes
struct	AccountInfo

struct	GameAccountInfo

struct	LastPlayedCharacterInfo

Public Member Functions
	Session (tcp::socket &&socket)

	~Session ()

void	Start () override

bool	Update () override

uint32	GetAccountId () const

uint32	GetGameAccountId () const

void	SendResponse (uint32 token, pb::Message const *response)

void	SendResponse (uint32 token, uint32 status)

void	SendRequest (uint32 serviceHash, uint32 methodId, pb::Message const *request, std::function< void(MessageBuffer)> callback)

void	SendRequest (uint32 serviceHash, uint32 methodId, pb::Message const *request)

uint32	HandleLogon (authentication::v1::LogonRequest const *logonRequest)

uint32	HandleVerifyWebCredentials (authentication::v1::VerifyWebCredentialsRequest const *verifyWebCredentialsRequest)

uint32	HandleGetAccountState (account::v1::GetAccountStateRequest const request, account::v1::GetAccountStateResponse response)

uint32	HandleGetGameAccountState (account::v1::GetGameAccountStateRequest const request, account::v1::GetGameAccountStateResponse response)

uint32	HandleProcessClientRequest (game_utilities::v1::ClientRequest const request, game_utilities::v1::ClientResponse response)

uint32	HandleGetAllValuesForAttribute (game_utilities::v1::GetAllValuesForAttributeRequest const request, game_utilities::v1::GetAllValuesForAttributeResponse response)

std::string	GetClientInfo () const

Public Member Functions inherited from Socket< Session, SslSocket< SslContext > >
	Socket (tcp::socket &&socket)

virtual	~Socket ()

boost::asio::ip::address	GetRemoteIpAddress () const

uint16	GetRemotePort () const

void	AsyncRead ()

void	AsyncReadWithCallback (void(Session::*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 Member Functions
void	HandshakeHandler (boost::system::error_code const &error)

void	ReadHandler () override

bool	ReadHeaderLengthHandler ()

bool	ReadHeaderHandler ()

bool	ReadDataHandler ()

Protected Member Functions inherited from Socket< Session, SslSocket< SslContext > >
virtual void	OnClose ()

bool	AsyncProcessQueue ()

void	SetNoDelay (bool enable)

SslSocket< SslContext > &	underlying_stream ()

Private Types
typedef Socket< Session, SslSocket< SslContext > >	BattlenetSocket

typedef uint32(Session::*	ClientRequestHandler )(std::unordered_map< std::string, Variant const * > const &, game_utilities::v1::ClientResponse *)

Private Member Functions
void	AsyncWrite (MessageBuffer *packet)

void	AsyncHandshake ()

void	CheckIpCallback (PreparedQueryResult result)

uint32	GetRealmListTicket (std::unordered_map< std::string, Variant const * > const &params, game_utilities::v1::ClientResponse *response)

uint32	GetLastCharPlayed (std::unordered_map< std::string, Variant const * > const &params, game_utilities::v1::ClientResponse *response)

uint32	GetRealmList (std::unordered_map< std::string, Variant const * > const &params, game_utilities::v1::ClientResponse *response)

uint32	JoinRealm (std::unordered_map< std::string, Variant const * > const &params, game_utilities::v1::ClientResponse *response)

Private Attributes
MessageBuffer	_headerLengthBuffer

MessageBuffer	_headerBuffer

MessageBuffer	_packetBuffer

std::unique_ptr< AccountInfo >	_accountInfo

GameAccountInfo *	_gameAccountInfo

std::string	_locale

std::string	_os

uint32	_build

std::string	_ipCountry

std::array< uint8, 32 >	_clientSecret

bool	_authed

PreparedQueryResultFuture	_queryFuture

std::function< void(PreparedQueryResult)>	_queryCallback

std::unordered_map< uint32, std::function< void(MessageBuffer)> >	_responseCallbacks

uint32	_requestToken

Static Private Attributes
static std::unordered_map < std::string, ClientRequestHandler > const	ClientRequestHandlers

Member Typedef Documentation

typedef Socket<Session, SslSocket<SslContext> > Battlenet::Session::BattlenetSocket

private

typedef uint32(Session::* Battlenet::Session::ClientRequestHandler)(std::unordered_map< std::string, Variant const * > const &, game_utilities::v1::ClientResponse *)

private

Constructor & Destructor Documentation

Battlenet::Session::Session ( tcp::socket && socket )

explicit

  : BattlenetSocket(std::move(socket)), _accountInfo(new AccountInfo()), _gameAccountInfo(nullptr), _locale(),
  _os(), _build(0), _ipCountry(), _authed(false), _requestToken(0)
 {
  _headerLengthBuffer.Resize(2);
 }

Here is the call graph for this function:

Battlenet::Session::~Session ( )

74 {

75 }

Member Function Documentation

void Battlenet::Session::AsyncHandshake ( )

private

 {
  underlying_stream().async_handshake(ssl::stream_base::server, std::bind(&Session::HandshakeHandler, shared_from_this(), std::placeholders::_1));
 }

Here is the call graph for this function:

void Battlenet::Session::AsyncWrite ( MessageBuffer * packet )

private

 {
  if (!IsOpen())
  return;
 
  QueuePacket(std::move(*packet));
 }

void Battlenet::Session::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_DEBUG("session", "%s tries to log in using banned IP!", GetClientInfo().c_str());
  CloseSocket();
  return;
  }
  }
 
  AsyncHandshake();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 Battlenet::Session::GetAccountId ( ) const

inline

129 { return _accountInfo->Id; }

Battlenet::Session::_accountInfo

std::unique_ptr< AccountInfo > _accountInfo

Definition: Session.h:178

std::string Battlenet::Session::GetClientInfo ( ) const

 {
  std::ostringstream stream;
  stream << '[' << GetRemoteIpAddress() << ':' << GetRemotePort();
  if (_accountInfo && !_accountInfo->Login.empty())
  stream << ", Account: " << _accountInfo->Login;
 
  if (_gameAccountInfo)
  stream << ", Game account: " << _gameAccountInfo->Name;
 
  stream << ']';
 
  return stream.str();
 }

Here is the caller graph for this function:

uint32 Battlenet::Session::GetGameAccountId ( ) const

inline

130 { return _gameAccountInfo->Id; }

Battlenet::Session::_gameAccountInfo

GameAccountInfo * _gameAccountInfo

Definition: Session.h:179

Battlenet::Session::GameAccountInfo::Id

uint32 Id

Definition: Session.h:96

uint32 Battlenet::Session::GetLastCharPlayed	(	std::unordered_map< std::string, Variant const * > const &	params,
		game_utilities::v1::ClientResponse *	response
	)

private

 {
  if (Variant const* subRegion = GetParam(params, "Command_LastCharPlayedRequest_v1_b9"))
  {
  auto lastPlayerChar = _gameAccountInfo->LastPlayedCharacters.find(subRegion->string_value());
  if (lastPlayerChar != _gameAccountInfo->LastPlayedCharacters.end())
  {
  std::vector<uint8> compressed = sRealmList->GetRealmEntryJSON(lastPlayerChar->second.RealmId, _build);
 
  if (compressed.empty())
  return ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE_RESPONSE;
 
  Attribute* attribute = response->add_attribute();
  attribute->set_name("Param_RealmEntry");
  attribute->mutable_value()->set_blob_value(compressed.data(), compressed.size());
 
  attribute = response->add_attribute();
  attribute->set_name("Param_CharacterName");
  attribute->mutable_value()->set_string_value(lastPlayerChar->second.CharacterName);
 
  attribute = response->add_attribute();
  attribute->set_name("Param_CharacterGUID");
  attribute->mutable_value()->set_blob_value(&lastPlayerChar->second.CharacterGUID, sizeof(lastPlayerChar->second.CharacterGUID));
 
  attribute = response->add_attribute();
  attribute->set_name("Param_LastPlayedTime");
  attribute->mutable_value()->set_int_value(int32(lastPlayerChar->second.LastPlayedTime));
  }
 
  return ERROR_OK;
  }
 
  return ERROR_UTIL_SERVER_UNKNOWN_REALM;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::GetRealmList	(	std::unordered_map< std::string, Variant const * > const &	params,
		game_utilities::v1::ClientResponse *	response
	)

private

 {
  if (!_gameAccountInfo)
  return ERROR_USER_SERVER_BAD_WOW_ACCOUNT;
 
  std::string subRegionId;
  if (Variant const* subRegion = GetParam(params, "Command_RealmListRequest_v1_b9"))
  subRegionId = subRegion->string_value();
 
  std::vector<uint8> compressed = sRealmList->GetRealmList(_build, subRegionId);
 
  if (compressed.empty())
  return ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE_RESPONSE;
 
  Attribute* attribute = response->add_attribute();
  attribute->set_name("Param_RealmList");
  attribute->mutable_value()->set_blob_value(compressed.data(), compressed.size());
 
  ::JSON::RealmList::RealmCharacterCountList realmCharacterCounts;
  for (auto const& characterCount : _gameAccountInfo->CharacterCounts)
  {
  ::JSON::RealmList::RealmCharacterCountEntry* countEntry = realmCharacterCounts.add_counts();
  countEntry->set_wowrealmaddress(characterCount.first);
  countEntry->set_count(characterCount.second);
  }
 
  std::string json = "JSONRealmCharacterCountList:" + ::JSON::Serialize(realmCharacterCounts);
 
  uLongf compressedLength = compressBound(json.length());
  compressed.resize(4 + compressedLength);
  *reinterpret_cast<uint32*>(compressed.data()) = json.length() + 1;
 
  if (compress(compressed.data() + 4, &compressedLength, reinterpret_cast<uint8 const*>(json.c_str()), json.length() + 1) != Z_OK)
  return ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE_RESPONSE;
 
  attribute = response->add_attribute();
  attribute->set_name("Param_CharacterCountList");
  attribute->mutable_value()->set_blob_value(compressed.data(), compressedLength + 4);
  return ERROR_OK;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::GetRealmListTicket	(	std::unordered_map< std::string, Variant const * > const &	params,
		game_utilities::v1::ClientResponse *	response
	)

private

 {
  if (Variant const* identity = GetParam(params, "Param_Identity"))
  {
  ::JSON::RealmList::RealmListTicketIdentity data;
  std::size_t jsonStart = identity->blob_value().find(':');
  if (jsonStart != std::string::npos && ::JSON::Deserialize(identity->blob_value().substr(jsonStart + 1), &data))
  {
  auto itr = _accountInfo->GameAccounts.find(data.gameaccountid());
  if (itr != _accountInfo->GameAccounts.end())
  _gameAccountInfo = &itr->second;
  }
  }
 
  if (!_gameAccountInfo)
  return ERROR_UTIL_SERVER_INVALID_IDENTITY_ARGS;
 
  if (Variant const* clientInfo = GetParam(params, "Param_ClientInfo"))
  {
  ::JSON::RealmList::RealmListTicketClientInformation data;
  std::size_t jsonStart = clientInfo->blob_value().find(':');
  if (jsonStart != std::string::npos && ::JSON::Deserialize(clientInfo->blob_value().substr(jsonStart + 1), &data))
  {
  if (_clientSecret.size() == data.info().secret().size())
  {
  _build = data.info().version().versionbuild();
  memcpy(_clientSecret.data(), data.info().secret().data(), _clientSecret.size());
  }
  }
  }
 
  if (!_build)
  return ERROR_WOW_SERVICES_DENIED_REALM_LIST_TICKET;
 
  PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_LAST_LOGIN_INFO);
  stmt->setString(0, GetRemoteIpAddress().to_string());
  stmt->setUInt8(1, GetLocaleByName(_locale));
  stmt->setString(2, _os);
  stmt->setUInt32(3, _accountInfo->Id);
 
  LoginDatabase.Execute(stmt);
 
  Attribute* attribute = response->add_attribute();
  attribute->set_name("Param_RealmListTicket");
  attribute->mutable_value()->set_blob_value("AuthRealmListTicket");
 
  return ERROR_OK;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleGetAccountState	(	account::v1::GetAccountStateRequest const *	request,
		account::v1::GetAccountStateResponse *	response
	)

 {
  if (!_authed)
  return ERROR_DENIED;
 
  if (request->options().field_privacy_info())
  {
  response->mutable_state()->mutable_privacy_info()->set_is_using_rid(false);
  response->mutable_state()->mutable_privacy_info()->set_is_real_id_visible_for_view_friends(false);
  response->mutable_state()->mutable_privacy_info()->set_is_hidden_from_friend_finder(true);
 
  response->mutable_tags()->set_privacy_info_tag(0xD7CA834D);
  }
 
  return ERROR_OK;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleGetAllValuesForAttribute	(	game_utilities::v1::GetAllValuesForAttributeRequest const *	request,
		game_utilities::v1::GetAllValuesForAttributeResponse *	response
	)

 {
  if (!_authed)
  return ERROR_DENIED;
 
  if (request->attribute_key() == "Command_RealmListRequest_v1_b9")
  {
  sRealmList->WriteSubRegions(response);
  return ERROR_OK;
  }
 
  return ERROR_RPC_NOT_IMPLEMENTED;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleGetGameAccountState	(	account::v1::GetGameAccountStateRequest const *	request,
		account::v1::GetGameAccountStateResponse *	response
	)

 {
  if (!_authed)
  return ERROR_DENIED;
 
  if (request->options().field_game_level_info())
  {
  auto itr = _accountInfo->GameAccounts.find(request->game_account_id().low());
  if (itr != _accountInfo->GameAccounts.end())
  {
  response->mutable_state()->mutable_game_level_info()->set_name(itr->second.DisplayName);
  response->mutable_state()->mutable_game_level_info()->set_program(5730135); // WoW
  }
 
  response->mutable_tags()->set_game_level_info_tag(0x5C46D483);
  }
 
  if (request->options().field_game_status())
  {
  auto itr = _accountInfo->GameAccounts.find(request->game_account_id().low());
  if (itr != _accountInfo->GameAccounts.end())
  {
  response->mutable_state()->mutable_game_status()->set_is_suspended(itr->second.IsBanned);
  response->mutable_state()->mutable_game_status()->set_is_banned(itr->second.IsPermanenetlyBanned);
  }
 
  response->mutable_state()->mutable_game_status()->set_program(5730135); // WoW
  response->mutable_tags()->set_game_status_tag(0x98B75F99);
  }
 
  return ERROR_OK;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleLogon ( authentication::v1::LogonRequest const * logonRequest )

 {
  if (logonRequest->program() != "WoW")
  {
  TC_LOG_DEBUG("session", "[Battlenet::LogonRequest] %s attempted to log in with game other than WoW (using %s)!", GetClientInfo().c_str(), logonRequest->program().c_str());
  return ERROR_BAD_PROGRAM;
  }
 
  if (logonRequest->platform() != "Win" && logonRequest->platform() != "Wn64" && logonRequest->platform() != "Mc64")
  {
  TC_LOG_DEBUG("session", "[Battlenet::LogonRequest] %s attempted to log in from an unsupported platform (using %s)!", GetClientInfo().c_str(), logonRequest->platform().c_str());
  return ERROR_BAD_PLATFORM;
  }
 
  if (GetLocaleByName(logonRequest->locale()) == LOCALE_enUS && logonRequest->locale() != "enUS")
  {
  TC_LOG_DEBUG("session", "[Battlenet::LogonRequest] %s attempted to log in with unsupported locale (using %s)!", GetClientInfo().c_str(), logonRequest->locale().c_str());
  return ERROR_BAD_LOCALE;
  }
 
  _locale = logonRequest->locale();
  _os = logonRequest->platform();
 
  ip::tcp::endpoint const& endpoint = sLoginService.GetAddressForClient(GetRemoteIpAddress());
 
  challenge::v1::ChallengeExternalRequest externalChallenge;
  externalChallenge.set_payload_type("web_auth_url");
  externalChallenge.set_payload(Trinity::StringFormat("https://%s:%u/bnetserver/login/", endpoint.address().to_string().c_str(), endpoint.port()));
  Service<challenge::v1::ChallengeListener>(this).OnExternalChallenge(&externalChallenge);
  return ERROR_OK;
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleProcessClientRequest	(	game_utilities::v1::ClientRequest const *	request,
		game_utilities::v1::ClientResponse *	response
	)

 {
  if (!_authed)
  return ERROR_DENIED;
 
  Attribute const* command = nullptr;
  std::unordered_map<std::string, Variant const*> params;
 
  for (int32 i = 0; i < request->attribute_size(); ++i)
  {
  Attribute const& attr = request->attribute(i);
  params[attr.name()] = &attr.value();
  if (strstr(attr.name().c_str(), "Command_") == attr.name().c_str())
  command = &attr;
  }
 
  if (!command)
  {
  TC_LOG_ERROR("session.rpc", "%s sent ClientRequest with no command.", GetClientInfo().c_str());
  return ERROR_RPC_MALFORMED_REQUEST;
  }
 
  auto itr = ClientRequestHandlers.find(command->name());
  if (itr == ClientRequestHandlers.end())
  {
  TC_LOG_ERROR("session.rpc", "%s sent ClientRequest with unknown command %s.", GetClientInfo().c_str(), command->name().c_str());
  return ERROR_RPC_NOT_IMPLEMENTED;
  }
 
  return (this->*itr->second)(params, response);
 }

Here is the call graph for this function:

uint32 Battlenet::Session::HandleVerifyWebCredentials ( authentication::v1::VerifyWebCredentialsRequest const * verifyWebCredentialsRequest )

 {
  authentication::v1::LogonResult logonResult;
  logonResult.set_error_code(0);
  _accountInfo = sLoginService.VerifyLoginTicket(verifyWebCredentialsRequest->web_credentials());
  if (!_accountInfo)
  return ERROR_DENIED;
 
  std::string ip_address = GetRemoteIpAddress().to_string();
 
  // If the IP is 'locked', check that the player comes indeed from the correct IP address
  if (_accountInfo->IsLockedToIP)
  {
  TC_LOG_DEBUG("session", "[Session::HandleVerifyWebCredentials] Account '%s' is locked to IP - '%s' is logging in from '%s'",
  _accountInfo->Login.c_str(), _accountInfo->LastIP.c_str(), ip_address.c_str());
 
  if (_accountInfo->LastIP != ip_address)
  return ERROR_RISK_ACCOUNT_LOCKED;
  }
  else
  {
  TC_LOG_DEBUG("session", "[Session::HandleVerifyWebCredentials] Account '%s' is not locked to ip", _accountInfo->Login.c_str());
  if (_accountInfo->LockCountry.empty() || _accountInfo->LockCountry == "00")
  TC_LOG_DEBUG("session", "[Session::HandleVerifyWebCredentials] Account '%s' is not locked to country", _accountInfo->Login.c_str());
  else if (!_accountInfo->LockCountry.empty() && !_ipCountry.empty())
  {
  TC_LOG_DEBUG("session", "[Session::HandleVerifyWebCredentials] Account '%s' is locked to country: '%s' Player country is '%s'",
  _accountInfo->Login.c_str(), _accountInfo->LockCountry.c_str(), _ipCountry.c_str());
 
  if (_ipCountry != _accountInfo->LockCountry)
  return ERROR_RISK_ACCOUNT_LOCKED;
  }
  }
 
  // If the account is banned, reject the logon attempt
  if (_accountInfo->IsBanned)
  {
  if (_accountInfo->IsPermanenetlyBanned)
  {
  TC_LOG_DEBUG("session", "%s [Session::HandleVerifyWebCredentials] Banned account %s tried to login!", GetClientInfo().c_str(), _accountInfo->Login.c_str());
  return ERROR_GAME_ACCOUNT_BANNED;
  }
  else
  {
  TC_LOG_DEBUG("session", "%s [Session::HandleVerifyWebCredentials] Temporarily banned account %s tried to login!", GetClientInfo().c_str(), _accountInfo->Login.c_str());
  return ERROR_GAME_ACCOUNT_SUSPENDED;
  }
  }
 
  logonResult.mutable_account_id()->set_low(_accountInfo->Id);
  logonResult.mutable_account_id()->set_high(UI64LIT(0x100000000000000));
  for (auto itr = _accountInfo->GameAccounts.begin(); itr != _accountInfo->GameAccounts.end(); ++itr)
  {
  if (!itr->second.IsBanned)
  {
  EntityId* gameAccountId = logonResult.add_game_account_id();
  gameAccountId->set_low(itr->second.Id);
  gameAccountId->set_high(UI64LIT(0x200000200576F57));
  }
  }
 
  if (!_ipCountry.empty())
  logonResult.set_geoip_country(_ipCountry);
 
  BigNumber k;
  k.SetRand(8 * 64);
  logonResult.set_session_key(k.AsByteArray(64).get(), 64);
 
  _authed = true;
 
  Service<authentication::v1::AuthenticationListener>(this).OnLogonComplete(&logonResult);
  return ERROR_OK;
 }

Here is the call graph for this function:

void Battlenet::Session::HandshakeHandler ( boost::system::error_code const & error )

protected

 {
  if (error)
  {
  TC_LOG_ERROR("session", "%s SSL Handshake failed %s", GetClientInfo().c_str(), error.message().c_str());
  CloseSocket();
  return;
  }
 
  AsyncRead();
 }

Here is the caller graph for this function:

uint32 Battlenet::Session::JoinRealm	(	std::unordered_map< std::string, Variant const * > const &	params,
		game_utilities::v1::ClientResponse *	response
	)

private

 {
  if (Variant const* realmAddress = GetParam(params, "Param_RealmAddress"))
  return sRealmList->JoinRealm(realmAddress->uint_value(), _build, GetRemoteIpAddress(), _clientSecret, GetLocaleByName(_locale), _os, _gameAccountInfo->Name, response);
 
  return ERROR_WOW_SERVICES_INVALID_JOIN_TICKET;
 }

Here is the call graph for this function:

bool Battlenet::Session::ReadDataHandler ( )

protected

 {
  Header header;
  header.ParseFromArray(_headerBuffer.GetReadPointer(), _headerBuffer.GetActiveSize());
 
  if (header.service_id() != 0xFE)
  {
  sServiceDispatcher.Dispatch(this, header.service_hash(), header.token(), header.method_id(), std::move(_packetBuffer));
  }
  else
  {
  auto itr = _responseCallbacks.find(header.token());
  if (itr != _responseCallbacks.end())
  {
  itr->second(std::move(_packetBuffer));
  _responseCallbacks.erase(header.token());
  }
  else
  _packetBuffer.Reset();
  }
 
  return true;
 }

Here is the call graph for this function:

void Battlenet::Session::ReadHandler ( )

overrideprotectedvirtual

Implements Socket< Session, SslSocket< SslContext > >.

 {
  if (!IsOpen())
  return;
 
  MessageBuffer& packet = GetReadBuffer();
  while (packet.GetActiveSize() > 0)
  {
  if (!PartialProcessPacket<&Battlenet::Session::ReadHeaderLengthHandler, &Battlenet::Session::_headerLengthBuffer>(this, packet))
  break;
 
  if (!PartialProcessPacket<&Battlenet::Session::ReadHeaderHandler, &Battlenet::Session::_headerBuffer>(this, packet))
  break;
 
  if (!PartialProcessPacket<&Battlenet::Session::ReadDataHandler, &Battlenet::Session::_packetBuffer>(this, packet))
  break;
 
  _headerLengthBuffer.Reset();
  _headerBuffer.Reset();
  }
 
  AsyncRead();
 }

Here is the call graph for this function:

bool Battlenet::Session::ReadHeaderHandler ( )

protected

 {
  Header header;
  if (!header.ParseFromArray(_headerBuffer.GetReadPointer(), _headerBuffer.GetActiveSize()))
  return true;
 
  _packetBuffer.Resize(header.size());
  return true;
 }

Here is the call graph for this function:

bool Battlenet::Session::ReadHeaderLengthHandler ( )

protected

 {
  uint16 len = *reinterpret_cast<uint16*>(_headerLengthBuffer.GetReadPointer());
  EndianConvertReverse(len);
  _headerBuffer.Resize(len);
  return true;
 }

Here is the call graph for this function:

void Battlenet::Session::SendRequest	(	uint32	serviceHash,
		uint32	methodId,
		pb::Message const *	request,
		std::function< void(MessageBuffer)>	callback
	)

inline

  {
  _responseCallbacks[_requestToken] = std::move(callback);
  SendRequest(serviceHash, methodId, request);
  }

void Battlenet::Session::SendRequest	(	uint32	serviceHash,
		uint32	methodId,
		pb::Message const *	request
	)

 {
  Header header;
  header.set_service_id(0);
  header.set_service_hash(serviceHash);
  header.set_method_id(methodId);
  header.set_size(request->ByteSize());
  header.set_token(_requestToken++);
 
  uint16 headerSize = header.ByteSize();
  EndianConvertReverse(headerSize);
 
  MessageBuffer packet;
  packet.Write(&headerSize, sizeof(headerSize));
  uint8* ptr = packet.GetWritePointer();
  packet.WriteCompleted(header.ByteSize());
  header.SerializeToArray(ptr, header.ByteSize());
  ptr = packet.GetWritePointer();
  packet.WriteCompleted(request->ByteSize());
  request->SerializeToArray(ptr, request->ByteSize());
 
  AsyncWrite(&packet);
 }

Here is the call graph for this function:

void Battlenet::Session::SendResponse	(	uint32	token,
		pb::Message const *	response
	)

 {
  Header header;
  header.set_token(token);
  header.set_service_id(0xFE);
  header.set_size(response->ByteSize());
 
  uint16 headerSize = header.ByteSize();
  EndianConvertReverse(headerSize);
 
  MessageBuffer packet;
  packet.Write(&headerSize, sizeof(headerSize));
  uint8* ptr = packet.GetWritePointer();
  packet.WriteCompleted(header.ByteSize());
  header.SerializeToArray(ptr, header.ByteSize());
  ptr = packet.GetWritePointer();
  packet.WriteCompleted(response->ByteSize());
  response->SerializeToArray(ptr, response->ByteSize());
 
  AsyncWrite(&packet);
 }

Here is the call graph for this function:

void Battlenet::Session::SendResponse	(	uint32	token,
		uint32	status
	)

 {
  Header header;
  header.set_token(token);
  header.set_status(status);
  header.set_service_id(0xFE);
 
  uint16 headerSize = header.ByteSize();
  EndianConvertReverse(headerSize);
 
  MessageBuffer packet;
  packet.Write(&headerSize, sizeof(headerSize));
  uint8* ptr = packet.GetWritePointer();
  packet.WriteCompleted(header.ByteSize());
  header.SerializeToArray(ptr, header.ByteSize());
 
  AsyncWrite(&packet);
 }

Here is the call graph for this function:

void Battlenet::Session::Start ( )

overridevirtual

Implements Socket< Session, SslSocket< SslContext > >.

 {
  std::string ip_address = GetRemoteIpAddress().to_string();
  TC_LOG_TRACE("session", "%s Accepted connection", GetClientInfo().c_str());
 
  // Verify that this IP is not in the ip_banned table
  LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS));
 
  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(&Battlenet::Session::CheckIpCallback, this, std::placeholders::_1);
  _queryFuture = LoginDatabase.AsyncQuery(stmt);
 }

Here is the call graph for this function:

bool Battlenet::Session::Update ( )

overridevirtual

Reimplemented from Socket< Session, SslSocket< SslContext > >.

 {
  if (!BattlenetSocket::Update())
  return false;
 
  if (_queryFuture.valid() && _queryFuture.wait_for(std::chrono::seconds(0)) == std::future_status::ready)
  {
  auto callback = std::move(_queryCallback);
  _queryCallback = nullptr;
  callback(_queryFuture.get());
  }
 
  return true;
 }

Here is the call graph for this function:

Member Data Documentation

std::unique_ptr<AccountInfo> Battlenet::Session::_accountInfo

private

bool Battlenet::Session::_authed

private

uint32 Battlenet::Session::_build

private

std::array<uint8, 32> Battlenet::Session::_clientSecret

private

GameAccountInfo* Battlenet::Session::_gameAccountInfo

private

MessageBuffer Battlenet::Session::_headerBuffer

private

MessageBuffer Battlenet::Session::_headerLengthBuffer

private

std::string Battlenet::Session::_ipCountry

private

std::string Battlenet::Session::_locale

private

std::string Battlenet::Session::_os

private

MessageBuffer Battlenet::Session::_packetBuffer

private

std::function<void(PreparedQueryResult)> Battlenet::Session::_queryCallback

private

PreparedQueryResultFuture Battlenet::Session::_queryFuture

private

uint32 Battlenet::Session::_requestToken

private

std::unordered_map<uint32, std::function<void(MessageBuffer)> > Battlenet::Session::_responseCallbacks

private

std::unordered_map< std::string, Battlenet::Session::ClientRequestHandler > const Battlenet::Session::ClientRequestHandlers

staticprivate

Initial value:

=
{
    { "Command_RealmListTicketRequest_v1_b9", &Battlenet::Session::GetRealmListTicket },
    { "Command_LastCharPlayedRequest_v1_b9", &Battlenet::Session::GetLastCharPlayed },
    { "Command_RealmListRequest_v1_b9", &Battlenet::Session::GetRealmList },
    { "Command_RealmJoinRequest_v1_b9", &Battlenet::Session::JoinRealm },
}

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

src/server/bnetserver/Server/Session.h
src/server/bnetserver/Server/Session.cpp

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation