RealmList Class Reference

Storage object for the list of realms on the server. More...

#include <RealmList.h>

Public Types
typedef std::map < Battlenet::RealmHandle, Realm >	RealmMap

Public Member Functions
	~RealmList ()
void	Initialize (boost::asio::io_service &ioService, uint32 updateInterval)
void	Close ()
RealmMap const &	GetRealms () const
Realm const *	GetRealm (Battlenet::RealmHandle const &id) const
RealmBuildInfo const *	GetBuildInfo (uint32 build) const
std::unordered_set < std::string > const &	GetSubRegions () const
void	WriteSubRegions (bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse *response) const
std::vector< uint8 >	GetRealmEntryJSON (Battlenet::RealmHandle const &id, uint32 build) const
std::vector< uint8 >	GetRealmList (uint32 build, std::string const &subRegion) const
uint32	JoinRealm (uint32 realmAddress, uint32 build, boost::asio::ip::address const &clientAddress, std::array< uint8, 32 > const &clientSecret, LocaleConstant locale, std::string const &os, std::string accountName, bgs::protocol::game_utilities::v1::ClientResponse *response) const

Static Public Member Functions
static RealmList *	Instance ()

Private Member Functions
	RealmList ()
void	UpdateRealms (boost::system::error_code const &error)
void	UpdateRealm (Battlenet::RealmHandle const &id, uint32 build, const std::string &name, ip::address const &address, ip::address const &localAddr, ip::address const &localSubmask, uint16 port, uint8 icon, RealmFlags flag, uint8 timezone, AccountTypes allowedSecurityLevel, float population)

Private Attributes
RealmMap	_realms
std::unordered_set< std::string >	_subRegions
uint32	_updateInterval
boost::asio::deadline_timer *	_updateTimer
boost::asio::ip::tcp::resolver *	_resolver

Detailed Description

Storage object for the list of realms on the server.

Member Typedef Documentation

typedef std::map<Battlenet::RealmHandle, Realm> RealmList::RealmMap

Constructor & Destructor Documentation

RealmList::~RealmList

(

)

{
 delete _updateTimer;
}

RealmList::RealmList ( )

private

 : _updateInterval(0), _updateTimer(nullptr), _resolver(nullptr)
{
}

Member Function Documentation

void RealmList::Close

(

)

{
 _updateTimer->cancel();
}

RealmBuildInfo const * RealmList::GetBuildInfo

(

uint32

build

)

const

{
 // List of client builds for verbose version info in realmlist packet
 static std::vector<RealmBuildInfo> const ClientBuilds =
 {
 { 21355, 6, 2, 4, ' ' },
 { 20726, 6, 2, 3, ' ' },
 { 20574, 6, 2, 2, 'a' },
 { 20490, 6, 2, 2, 'a' },
 { 15595, 4, 3, 4, ' ' },
 { 14545, 4, 2, 2, ' ' },
 { 13623, 4, 0, 6, 'a' },
 { 13930, 3, 3, 5, 'a' }, // 3.3.5a China Mainland build
 { 12340, 3, 3, 5, 'a' },
 { 11723, 3, 3, 3, 'a' },
 { 11403, 3, 3, 2, ' ' },
 { 11159, 3, 3, 0, 'a' },
 { 10505, 3, 2, 2, 'a' },
 { 9947, 3, 1, 3, ' ' },
 { 8606, 2, 4, 3, ' ' },
 { 6141, 1, 12, 3, ' ' },
 { 6005, 1, 12, 2, ' ' },
 { 5875, 1, 12, 1, ' ' },
 };

 for (std::size_t i = 0; i < ClientBuilds.size(); ++i)
 if (ClientBuilds[i].Build == build)
 return &ClientBuilds[i];

 return nullptr;
}

Here is the caller graph for this function:

Realm const * RealmList::GetRealm

(

Battlenet::RealmHandle const &

id

)

const

{
 auto itr = _realms.find(id);
 if (itr != _realms.end())
 return &itr->second;

 return NULL;
}

Here is the caller graph for this function:

std::vector< uint8 > RealmList::GetRealmEntryJSON	(	Battlenet::RealmHandle const &	id,
		uint32	build
	)		const

