Horizon::Auth::AuthServer Class Reference

#include <Auth.hpp>

Inheritance diagram for Horizon::Auth::AuthServer:

Collaboration diagram for Horizon::Auth::AuthServer:

Public Member Functions
	AuthServer ()
	Horizon Constructor. More...
	~AuthServer ()
	Horizon Destructor. More...
bool	read_config ()
	Read /config/horizon-server.yaml. More...
void	initialize () override
void	finalize () override
void	generate_salt (std::vector< unsigned char > &salt)
void	hash_password (const std::string &password, const std::vector< unsigned char > &salt, std::vector< unsigned char > &hash)
void	initialize_cli_commands ()
	Initialize CLI Comamnds. More...
bool	clicmd_reload_config (std::string)
	CLI Command: Reload Configuration. More...
bool	clicmd_create_new_account (std::string)
bool	clicmd_reset_password (std::string)
void	verify_connected_sessions ()
TaskScheduler &	getScheduler ()
auth_config_type &	get_auth_config ()
void	update (uint64_t time)
Public Member Functions inherited from Server
	Server ()
	~Server ()
void	parse_exec_args (const char *argv[], int argc)
virtual void	initialize ()
virtual void	finalize ()
virtual void	post_initialize ()
virtual void	post_finalize ()
void	print_help ()
struct general_server_configuration &	general_conf ()
bool	parse_common_configs (sol::table &cfg)
std::shared_ptr< boost::mysql::tcp_ssl_connection >	get_database_connection ()
bool	test_database_connection ()
Public Member Functions inherited from Kernel
	Kernel (general_server_configuration &config)
	~Kernel ()
virtual void	initialize ()=0
virtual void	finalize ()=0
virtual void	post_initialize ()=0
virtual void	post_finalize ()=0
struct general_server_configuration &	general_conf ()
template<typename T >
std::shared_ptr< T >	get_component (std::string uuid)
template<typename T >
std::shared_ptr< T >	get_component_of_type (Horizon::System::runtime_module_type type, int segment_number=1)
template<typename T >
void	register_component (Horizon::System::runtime_module_type type, T &&component)
template<typename T >
void	register_component (Horizon::System::runtime_module_type type, std::shared_ptr< T > component)
void	deregister_component (Horizon::System::runtime_module_type type, int segment_number=1)
int	get_registered_component_count_of_type (Horizon::System::runtime_module_type type)
template<typename ComponentType , std::size_t Priority, typename Key , typename Value >
int	get_segment_number_for_resource (Horizon::System::runtime_module_type module_t, Key resource_key, Value resource_not_found_value)
int	get_component_count ()
KernelComponents &	get_components ()
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContext > context)
void	system_routine_queue_push (std::shared_ptr< Horizon::System::RuntimeContextChain > context)
void	system_routine_process_queue ()
void	system_routine_register (Horizon::System::runtime_module_type module_t, Horizon::System::runtime_synchronization_method sync_t, std::shared_ptr< Horizon::System::RuntimeContext > context)
Horizon::System::SystemRoutineManager &	get_system_routine_manager ()
boost::asio::io_context &	get_io_context ()
void	set_signal_interrupt_command_line_loop (bool signal)
bool	get_signal_interrupt_command_line_loop ()

Static Public Member Functions
static AuthServer *	getInstance ()

Protected Attributes
TaskScheduler	_task_scheduler
std::mutex	_conf_lock
auth_config_type	_auth_config
boost::asio::deadline_timer	_update_timer
Protected Attributes inherited from Server
struct general_server_configuration	general_config
Protected Attributes inherited from Kernel
boost::asio::io_context	_io_context_global
KernelComponents	_components
general_server_configuration	_config

Constructor & Destructor Documentation

AuthServer()

AuthServer::AuthServer

(

)

Horizon Constructor.

: Server(), _update_timer(get_io_context())
{
}

~AuthServer()

AuthServer::~AuthServer

(

)

Horizon Destructor.

{
}

Member Function Documentation

clicmd_create_new_account()

bool AuthServer::clicmd_create_new_account

(

std::string

cmd

)

