LoginRESTService Class Reference

#include <LoginRESTService.h>

Classes
struct	ContentTypePlugin
struct	LoginTicket
struct	ResponseCodePlugin

Public Member Functions
	LoginRESTService ()
bool	Start (boost::asio::io_service &ioService)
void	Stop ()
boost::asio::ip::tcp::endpoint const &	GetAddressForClient (boost::asio::ip::address const &address) const
std::unique_ptr < Battlenet::Session::AccountInfo >	VerifyLoginTicket (std::string const &id)

Static Public Member Functions
static LoginRESTService &	Instance ()

Private Member Functions
void	Run ()
int32	HandleGet (soap *soapClient)
int32	HandlePost (soap *soapClient)
int32	SendResponse (soap *soapClient, google::protobuf::Message const &response)
std::string	CalculateShaPassHash (std::string const &name, std::string const &password)
void	AddLoginTicket (std::string const &id, std::unique_ptr< Battlenet::Session::AccountInfo > accountInfo)
void	CleanupLoginTickets (boost::system::error_code const &error)

Private Attributes
std::thread	_thread
std::atomic< bool >	_stopped
Battlenet::JSON::Login::FormInputs	_formInputs
std::string	_bindIP
int32	_port
boost::asio::ip::tcp::endpoint	_externalAddress
boost::asio::ip::tcp::endpoint	_localAddress
std::mutex	_loginTicketMutex
std::unordered_map < std::string, LoginTicket >	_validLoginTickets
boost::asio::deadline_timer *	_loginTicketCleanupTimer

Friends
int32	handle_get_plugin (soap *soapClient)
int32	handle_post_plugin (soap *soapClient)

Constructor & Destructor Documentation

LoginRESTService::LoginRESTService ( )

inline

: _stopped(false), _port(0) { }

Member Function Documentation

void LoginRESTService::AddLoginTicket ( std::string const &  id, std::unique_ptr< Battlenet::Session::AccountInfo >  accountInfo  )

private

{
 std::unique_lock<std::mutex> lock(_loginTicketMutex);

 _validLoginTickets[id] = { id, std::move(accountInfo), time(nullptr) + 10 };
}

Here is the caller graph for this function:

std::string LoginRESTService::CalculateShaPassHash ( std::string const &  name, std::string const &  password  )

private