{
 std::vector<uint8> compressed;
 if (Realm const* realm = GetRealm(id))
 {
 if (!(realm->Flags & REALM_FLAG_OFFLINE) && realm->Build == build)
 {
 JSON::RealmList::RealmEntry realmEntry;
 realmEntry.set_wowrealmaddress(realm->Id.GetAddress());
 realmEntry.set_cfgtimezonesid(1);
 realmEntry.set_populationstate(std::max(uint32(realm->PopulationLevel), 1u));
 realmEntry.set_cfgcategoriesid(realm->Timezone);

 JSON::RealmList::ClientVersion* version = realmEntry.mutable_version();
 if (RealmBuildInfo const* buildInfo = GetBuildInfo(realm->Build))
 {
 version->set_versionmajor(buildInfo->MajorVersion);
 version->set_versionminor(buildInfo->MinorVersion);
 version->set_versionrevision(buildInfo->BugfixVersion);
 version->set_versionbuild(buildInfo->Build);
 }
 else
 {
 version->set_versionmajor(6);
 version->set_versionminor(2);
 version->set_versionrevision(4);
 version->set_versionbuild(realm->Build);
 }

 realmEntry.set_cfgrealmsid(realm->Id.Realm);
 realmEntry.set_flags(realm->Flags);
 realmEntry.set_name(realm->Name);
 realmEntry.set_cfgconfigsid(realm->GetConfigId());
 realmEntry.set_cfglanguagesid(1);

 std::string json = "JamJSONRealmEntry:" + JSON::Serialize(realmEntry);

 uLong compressedLength = compressBound(json.length());
 compressed.resize(compressedLength + 4);
 *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)
 compressed.resize(compressedLength + 4);
 else
 compressed.clear();
 }
 }

 return compressed;
}

Here is the call graph for this function:

std::vector< uint8 > RealmList::GetRealmList	(	uint32	build,
		std::string const &	subRegion
	)		const

{
 JSON::RealmList::RealmListUpdates realmList;
 for (auto const& realm : _realms)
 {
 if (realm.second.Id.GetSubRegionAddress() != subRegion)
 continue;

 uint32 flag = realm.second.Flags;
 if (realm.second.Build != build)
 flag |= REALM_FLAG_VERSION_MISMATCH;

 JSON::RealmList::RealmState* state = realmList.add_updates();
 state->mutable_update()->set_wowrealmaddress(realm.second.Id.GetAddress());
 state->mutable_update()->set_cfgtimezonesid(1);
 state->mutable_update()->set_populationstate((realm.second.Flags & REALM_FLAG_OFFLINE) ? 0u : std::max(uint32(realm.second.PopulationLevel), 1u));
 state->mutable_update()->set_cfgcategoriesid(realm.second.Timezone);

 JSON::RealmList::ClientVersion* version = state->mutable_update()->mutable_version();
 if (RealmBuildInfo const* buildInfo = GetBuildInfo(realm.second.Build))
 {
 version->set_versionmajor(buildInfo->MajorVersion);
 version->set_versionminor(buildInfo->MinorVersion);
 version->set_versionrevision(buildInfo->BugfixVersion);
 version->set_versionbuild(buildInfo->Build);
 }
 else
 {
 version->set_versionmajor(6);
 version->set_versionminor(2);
 version->set_versionrevision(4);
 version->set_versionbuild(realm.second.Build);
 }

 state->mutable_update()->set_cfgrealmsid(realm.second.Id.Realm);
 state->mutable_update()->set_flags(flag);
 state->mutable_update()->set_name(realm.second.Name);
 state->mutable_update()->set_cfgconfigsid(realm.second.GetConfigId());
 state->mutable_update()->set_cfglanguagesid(1);

 state->set_deleting(false);
 }

 std::string json = "JSONRealmListUpdates:" + JSON::Serialize(realmList);

 uLong compressedLength = compressBound(json.length());
 std::vector<uint8> compressed;
 compressed.resize(4 + compressedLength);
 *reinterpret_cast<uint32*>(compressed.data()) = json.length() + 1;

 compress(compressed.data() + 4, &compressedLength, reinterpret_cast<uint8 const*>(json.c_str()), json.length() + 1);

 compressed.resize(compressedLength + 4);

 return compressed;
}

Here is the call graph for this function:

RealmMap const& RealmList::GetRealms ( ) const

inline

{ return _realms; }

std::unordered_set<std::string> const& RealmList::GetSubRegions ( ) const

inline

{ return _subRegions; }

Here is the caller graph for this function:

void RealmList::Initialize	(	boost::asio::io_service &	ioService,
		uint32	updateInterval
	)