{
    std::vector<std::string> separated_args;
    std::string help_str = "Usage: create-account <username> <password> <email> <birthdate: YYYY-MM-DD> <pincode> {"
        "{<account_gender = 'M' or 'F' or 'C' (Character Dependent)>}, {<group_id>}, {<character_slots>}}";
    
    boost::algorithm::split(separated_args, cmd, boost::algorithm::is_any_of(" "));
 
    if (separated_args.size() < 6) {
        HLog(error) << "create-account command requires at least 5 arguments.";
        HLog(error) << help_str;
        return false;
    }
 
    std::string username = separated_args[1];
    std::string password = separated_args[2];
    std::string email = separated_args[3];
    std::string birthdate = separated_args[4];
    std::string pincode = separated_args[5];
 
    game_account_gender_type gender = separated_args.size() >= 7 ? ((separated_args[6] == "M" ? ACCOUNT_GENDER_MALE : (separated_args[6] == "F" ? ACCOUNT_GENDER_FEMALE : ACCOUNT_GENDER_NONE))) : ACCOUNT_GENDER_NONE;
    int group_id = separated_args.size() >= 8 ? std::stoi(separated_args[7]) : 0;
    int character_slots = separated_args.size() >= 9 ? std::stoi(separated_args[8]) : 3;
    
    try {
        auto b1 = get_database_connection()->prepare_statement("SELECT `id` FROM game_accounts WHERE `username` = ?").bind(username);
        boost::mysql::results results;
        get_database_connection()->execute(b1, results);
 
        if (!results.rows().empty()) {
            HLog(error) << "Account with username '" << username << "' already exists.";
            return false;
        }
 
        std::vector<unsigned char> salt;
        std::vector<unsigned char> hash;
 
        sAuth->generate_salt(salt);
        sAuth->hash_password(password, salt, hash);
        boost::mysql::statement stmt = get_database_connection()->prepare_statement("INSERT INTO `game_accounts` (`username`, `hash`, `salt`, `gender`, `email`, `birth_date`, `character_slots`, `pincode`, `group_id`, `state`) "
            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
        auto b2 = stmt.bind(username, hash, salt, gender == ACCOUNT_GENDER_MALE ? "M" : (gender == ACCOUNT_GENDER_FEMALE ? "F" : "NA"), 
                email, birthdate, character_slots, pincode, group_id, (int)ACCOUNT_STATE_NONE);
        get_database_connection()->execute(b2, results);
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << error.what();
        return false;
    }
    
    HLog(info) << "Account '" << username << "' has been created successfully.";
 
    return true;
}

References ACCOUNT_GENDER_FEMALE, ACCOUNT_GENDER_MALE, ACCOUNT_GENDER_NONE, ACCOUNT_STATE_NONE, Server::get_database_connection(), HLog, and sAuth.

Referenced by initialize_cli_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

clicmd_reload_config()

bool AuthServer::clicmd_reload_config

(

std::string

)

CLI Command: Reload Configuration.

Returns

boolean value from AuthServer->ReadConfig()

{
    HLog(info) << "Reloading configuration from '" << general_conf().get_config_file_path() << "'";
 
    return read_config();
}

References Server::general_conf(), general_server_configuration::get_config_file_path(), HLog, and read_config().

Referenced by initialize_cli_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

clicmd_reset_password()

bool AuthServer::clicmd_reset_password

(

std::string

cmd

)

{
    std::vector<std::string> separated_args;
    std::string help_str = "Usage: reset-password <username> <new_password>";
 
    boost::algorithm::split(separated_args, cmd, boost::algorithm::is_any_of(" "));
 
    if (separated_args.size() < 3) {
        HLog(error) << "reset-password command requires 2 arguments.";
        HLog(error) << help_str;
        return false;
    }
 
    std::string username = separated_args[1];
    std::string new_password = separated_args[2];
 
    try {
        auto b1 = get_database_connection()->prepare_statement("SELECT `id` FROM game_accounts WHERE `username` = ?").bind(username);
        boost::mysql::results results;
        get_database_connection()->execute(b1, results);
 
        if (results.rows().empty()) {
            HLog(error) << "Account with username '" << username << "' does not exist.";
            return false;
        }
 
        std::vector<unsigned char> salt;
 
        sAuth->generate_salt(salt);
 
        std::vector<unsigned char> hash;
        sAuth->hash_password(new_password, salt, hash);
 
        boost::mysql::statement stmt = get_database_connection()->prepare_statement("UPDATE `game_accounts` SET `hash` = ?, `salt` = ? WHERE `username` = ?");
        auto b2 = stmt.bind(hash, salt, username);
        get_database_connection()->execute(b2, results);
 
        HLog(info) << "Password for account '" << username << "' has been reset successfully.";
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << error.what();
        return false;
    }
    return true;
}

References Server::get_database_connection(), HLog, and sAuth.

Referenced by initialize_cli_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

finalize()

void AuthServer::finalize ( )

overridevirtual

Server shutdown routine begins here...

Reimplemented from Server.

{
    HLog(info) << "Shutdown process initiated...";
 
    if (!get_io_context().stopped())
        get_io_context().stop();
 
    Server::finalize();
    
    Server::post_finalize();
}

References Server::finalize(), Kernel::get_io_context(), HLog, and Server::post_finalize().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_salt()

void Horizon::Auth::AuthServer::generate_salt ( std::vector< unsigned char > &  salt )

inline

                                                       {
        salt.resize(SALT_LEN);
        if (!RAND_bytes(salt.data(), SALT_LEN)) {
            throw std::runtime_error("Failed to generate salt");
        }
    }

References Horizon::Auth::SALT_LEN.

get_auth_config()

auth_config_type & Horizon::Auth::AuthServer::get_auth_config ( )

inline

    {
        std::lock_guard<std::mutex> lock(_conf_lock);
        return _auth_config;
    }

References _auth_config, and _conf_lock.

Referenced by initialize(), read_config(), and verify_connected_sessions().

Here is the caller graph for this function:

getInstance()

static AuthServer * Horizon::Auth::AuthServer::getInstance ( )

inlinestatic

    {
        static AuthServer instance;
        return &instance;
    }

getScheduler()

TaskScheduler & Horizon::Auth::AuthServer::getScheduler ( )

inline

{ return _task_scheduler; }

References _task_scheduler.

Referenced by update().

Here is the caller graph for this function:

hash_password()

void Horizon::Auth::AuthServer::hash_password ( const std::string &  password, const std::vector< unsigned char > &  salt, std::vector< unsigned char > &  hash  )

inline

                                                                                                                        {
        hash.resize(HASH_LEN);
        if (!PKCS5_PBKDF2_HMAC(password.c_str(), password.length(), salt.data(), salt.size(), ITERATIONS, EVP_sha256(), HASH_LEN, hash.data())) {
            throw std::runtime_error("Failed to hash password");
        }
    }

References Horizon::Auth::HASH_LEN, and Horizon::Auth::ITERATIONS.

initialize()

void AuthServer::initialize ( )

overridevirtual

Core Signal Handler

Reimplemented from Server.

{
    signal(SIGINT, SignalHandler);
    signal(SIGTERM, SignalHandler);
#ifndef WIN32
    signal(SIGQUIT, SignalHandler);
#endif
 
    // Start Horizon Network
    sClientSocketMgr->start(get_io_context(), 
        general_conf().get_listen_ip(), 
        general_conf().get_listen_port(), 
        get_auth_config().max_network_threads(),
        general_conf().is_test_run() && general_conf().is_test_run_with_network() == false);
    
    // Initialize core.
    Server::initialize();
    
    Server::post_initialize();
 
    initialize_cli_commands();
        
    _update_timer.expires_from_now(boost::posix_time::microseconds(MAX_CORE_UPDATE_INTERVAL));
    _update_timer.async_wait(std::bind(&AuthServer::update, this, MAX_CORE_UPDATE_INTERVAL));
 
    _task_scheduler.Schedule(Seconds(0), [this] (TaskContext context) {
        verify_connected_sessions();
        context.Repeat(Seconds(60));
    });
 
    // Run the io_context until stop is called from the internal, finalizing thread.
    // After stopping, execution will continue through the next line onwards.
    // We actually finalize on this thread and not in any of io_context's internal threads.
    get_io_context().run();
 
    /*
     * Core Cleanup
     */
    HLog(info) << "Server shutting down...";
 
    HLogShutdown;
 
    set_shutdown_stage(SHUTDOWN_CLEANUP_COMPLETE);
}

References _task_scheduler, _update_timer, Server::general_conf(), get_auth_config(), Kernel::get_io_context(), HLog, HLogShutdown, Server::initialize(), initialize_cli_commands(), MAX_CORE_UPDATE_INTERVAL, Server::post_initialize(), TaskContext::Repeat(), TaskScheduler::Schedule(), sClientSocketMgr, set_shutdown_stage(), SHUTDOWN_CLEANUP_COMPLETE, SignalHandler(), update(), and verify_connected_sessions().

Here is the call graph for this function:

initialize_cli_commands()

void AuthServer::initialize_cli_commands

(

)

Initialize CLI Comamnds.

{
    if (general_conf().is_test_run() && general_conf().is_test_run_minimal())
        return;
 
    get_component_of_type<CommandLineProcess>(Horizon::System::RUNTIME_COMMANDLINE)->add_function("reloadconf", std::bind(&AuthServer::clicmd_reload_config, this, std::placeholders::_1));
    get_component_of_type<CommandLineProcess>(Horizon::System::RUNTIME_COMMANDLINE)->add_function("create-account", std::bind(&AuthServer::clicmd_create_new_account, this, std::placeholders::_1));
    get_component_of_type<CommandLineProcess>(Horizon::System::RUNTIME_COMMANDLINE)->add_function("reset-password", std::bind(&AuthServer::clicmd_reset_password, this, std::placeholders::_1));
}

References clicmd_create_new_account(), clicmd_reload_config(), clicmd_reset_password(), Server::general_conf(), and Horizon::System::RUNTIME_COMMANDLINE.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

read_config()

bool AuthServer::read_config

(

)

Read /config/horizon-server.yaml.

Returns

true on success, false on failure.

Process Configuration that is common between servers.

{
    sol::state lua;
 
    std::string file_path = general_conf().get_config_file_path().string();
    std::string tmp_string;
    sol::table tbl;
 
    if (!boost::filesystem::exists(file_path)) {
        HLog(error) << "Configuration file does not exist at " << file_path << "." << std::endl;
        return false;
    }
    
    // Read the file. If there is an error, report it and exit.
    try {
        lua.script_file(file_path);
        tbl = lua["horizon_config"];
    } catch (const std::exception &error) {
        HLog(error) << "Horizon::ReadConfig: '" << error.what() << "'.";
        return false;
    }
    
    try {
        sol::table char_servers = tbl.get<sol::table>("character_servers");
        char_servers.for_each([&](sol::object const &key, sol::object const &value) {
            auth_config_type::char_server c;
            sol::table cfg = value.as<sol::table>();
            
            c._name = cfg.get<std::string>("Name");
            c._host = cfg.get<std::string>("Host");
            c._port = cfg.get<uint16_t>("Port");
            c._type = cfg.get<uint16_t>("Type");
            c._is_new = cfg.get<uint16_t>("IsNew");
            
            get_auth_config().add_char_server(c);
            
            HLog(info) << "Character server '" << c._name << "' is configured.";
        });
    } catch (std::exception &error) {
        HLog(error) << "Character server configuration error:" << error.what() << ".";
        return false;
    }
    
    int char_server_count = get_auth_config().get_char_servers().size();
    HLog(info) << char_server_count << " character servers were configured.";
    
    // Max network threads
    if (tbl.get<sol::object>("max_network_threads") != sol::lua_nil) {
        get_auth_config().set_max_network_threads(tbl.get<int>("max_network_threads"));
    } else {
        horizon_config_error("max_network_threads", 1);
    }
 
    try {
        int32_t session_max_timeout = tbl.get_or("session_max_timeout", 60);
        get_auth_config().set_session_max_timeout(session_max_timeout);
        HLog(info) << "Session maximum timeout set to '" << get_auth_config().session_max_timeout() << "',"
            << " sessions surpassing this time limit will be disconnected.";
    } catch (sol::error &err) {
        HLog(error) << "Error for setting session_max_timeout:" << err.what();
    }
 
    HLog(info) << "Max Network Threads set to '" << get_auth_config().max_network_threads() << "'.";
 
    if (!parse_common_configs(tbl))
        return false;
 
    HLog(info) << "Done reading server configuration from '" << file_path << "'.";
 
    return true;
}

References Horizon::Auth::auth_config_type::char_server::_host, Horizon::Auth::auth_config_type::char_server::_is_new, Horizon::Auth::auth_config_type::char_server::_name, Horizon::Auth::auth_config_type::char_server::_port, Horizon::Auth::auth_config_type::char_server::_type, Horizon::Auth::auth_config_type::add_char_server(), Server::general_conf(), get_auth_config(), Horizon::Auth::auth_config_type::get_char_servers(), general_server_configuration::get_config_file_path(), HLog, horizon_config_error, Horizon::Auth::auth_config_type::max_network_threads(), Server::parse_common_configs(), Horizon::Auth::auth_config_type::session_max_timeout(), Horizon::Auth::auth_config_type::set_max_network_threads(), and Horizon::Auth::auth_config_type::set_session_max_timeout().

Referenced by clicmd_reload_config().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void AuthServer::update

(

uint64_t

time

)

Cancel all pending tasks.

Stop all networks

{
    getScheduler().Update();
    
    sClientSocketMgr->manage_sockets(time);
    sClientSocketMgr->update_sessions(time);
    
    if (get_shutdown_stage() == SHUTDOWN_NOT_STARTED && !general_conf().is_test_run_minimal()) {
        _update_timer.expires_from_now(boost::posix_time::microseconds(MAX_CORE_UPDATE_INTERVAL));
        _update_timer.async_wait(std::bind(&AuthServer::update, this, std::time(nullptr)));
        _task_scheduler.Update();
    } else {
    
        for (auto i = _components.begin(); i != _components.end(); i++) {
            HLog(info) << "Kernel component '" << i->second.ptr->get_type_string()  << " (" << i->second.segment_number << ")': " << (i->second.ptr->is_finalized() == true ? "Offline" : "Online (Shutting Down)") << " { CPU: " << i->second.ptr->get_thread_cpu_id() << ", uuid: " << i->first << " }";
        }
 
        getScheduler().CancelAll();
 
        sClientSocketMgr->stop();
 
        finalize();
    }
}

References Kernel::_components, _task_scheduler, _update_timer, TaskScheduler::CancelAll(), finalize(), Server::general_conf(), get_shutdown_stage(), getScheduler(), HLog, MAX_CORE_UPDATE_INTERVAL, sClientSocketMgr, SHUTDOWN_NOT_STARTED, TaskScheduler::Update(), and update().

Referenced by initialize(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_connected_sessions()

void AuthServer::verify_connected_sessions

(

)

{   
    try {
        std::shared_ptr<boost::mysql::tcp_ssl_connection> conn = sAuth->get_database_connection();
        boost::mysql::statement stmt = conn->prepare_statement("DELETE FROM `session_data` WHERE `current_server` = ? AND `last_update` < ?");
        auto b = stmt.bind("A", std::time(nullptr) - get_auth_config().session_max_timeout());
        boost::mysql::results results;
        conn->execute(b, results);
 
        stmt = conn->prepare_statement("SELECT COUNT(`game_account_id`) FROM `session_data` WHERE `current_server` = ?");
        auto b2 = stmt.bind("A");
        conn->execute(b2, results);
 
        if (results.rows().empty()) {
            HLog(info) << "There are no connected session(s).";
            return;
        }
 
        int32_t count = results.rows()[0][0].as_int64();
 
        HLog(info) << count << " connected session(s).";
 
    }
    catch (boost::mysql::error_with_diagnostics &error) {
        HLog(error) << error.what();
    }
    catch (std::exception& error) {
        HLog(error) << error.what();
    }
}

References GridTypeListIterator::count(), get_auth_config(), HLog, and sAuth.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_auth_config

auth_config_type Horizon::Auth::AuthServer::_auth_config

protected

Referenced by get_auth_config().

_conf_lock

std::mutex Horizon::Auth::AuthServer::_conf_lock

protected

Referenced by get_auth_config().

_task_scheduler

TaskScheduler Horizon::Auth::AuthServer::_task_scheduler

protected

Referenced by getScheduler(), initialize(), and update().

_update_timer

boost::asio::deadline_timer Horizon::Auth::AuthServer::_update_timer

protected

Referenced by initialize(), and update().

---

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

• src/Server/Auth/Auth.hpp
• src/Server/Auth/Auth.cpp