{
 SHA256Hash email;
 email.UpdateData(name);
 email.Finalize();

 SHA256Hash sha;
 sha.UpdateData(ByteArrayToHexStr(email.GetDigest(), email.GetLength()));
 sha.UpdateData(":");
 sha.UpdateData(password);
 sha.Finalize();

 return ByteArrayToHexStr(sha.GetDigest(), sha.GetLength(), true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void LoginRESTService::CleanupLoginTickets ( boost::system::error_code const &  error )

private

{
 if (error)
 return;

 time_t now = time(nullptr);

 {
 std::unique_lock<std::mutex> lock(_loginTicketMutex);
 for (auto itr = _validLoginTickets.begin(); itr != _validLoginTickets.end();)
 {
 if (itr->second.ExpiryTime < now)
 itr = _validLoginTickets.erase(itr);
 else
 ++itr;
 }
 }

 _loginTicketCleanupTimer->expires_from_now(boost::posix_time::seconds(10));
 _loginTicketCleanupTimer->async_wait(std::bind(&LoginRESTService::CleanupLoginTickets, this, std::placeholders::_1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

boost::asio::ip::tcp::endpoint const & LoginRESTService::GetAddressForClient

(

boost::asio::ip::address const &

address

)

const

{
 if (address.is_loopback())
 return _localAddress;
 else if (_localAddress.address().is_loopback())
 return _externalAddress;

 if (boost::asio::ip::address_v4::netmask(_localAddress.address().to_v4()).to_ulong() & address.to_v4().to_ulong())
 return _localAddress;

 return _externalAddress;
}

int32 LoginRESTService::HandleGet ( soap *  soapClient )

private

{
 boost::asio::ip::address_v4 address(soapClient->ip);
 std::string ip_address = address.to_string();

 TC_LOG_DEBUG("server.rest", "[%s:%d] Handling GET request path=\"%s\"", ip_address.c_str(), soapClient->port, soapClient->path);

 static std::string const expectedPath = "/bnetserver/login/";
 if (strstr(soapClient->path, expectedPath.c_str()) != &soapClient->path[0])
 return 404;

 return SendResponse(soapClient, _formInputs);
}

Here is the call graph for this function:

int32 LoginRESTService::HandlePost ( soap *  soapClient )

private

{
 boost::asio::ip::address_v4 address(soapClient->ip);
 std::string ip_address = address.to_string();

 TC_LOG_DEBUG("server.rest", "[%s:%d] Handling POST request path=\"%s\"", ip_address.c_str(), soapClient->port, soapClient->path);

 static std::string const expectedPath = "/bnetserver/login/";
 if (strstr(soapClient->path, expectedPath.c_str()) != &soapClient->path[0])
 return 404;

 char *buf;
 size_t len;
 soap_http_body(soapClient, &buf, &len);

 Battlenet::JSON::Login::LoginForm loginForm;
 Battlenet::JSON::Login::LoginResult loginResult;
 if (!JSON::Deserialize(buf, &loginForm))
 {
 if (soap_register_plugin_arg(soapClient, &ResponseCodePlugin::Init, nullptr) != SOAP_OK)
 return 500;

 ResponseCodePlugin* responseCode = reinterpret_cast<ResponseCodePlugin*>(soap_lookup_plugin(soapClient, ResponseCodePlugin::PluginId));
 ASSERT(responseCode);

 responseCode->ErrorCode = 400;

 loginResult.set_authentication_state(Battlenet::JSON::Login::LOGIN);
 loginResult.set_error_code("UNABLE_TO_DECODE");
 loginResult.set_error_message("There was an internal error while connecting to Battle.net. Please try again later.");
 return SendResponse(soapClient, loginResult);
 }

 std::string login;
 std::string password;

 for (int32 i = 0; i < loginForm.inputs_size(); ++i)
 {
 if (loginForm.inputs(i).input_id() == "account_name")
 login = loginForm.inputs(i).value();
 else if (loginForm.inputs(i).input_id() == "password")
 password = loginForm.inputs(i).value();
 }

 Utf8ToUpperOnlyLatin(login);
 Utf8ToUpperOnlyLatin(password);

 PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_ACCOUNT_INFO);
 stmt->setString(0, login);
 stmt->setString(1, CalculateShaPassHash(login, std::move(password)));
 if (PreparedQueryResult result = LoginDatabase.Query(stmt))
 {
 std::unique_ptr<Battlenet::Session::AccountInfo> accountInfo = Trinity::make_unique<Battlenet::Session::AccountInfo>();
 accountInfo->LoadResult(result);

 stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_CHARACTER_COUNTS_BY_BNET_ID);
 stmt->setUInt32(0, accountInfo->Id);
 if (PreparedQueryResult characterCountsResult = LoginDatabase.Query(stmt))
 {
 do
 {
 Field* fields = characterCountsResult->Fetch();
 accountInfo->GameAccounts[fields[0].GetUInt32()]
 .CharacterCounts[Battlenet::RealmHandle{ fields[3].GetUInt8(), fields[4].GetUInt8(), fields[2].GetUInt32() }.GetAddress()] = fields[1].GetUInt8();

 } while (characterCountsResult->NextRow());
 }

 stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_BNET_LAST_PLAYER_CHARACTERS);
 stmt->setUInt32(0, accountInfo->Id);
 if (PreparedQueryResult lastPlayerCharactersResult = LoginDatabase.Query(stmt))
 {
 Field* fields = lastPlayerCharactersResult->Fetch();
 Battlenet::RealmHandle realmId{ fields[1].GetUInt8(), fields[2].GetUInt8(), fields[3].GetUInt32() };
 Battlenet::Session::LastPlayedCharacterInfo& lastPlayedCharacter = accountInfo->GameAccounts[fields[0].GetUInt32()]
 .LastPlayedCharacters[realmId.GetSubRegionAddress()];

 lastPlayedCharacter.RealmId = realmId;
 lastPlayedCharacter.CharacterName = fields[4].GetString();
 lastPlayedCharacter.CharacterGUID = fields[5].GetUInt64();
 lastPlayedCharacter.LastPlayedTime = fields[6].GetUInt32();
 }

 BigNumber ticket;
 ticket.SetRand(20 * 8);

 loginResult.set_login_ticket("TC-" + ByteArrayToHexStr(ticket.AsByteArray(20).get(), 20));

 AddLoginTicket(loginResult.login_ticket(), std::move(accountInfo));
 }

 loginResult.set_authentication_state(Battlenet::JSON::Login::DONE);
 return SendResponse(soapClient, loginResult);
}

Here is the call graph for this function:

LoginRESTService & LoginRESTService::Instance ( )

static

{
 static LoginRESTService instance;
 return instance;
}

void LoginRESTService::Run ( )

private

{
 soap soapServer(SOAP_C_UTFSTRING, SOAP_C_UTFSTRING);

 // check every 3 seconds if world ended
 soapServer.accept_timeout = 3;
 soapServer.recv_timeout = 5;
 soapServer.send_timeout = 5;
 if (!soap_valid_socket(soap_bind(&soapServer, _bindIP.c_str(), _port, 100)))
 {
 TC_LOG_ERROR("server.rest", "Couldn't bind to %s:%d", _bindIP.c_str(), _port);
 return;
 }

 TC_LOG_INFO("server.rest", "Login service bound to http://%s:%d", _bindIP.c_str(), _port);

 http_post_handlers handlers[] =
 {
 { "application/json;charset=utf-8", handle_post_plugin },
 { "application/json", handle_post_plugin },
 { nullptr, nullptr }
 };

 soap_register_plugin_arg(&soapServer, &http_get, (void*)&handle_get_plugin);
 soap_register_plugin_arg(&soapServer, &http_post, handlers);
 soap_register_plugin_arg(&soapServer, &ContentTypePlugin::Init, (void*)"application/json;charset=utf-8");

 // Use our already ready ssl context
 soapServer.ctx = Battlenet::SslContext::instance().native_handle();
 soapServer.ssl_flags = SOAP_SSL_RSA;

 while (!_stopped)
 {
 if (!soap_valid_socket(soap_accept(&soapServer)))
 continue; // ran into an accept timeout

 std::shared_ptr<soap> soapClient = std::make_shared<soap>(soapServer);
 boost::asio::ip::address_v4 address(soapClient->ip);
 if (soap_ssl_accept(soapClient.get()) != SOAP_OK)
 {
 TC_LOG_DEBUG("server.rest", "Failed SSL handshake from IP=%s", address.to_string().c_str());
 continue;
 }

 TC_LOG_DEBUG("server.rest", "Accepted connection from IP=%s", address.to_string().c_str());

 std::thread([soapClient]
 {
 soap_serve(soapClient.get());
 }).detach();
 }

 // and release the context handle here - soap does not own it so it should not free it on exit
 soapServer.ctx = nullptr;

 TC_LOG_INFO("server.rest", "Login service exiting...");
}

Here is the call graph for this function:

Here is the caller graph for this function:

int32 LoginRESTService::SendResponse ( soap *  soapClient, google::protobuf::Message const &  response  )

private

{
 std::string jsonResponse = JSON::Serialize(response);

 soap_response(soapClient, SOAP_FILE);
 soap_send_raw(soapClient, jsonResponse.c_str(), jsonResponse.length());
 return soap_end_send(soapClient);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool LoginRESTService::Start

(

boost::asio::io_service &

ioService

)

{
 _bindIP = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0");
 _port = sConfigMgr->GetIntDefault("LoginREST.Port", 8081);
 if (_port < 0 || _port > 0xFFFF)
 {
 TC_LOG_ERROR("server.rest", "Specified login service port (%d) out of allowed range (1-65535), defaulting to 8081", _port);
 _port = 8081;
 }

 boost::system::error_code ec;
 boost::asio::ip::tcp::resolver resolver(ioService);
 boost::asio::ip::tcp::resolver::iterator end;

 std::string configuredAddress = sConfigMgr->GetStringDefault("LoginREST.ExternalAddress", "127.0.0.1");
 boost::asio::ip::tcp::resolver::query externalAddressQuery(boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
 boost::asio::ip::tcp::resolver::iterator endPoint = resolver.resolve(externalAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("server.rest", "Could not resolve LoginREST.ExternalAddress %s", configuredAddress.c_str());
 return false;
 }

 _externalAddress = endPoint->endpoint();

 configuredAddress = sConfigMgr->GetStringDefault("LoginREST.LocalAddress", "127.0.0.1");
 boost::asio::ip::tcp::resolver::query localAddressQuery(boost::asio::ip::tcp::v4(), configuredAddress, std::to_string(_port));
 endPoint = resolver.resolve(localAddressQuery, ec);
 if (endPoint == end || ec)
 {
 TC_LOG_ERROR("server.rest", "Could not resolve LoginREST.ExternalAddress %s", configuredAddress.c_str());
 return false;
 }

 _localAddress = endPoint->endpoint();

 // set up form inputs
 Battlenet::JSON::Login::FormInput* input;
 _formInputs.set_type(Battlenet::JSON::Login::LOGIN_FORM);
 input = _formInputs.add_inputs();
 input->set_input_id("account_name");
 input->set_type("text");
 input->set_label("E-mail");
 input->set_max_length(320);

 input = _formInputs.add_inputs();
 input->set_input_id("password");
 input->set_type("password");
 input->set_label("Password");
 input->set_max_length(16);

 input = _formInputs.add_inputs();
 input->set_input_id("log_in_submit");
 input->set_type("submit");
 input->set_label("Log In");

 _loginTicketCleanupTimer = new boost::asio::deadline_timer(ioService);
 _loginTicketCleanupTimer->expires_from_now(boost::posix_time::seconds(10));
 _loginTicketCleanupTimer->async_wait(std::bind(&LoginRESTService::CleanupLoginTickets, this, std::placeholders::_1));

 _thread = std::thread(std::bind(&LoginRESTService::Run, this));
 return true;
}

Here is the call graph for this function:

void LoginRESTService::Stop

(

)

{
 _stopped = true;
 _loginTicketCleanupTimer->cancel();
 _thread.join();
}

std::unique_ptr< Battlenet::Session::AccountInfo > LoginRESTService::VerifyLoginTicket

(

std::string const &

id

)

{
 std::unique_lock<std::mutex> lock(_loginTicketMutex);

 auto itr = _validLoginTickets.find(id);
 if (itr != _validLoginTickets.end())
 {
 if (itr->second.ExpiryTime > time(nullptr))
 {
 std::unique_ptr<Battlenet::Session::AccountInfo> accountInfo = std::move(itr->second.Account);
 _validLoginTickets.erase(itr);
 return accountInfo;
 }
 }

 return std::unique_ptr<Battlenet::Session::AccountInfo>();
}

Friends And Related Function Documentation

int32 handle_get_plugin ( soap *  soapClient )

friend

{
 return sLoginService.HandleGet(soapClient);
}

int32 handle_post_plugin ( soap *  soapClient )

friend

{
 return sLoginService.HandlePost(soapClient);
}

Member Data Documentation

std::string LoginRESTService::_bindIP

private

boost::asio::ip::tcp::endpoint LoginRESTService::_externalAddress

private

Battlenet::JSON::Login::FormInputs LoginRESTService::_formInputs

private

boost::asio::ip::tcp::endpoint LoginRESTService::_localAddress

private

boost::asio::deadline_timer* LoginRESTService::_loginTicketCleanupTimer

private

std::mutex LoginRESTService::_loginTicketMutex

private

int32 LoginRESTService::_port

private

std::atomic<bool> LoginRESTService::_stopped

private

std::thread LoginRESTService::_thread

private

std::unordered_map<std::string, LoginTicket> LoginRESTService::_validLoginTickets

private

---

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

• src/server/bnetserver/REST/LoginRESTService.h
• src/server/bnetserver/REST/LoginRESTService.cpp