{
 _updateInterval = updateInterval;
 _updateTimer = new boost::asio::deadline_timer(ioService);
 _resolver = new boost::asio::ip::tcp::resolver(ioService);

 // Get the content of the realmlist table in the database
 UpdateRealms(boost::system::error_code());
}

Here is the call graph for this function:

RealmList * RealmList::Instance ( )

static

{
 static RealmList instance;
 return &instance;
}

uint32 RealmList::JoinRealm	(	uint32	realmAddress,
		uint32	build,
		boost::asio::ip::address const &	clientAddress,
		std::array< uint8, 32 > const &	clientSecret,
		LocaleConstant	locale,
		std::string const &	os,
		std::string	accountName,
		bgs::protocol::game_utilities::v1::ClientResponse *	response
	)		const

{
 if (Realm const* realm = GetRealm(Battlenet::RealmHandle(realmAddress)))
 {
 if (realm->Flags & REALM_FLAG_OFFLINE || realm->Build != build)
 return ERROR_USER_SERVER_NOT_PERMITTED_ON_REALM;

 JSON::RealmList::RealmListServerIPAddresses serverAddresses;
 JSON::RealmList::RealmIPAddressFamily* addressFamily = serverAddresses.add_families();
 addressFamily->set_family(1);

 JSON::RealmList::IPAddress* address = addressFamily->add_addresses();
 address->set_ip(realm->GetAddressForClient(clientAddress).address().to_string());
 address->set_port(realm->Port);

 std::string json = "JSONRealmListServerIPAddresses:" + JSON::Serialize(serverAddresses);

 uLong compressedLength = compressBound(json.length());
 std::vector<uint8> compressed;
 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;

 BigNumber serverSecret;
 serverSecret.SetRand(8 * 32);

 SHA256Hash wowSessionKey;
 wowSessionKey.UpdateData(clientSecret.data(), clientSecret.size());
 wowSessionKey.UpdateData(serverSecret.AsByteArray(32).get(), 32);
 wowSessionKey.Finalize();

 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_BNET_GAME_ACCOUNT_LOGIN_INFO);
 stmt->setString(0, ByteArrayToHexStr(wowSessionKey.GetDigest(), wowSessionKey.GetLength(), true));
 stmt->setString(1, clientAddress.to_string());
 stmt->setUInt8(2, locale);
 stmt->setString(3, os);
 stmt->setString(4, accountName);
 LoginDatabase.DirectExecute(stmt);

 bgs::protocol::Attribute* attribute = response->add_attribute();
 attribute->set_name("Param_RealmJoinTicket");
 attribute->mutable_value()->set_blob_value(accountName);

 attribute = response->add_attribute();
 attribute->set_name("Param_ServerAddresses");
 attribute->mutable_value()->set_blob_value(compressed.data(), compressedLength + 4);

 attribute = response->add_attribute();
 attribute->set_name("Param_JoinSecret");
 attribute->mutable_value()->set_blob_value(serverSecret.AsByteArray(32).get(), 32);
 return ERROR_OK;
 }

 return ERROR_UTIL_SERVER_UNKNOWN_REALM;
}

Here is the call graph for this function:

void RealmList::UpdateRealm ( Battlenet::RealmHandle const &  id, uint32  build, const std::string &  name, ip::address const &  address, ip::address const &  localAddr, ip::address const &  localSubmask, uint16  port, uint8  icon, RealmFlags  flag, uint8  timezone, AccountTypes  allowedSecurityLevel, float  population  )

private

{
 // Create new if not exist or update existed
 Realm& realm = _realms[id];

 realm.Id = id;
 realm.Build = build;
 realm.Name = name;
 realm.Type = icon;
 realm.Flags = flag;
 realm.Timezone = timezone;
 realm.AllowedSecurityLevel = allowedSecurityLevel;
 realm.PopulationLevel = population;
 realm.ExternalAddress = address;
 realm.LocalAddress = localAddr;
 realm.LocalSubnetMask = localSubmask;
 realm.Port = port;
}

Here is the caller graph for this function:

void RealmList::UpdateRealms ( boost::system::error_code const &  error )

private

