RASession Class Reference

#include "RASession.h"

Inheritance diagram for RASession:

Public Member Functions
	RASession (tcp::socket &&socket)
void	Start ()
const std::string	GetRemoteIpAddress () const
unsigned short	GetRemotePort () const

Private Member Functions
int	Send (std::string_view data)
std::string	ReadString ()
bool	CheckAccessLevel (const std::string &user)
bool	CheckPassword (const std::string &user, const std::string &pass)
bool	ProcessCommand (std::string &command)

Static Private Member Functions
static void	CommandPrint (void *callbackArg, std::string_view text)
static void	CommandFinished (void *callbackArg, bool)

Private Attributes
tcp::socket	_socket
boost::asio::streambuf	_readBuffer
boost::asio::streambuf	_writeBuffer
std::promise< void > *	_commandExecuting

Detailed Description

Constructor & Destructor Documentation

RASession()

RASession::RASession ( tcp::socket &&  socket )

inline

                                  :
        _socket(std::move(socket)), _commandExecuting(nullptr) { }

Member Function Documentation

CheckAccessLevel()

bool RASession::CheckAccessLevel ( const std::string &  user )

private

{
    std::string safeUser = user;
 
    Utf8ToUpperOnlyLatin(safeUser);
 
    auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_ACCESS);
    stmt->SetData(0, safeUser);
 
    PreparedQueryResult result = LoginDatabase.Query(stmt);
    if (!result)
    {
        LOG_INFO("commands.ra", "User {} does not exist in database", user);
        return false;
    }
 
    Field* fields = result->Fetch();
 
    if (fields[1].Get<uint8>() < sConfigMgr->GetOption<int32>("Ra.MinLevel", 3))
    {
        LOG_INFO("commands.ra", "User {} has no privilege to login", user);
        return false;
    }
    else if (fields[2].Get<int32>() != -1)
    {
        LOG_INFO("commands.ra", "User {} has to be assigned on all realms (with RealmID = '-1')", user);
        return false;
    }
 
    return true;
}

References LOG_INFO, LOGIN_SEL_ACCOUNT_ACCESS, LoginDatabase, sConfigMgr, and Utf8ToUpperOnlyLatin().

Referenced by Start().

CheckPassword()

bool RASession::CheckPassword ( const std::string &  user, const std::string &  pass  )

private

{
    std::string safe_user = user;
    std::transform(safe_user.begin(), safe_user.end(), safe_user.begin(), ::toupper);
    Utf8ToUpperOnlyLatin(safe_user);
 
    std::string safe_pass = pass;
    Utf8ToUpperOnlyLatin(safe_pass);
    std::transform(safe_pass.begin(), safe_pass.end(), safe_pass.begin(), ::toupper);
 
    auto* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_CHECK_PASSWORD_BY_NAME);
 
    stmt->SetData(0, safe_user);
 
    if (PreparedQueryResult result = LoginDatabase.Query(stmt))
    {
        Acore::Crypto::SRP6::Salt salt = (*result)[0].Get<Binary, Acore::Crypto::SRP6::SALT_LENGTH>();
        Acore::Crypto::SRP6::Verifier verifier = (*result)[1].Get<Binary, Acore::Crypto::SRP6::VERIFIER_LENGTH>();
 
        if (Acore::Crypto::SRP6::CheckLogin(safe_user, safe_pass, salt, verifier))
            return true;
    }
 
    LOG_INFO("commands.ra", "Wrong password for user: {}", user);
    return false;
}

References Acore::Crypto::SRP6::CheckLogin(), LOG_INFO, LOGIN_SEL_CHECK_PASSWORD_BY_NAME, LoginDatabase, Acore::Crypto::SRP6::SALT_LENGTH, Utf8ToUpperOnlyLatin(), and Acore::Crypto::SRP6::VERIFIER_LENGTH.

Referenced by Start().

CommandFinished()

void RASession::CommandFinished ( void *  callbackArg, bool    )

staticprivate

{
    RASession* session = static_cast<RASession*>(callbackArg);
    session->_commandExecuting->set_value();
}

References _commandExecuting.

Referenced by ProcessCommand().

CommandPrint()

void RASession::CommandPrint ( void *  callbackArg, std::string_view  text  )

staticprivate

{
    if (text.empty())
    {
        return;
    }
 
    RASession* session = static_cast<RASession*>(callbackArg);
    session->Send(text);
}

References Send().

Referenced by ProcessCommand().

GetRemoteIpAddress()

const std::string RASession::GetRemoteIpAddress ( ) const

inline

{ return _socket.remote_endpoint().address().to_string(); }

References _socket.

Referenced by Start().

GetRemotePort()

unsigned short RASession::GetRemotePort ( ) const

inline

{ return _socket.remote_endpoint().port(); }

References _socket.

ProcessCommand()

bool RASession::ProcessCommand ( std::string &  command )

private

{
    if (command.length() == 0)
        return true;
 
    LOG_INFO("commands.ra", "Received command: {}", command);
 
    // handle quit, exit and logout commands to terminate connection
    if (command == "quit" || command == "exit" || command == "logout")
    {
        Send("Bye\r\n");
        return true;
    }
 
    // Obtain a new promise per command
    delete _commandExecuting;
    _commandExecuting = new std::promise<void>();
 
    CliCommandHolder* cmd = new CliCommandHolder(this, command.c_str(), &RASession::CommandPrint, &RASession::CommandFinished);
    sWorld->QueueCliCommand(cmd);
 
    // Wait for the command to finish
    _commandExecuting->get_future().wait();
 
    return false;
}

References _commandExecuting, CommandFinished(), CommandPrint(), LOG_INFO, Send(), and sWorld.

Referenced by Start().

ReadString()

std::string RASession::ReadString ( )

private

{
    boost::system::error_code error;
    std::size_t read = boost::asio::read_until(_socket, _readBuffer, "\r\n", error);
    if (!read)
    {
        _socket.close();
        return "";
    }
 
    std::string line;
    std::istream is(&_readBuffer);
    std::getline(is, line);
 
    if (*line.rbegin() == '\r')
        line.erase(line.length() - 1);
 
    return line;
}

References _readBuffer, and _socket.

Referenced by Start().

Send()

int RASession::Send ( std::string_view  data )

private

{
    std::ostream os(&_writeBuffer);
    os << data;
    std::size_t written = _socket.send(_writeBuffer.data());
    _writeBuffer.consume(written);
    return written;
}

References _socket, and _writeBuffer.

Referenced by CommandPrint(), ProcessCommand(), and Start().

Start()

void RASession::Start

(

)

{
    // wait 1 second for active connections to send negotiation request
    for (int counter = 0; counter < 10 && _socket.available() == 0; counter++)
        std::this_thread::sleep_for(100ms);
 
    // Check if there are bytes available, if they are, then the client is requesting the negotiation
    if (_socket.available() > 0)
    {
        // Handle subnegotiation
        char buf[1024] = { };
        _socket.read_some(boost::asio::buffer(buf));
 
        // Send the end-of-negotiation packet
        uint8 const reply[2] = { 0xFF, 0xF0 };
        _socket.write_some(boost::asio::buffer(reply));
    }
 
    Send("Authentication Required\r\n");
    Send("Username: ");
 
    std::string username = ReadString();
 
    if (username.empty())
        return;
 
    LOG_INFO("commands.ra", "Accepting RA connection from user {} (IP: {})", username, GetRemoteIpAddress());
 
    Send("Password: ");
 
    std::string password = ReadString();
    if (password.empty())
        return;
 
    if (!CheckAccessLevel(username) || !CheckPassword(username, password))
    {
        Send("Authentication failed\r\n");
        _socket.close();
        return;
    }
 
    LOG_INFO("commands.ra", "User {} (IP: {}) authenticated correctly to RA", username, GetRemoteIpAddress());
 
    // Authentication successful, send the motd
    Send(std::string(std::string(sMotdMgr->GetMotd(DEFAULT_LOCALE)) + "\r\n").c_str());
 
    // Read commands
    for (;;)
    {
        Send("AC>");
        std::string command = ReadString();
 
        if (ProcessCommand(command))
            break;
    }
 
    _socket.close();
}

References _socket, CheckAccessLevel(), CheckPassword(), DEFAULT_LOCALE, GetRemoteIpAddress(), LOG_INFO, ProcessCommand(), ReadString(), Send(), and sMotdMgr.

Member Data Documentation

_commandExecuting

std::promise<void>* RASession::_commandExecuting

private

Referenced by CommandFinished(), and ProcessCommand().

_readBuffer

boost::asio::streambuf RASession::_readBuffer

private

Referenced by ReadString().

_socket

tcp::socket RASession::_socket

private

Referenced by GetRemoteIpAddress(), GetRemotePort(), ReadString(), Send(), and Start().

_writeBuffer

boost::asio::streambuf RASession::_writeBuffer

private

Referenced by Send().