{
 if (error)
 return;

 TC_LOG_DEBUG("realmlist", "Updating Realm List...");

 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST);
 PreparedQueryResult result = LoginDatabase.Query(stmt);

 std::map<Battlenet::RealmHandle, std::string> existingRealms;
 for (auto const& p : _realms)
 existingRealms[p.first] = p.second.Name;

 _realms.clear();

 // Circle through results and add them to the realm map
 if (result)
 {
 do
 {
 try
 {
 boost::asio::ip::tcp::resolver::iterator end;

 Field* fields = result->Fetch();
 uint32 realmId = fields[0].GetUInt32();
 std::string name = fields[1].GetString();
 boost::asio::ip::tcp::resolver::query externalAddressQuery(ip::tcp::v4(), fields[2].GetString(), "");

 boost::system::error_code ec;
 boost::asio::ip::tcp::resolver::iterator endPoint = _resolver->resolve(externalAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("realmlist", "Could not resolve address %s for realm \"%s\" id %u", fields[2].GetString().c_str(), name.c_str(), realmId);
 continue;
 }

 ip::address externalAddress = (*endPoint).endpoint().address();

 boost::asio::ip::tcp::resolver::query localAddressQuery(ip::tcp::v4(), fields[3].GetString(), "");
 endPoint = _resolver->resolve(localAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("realmlist", "Could not resolve localAddress %s for realm \"%s\" id %u", fields[3].GetString().c_str(), name.c_str(), realmId);
 continue;
 }

 ip::address localAddress = (*endPoint).endpoint().address();

 boost::asio::ip::tcp::resolver::query localSubmaskQuery(ip::tcp::v4(), fields[4].GetString(), "");
 endPoint = _resolver->resolve(localSubmaskQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("realmlist", "Could not resolve localSubnetMask %s for realm \"%s\" id %u", fields[4].GetString().c_str(), name.c_str(), realmId);
 continue;
 }

 ip::address localSubmask = (*endPoint).endpoint().address();

 uint16 port = fields[5].GetUInt16();
 uint8 icon = fields[6].GetUInt8();
 if (icon == REALM_TYPE_FFA_PVP)
 icon = REALM_TYPE_PVP;
 if (icon >= MAX_CLIENT_REALM_TYPE)
 icon = REALM_TYPE_NORMAL;
 RealmFlags flag = RealmFlags(fields[7].GetUInt8());
 uint8 timezone = fields[8].GetUInt8();
 uint8 allowedSecurityLevel = fields[9].GetUInt8();
 float pop = fields[10].GetFloat();
 uint32 build = fields[11].GetUInt32();
 uint8 region = fields[12].GetUInt8();
 uint8 battlegroup = fields[13].GetUInt8();

 Battlenet::RealmHandle id{ region, battlegroup, realmId };

 UpdateRealm(id, build, name, externalAddress, localAddress, localSubmask, port, icon, flag,
 timezone, (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), pop);

 _subRegions.insert(Battlenet::RealmHandle{ region, battlegroup, 0 }.GetAddressString());

 if (!existingRealms.count(id))
 TC_LOG_INFO("realmlist", "Added realm \"%s\" at %s:%u.", name.c_str(), externalAddress.to_string().c_str(), port);
 else
 TC_LOG_DEBUG("realmlist", "Updating realm \"%s\" at %s:%u.", name.c_str(), externalAddress.to_string().c_str(), port);

 existingRealms.erase(id);
 }
 catch (std::exception& ex)
 {
 TC_LOG_ERROR("realmlist", "Realmlist::UpdateRealms has thrown an exception: %s", ex.what());
 ABORT();
 }
 }
 while (result->NextRow());
 }

 for (auto itr = existingRealms.begin(); itr != existingRealms.end(); ++itr)
 TC_LOG_INFO("realmlist", "Removed realm \"%s\".", itr->second.c_str());

 if (_updateInterval)
 {
 _updateTimer->expires_from_now(boost::posix_time::seconds(_updateInterval));
 _updateTimer->async_wait(std::bind(&RealmList::UpdateRealms, this, std::placeholders::_1));
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RealmList::WriteSubRegions

(

bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse *

response

)

const

{
 for (std::string const& subRegion : GetSubRegions())
 response->add_attribute_value()->set_string_value(subRegion);
}

Here is the call graph for this function:

Member Data Documentation

RealmMap RealmList::_realms

private

boost::asio::ip::tcp::resolver* RealmList::_resolver

private

std::unordered_set<std::string> RealmList::_subRegions

private

uint32 RealmList::_updateInterval

private

boost::asio::deadline_timer* RealmList::_updateTimer

private

---

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

• src/server/shared/Realm/RealmList.h
• src/server/shared/Realm/RealmList.cpp