Main.cpp File Reference

#include "AppenderDB.h"
#include "AuthSocketMgr.h"
#include "Banner.h"
#include "Config.h"
#include "DBUpdater.h"
#include "DatabaseEnv.h"
#include "DatabaseLoader.h"
#include "GitRevision.h"
#include "IPLocation.h"
#include "IoContext.h"
#include "Log.h"
#include "MySQLThreading.h"
#include "OpenSSLCrypto.h"
#include "ProcessPriority.h"
#include "RealmList.h"
#include "SecretMgr.h"
#include "SharedDefines.h"
#include "SteadyTimer.h"
#include "Util.h"
#include <boost/asio/signal_set.hpp>
#include <boost/program_options.hpp>
#include <boost/version.hpp>
#include <csignal>
#include <filesystem>
#include <iostream>
#include <openssl/crypto.h>
#include <openssl/opensslv.h>

Go to the source code of this file.

Macros
#define	_ACORE_REALM_CONFIG   "authserver.conf"

Functions
bool	StartDB ()
	Initialize connection to the database.
void	StopDB ()
	Close the connection to the database.
void	SignalHandler (std::weak_ptr< Acore::Asio::IoContext > ioContextRef, boost::system::error_code const &error, int signalNumber)
void	KeepDatabaseAliveHandler (std::weak_ptr< boost::asio::steady_timer > dbPingTimerRef, int32 dbPingInterval, boost::system::error_code const &error)
void	BanExpiryHandler (std::weak_ptr< boost::asio::steady_timer > banExpiryCheckTimerRef, int32 banExpiryCheckInterval, boost::system::error_code const &error)
variables_map	GetConsoleArguments (int argc, char **argv, fs::path &configFile)
int	main (int argc, char **argv)
	Launch the auth server.

Macro Definition Documentation

_ACORE_REALM_CONFIG

#define _ACORE_REALM_CONFIG   "authserver.conf"

Function Documentation

BanExpiryHandler()

void BanExpiryHandler	(	std::weak_ptr< boost::asio::steady_timer >	banExpiryCheckTimerRef,
		int32	banExpiryCheckInterval,
		boost::system::error_code const &	error
	)

{
    if (!error)
    {
        if (std::shared_ptr<boost::asio::steady_timer> banExpiryCheckTimer = banExpiryCheckTimerRef.lock())
        {
            LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_DEL_EXPIRED_IP_BANS));
            LoginDatabase.Execute(LoginDatabase.GetPreparedStatement(LOGIN_UPD_EXPIRED_ACCOUNT_BANS));
 
            banExpiryCheckTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(banExpiryCheckInterval));
            banExpiryCheckTimer->async_wait(std::bind(&BanExpiryHandler, banExpiryCheckTimerRef, banExpiryCheckInterval, std::placeholders::_1));
        }
    }
}

References BanExpiryHandler(), Acore::Asio::SteadyTimer::GetExpirationTime(), LOGIN_DEL_EXPIRED_IP_BANS, LOGIN_UPD_EXPIRED_ACCOUNT_BANS, and LoginDatabase.

Referenced by BanExpiryHandler(), and main().

GetConsoleArguments()

variables_map GetConsoleArguments	(	int	argc,
		char **	argv,
		fs::path &	configFile
	)

{
    options_description all("Allowed options");
    all.add_options()
        ("help,h", "print usage message")
        ("version,v", "print version build info")
        ("dry-run,d", "Dry run")
        ("config,c", value<fs::path>(&configFile)->default_value(fs::path(sConfigMgr->GetConfigPath() + std::string(_ACORE_REALM_CONFIG))), "use <arg> as configuration file")
        ("config-policy", value<std::string>()->value_name("policy"), "override config severity policy (e.g. default=skip,critical_option=fatal)");
 
    variables_map variablesMap;
 
    try
    {
        store(command_line_parser(argc, argv).options(all).allow_unregistered().run(), variablesMap);
        notify(variablesMap);
    }
    catch (std::exception const& e)
    {
        std::cerr << e.what() << "\n";
    }
 
    if (variablesMap.count("help"))
        std::cout << all << "\n";
    else if (variablesMap.count("version"))
        std::cout << GitRevision::GetFullVersion() << "\n";
    else if (variablesMap.count("dry-run"))
        sConfigMgr->setDryRun(true);
 
    return variablesMap;
}

References _ACORE_REALM_CONFIG, GitRevision::GetFullVersion(), and sConfigMgr.

Referenced by main().

KeepDatabaseAliveHandler()

void KeepDatabaseAliveHandler	(	std::weak_ptr< boost::asio::steady_timer >	dbPingTimerRef,
		int32	dbPingInterval,
		boost::system::error_code const &	error
	)

{
    if (!error)
    {
        if (std::shared_ptr<boost::asio::steady_timer> dbPingTimer = dbPingTimerRef.lock())
        {
            LOG_DEBUG("sql.driver", "Ping MySQL to keep connection alive");
            LoginDatabase.KeepAlive();
 
            dbPingTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(dbPingInterval));
            dbPingTimer->async_wait(std::bind(&KeepDatabaseAliveHandler, dbPingTimerRef, dbPingInterval, std::placeholders::_1));
        }
    }
}

References Acore::Asio::SteadyTimer::GetExpirationTime(), KeepDatabaseAliveHandler(), LOG_DEBUG, and LoginDatabase.

Referenced by KeepDatabaseAliveHandler(), and main().

main()

int main	(	int	argc,
		char **	argv
	)

Launch the auth server.

{
    Acore::Impl::CurrentServerProcessHolder::_type = SERVER_PROCESS_AUTHSERVER;
    signal(SIGABRT, &Acore::AbortHandler);
 
    // Command line parsing
    auto configFile = fs::path(sConfigMgr->GetConfigPath() + std::string(_ACORE_REALM_CONFIG));
    auto vm = GetConsoleArguments(argc, argv, configFile);
 
    // exit if help or version is enabled
    if (vm.count("help") || vm.count("version"))
        return 0;
 
    // Add file and args in config
    sConfigMgr->Configure(configFile.generic_string(), std::vector<std::string>(argv, argv + argc));
 
    if (!sConfigMgr->LoadAppConfigs())
        return 1;
 
    // Init logging
    sLog->RegisterAppender<AppenderDB>();
    sLog->Initialize(nullptr);
 
    Acore::Banner::Show("authserver",
        [](std::string_view text)
        {
            LOG_INFO("server.authserver", text);
        },
        []()
        {
            LOG_INFO("server.authserver", "> Using configuration file       {}", sConfigMgr->GetFilename());
            LOG_INFO("server.authserver", "> Using SSL version:             {} (library: {})", OPENSSL_VERSION_TEXT, OpenSSL_version(OPENSSL_VERSION));
            LOG_INFO("server.authserver", "> Using Boost version:           {}.{}.{}", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100);
        });
 
    OpenSSLCrypto::threadsSetup();
 
    std::shared_ptr<void> opensslHandle(nullptr, [](void*) { OpenSSLCrypto::threadsCleanup(); });
 
    // authserver PID file creation
    std::string pidFile = sConfigMgr->GetOption<std::string>("PidFile", "");
    if (!pidFile.empty())
    {
        if (uint32 pid = CreatePIDFile(pidFile))
            LOG_INFO("server.authserver", "Daemon PID: {}\n", pid); // outError for red color in console
        else
        {
            LOG_ERROR("server.authserver", "Cannot create PID file {} (possible error: permission)\n", pidFile);
            return 1;
        }
    }
 
    // Initialize the database connection
    if (!StartDB())
        return 1;
 
    sSecretMgr->Initialize();
 
    // Load IP Location Database
    sIPLocation->Load();
 
    std::shared_ptr<void> dbHandle(nullptr, [](void*) { StopDB(); });
 
    // Mark every realm offline on startup; each worldserver clears this flag for its own realm once it is ready.
    // This prevents realms from appearing online in the realm list when no worldserver is actually running.
    LoginDatabase.DirectExecute("UPDATE realmlist SET flag = flag | {}", REALM_FLAG_OFFLINE);
 
    std::shared_ptr<Acore::Asio::IoContext> ioContext = std::make_shared<Acore::Asio::IoContext>();
 
    // Get the list of realms for the server
    sRealmList->Initialize(*ioContext, sConfigMgr->GetOption<int32>("RealmsStateUpdateDelay", 20));
 
    std::shared_ptr<void> sRealmListHandle(nullptr, [](void*) { sRealmList->Close(); });
 
    if (sRealmList->GetRealms().empty())
    {
        LOG_ERROR("server.authserver", "No valid realms specified. Possible reasons:");
        LOG_ERROR("server.authserver", "- the realmlist table of the auth database is empty");
        LOG_ERROR("server.authserver", "- every realm has flag 3 (REALM_FLAG_VERSION_MISMATCH | REALM_FLAG_OFFLINE), which the realm list "
            "query excludes. Reset it with: UPDATE realmlist SET flag = 0 WHERE id = <realm id>;");
        LOG_ERROR("server.authserver", "- no realm address could be resolved, see the resolver errors logged above");
        return 1;
    }
 
    // Stop auth server if dry run
    if (sConfigMgr->isDryRun())
    {
        if (uint32 failed = DBUpdaterUtil::GetFailedUpdateCount())
        {
            LOG_FATAL("server.authserver", "Dry run completed with {} failed database update(s), terminating.", failed);
            return 1;
        }
 
        LOG_INFO("server.authserver", "Dry run completed, terminating.");
        return 0;
    }
 
    // Start the listening port (acceptor) for auth connections
    int32 port = sConfigMgr->GetOption<int32>("RealmServerPort", 3724);
    if (port < 0 || port > 0xFFFF)
    {
        LOG_ERROR("server.authserver", "Specified port out of allowed range (1-65535)");
        return 1;
    }
 
    std::string bindIp = sConfigMgr->GetOption<std::string>("BindIP", "0.0.0.0");
 
    if (!sAuthSocketMgr.StartNetwork(*ioContext, bindIp, port))
    {
        LOG_ERROR("server.authserver", "Failed to initialize network");
        return 1;
    }
 
    std::shared_ptr<void> sAuthSocketMgrHandle(nullptr, [](void*) { sAuthSocketMgr.StopNetwork(); });
 
    // Set signal handlers
    boost::asio::signal_set signals(*ioContext, SIGINT, SIGTERM);
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    signals.add(SIGBREAK);
#endif
    signals.async_wait(std::bind(&SignalHandler, std::weak_ptr<Acore::Asio::IoContext>(ioContext), std::placeholders::_1, std::placeholders::_2));
 
    // Set process priority according to configuration settings
    SetProcessPriority("server.authserver", sConfigMgr->GetOption<int32>(CONFIG_PROCESSOR_AFFINITY, 0), sConfigMgr->GetOption<bool>(CONFIG_HIGH_PRIORITY, false));
 
    // Enabled a timed callback for handling the database keep alive ping
    int32 dbPingInterval = sConfigMgr->GetOption<int32>("MaxPingTime", 30);
    std::shared_ptr<boost::asio::steady_timer> dbPingTimer = std::make_shared<boost::asio::steady_timer>(*ioContext);
 
    dbPingTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(dbPingInterval * MINUTE));
    dbPingTimer->async_wait(std::bind(&KeepDatabaseAliveHandler, std::weak_ptr<boost::asio::steady_timer>(dbPingTimer), dbPingInterval, std::placeholders::_1));
 
    int32 banExpiryCheckInterval = sConfigMgr->GetOption<int32>("BanExpiryCheckInterval", 60);
    std::shared_ptr<boost::asio::steady_timer> banExpiryCheckTimer = std::make_shared<boost::asio::steady_timer>(*ioContext);
 
    banExpiryCheckTimer->expires_at(Acore::Asio::SteadyTimer::GetExpirationTime(banExpiryCheckInterval));
    banExpiryCheckTimer->async_wait(std::bind(&BanExpiryHandler, std::weak_ptr<boost::asio::steady_timer>(banExpiryCheckTimer), banExpiryCheckInterval, std::placeholders::_1));
 
    // Start the io service worker loop
    ioContext->run();
 
    banExpiryCheckTimer->cancel();
    dbPingTimer->cancel();
 
    LOG_INFO("server.authserver", "Halting process...");
 
    signals.cancel();
 
    return 0;
}

References _ACORE_REALM_CONFIG, Acore::Impl::CurrentServerProcessHolder::_type, Acore::AbortHandler(), BanExpiryHandler(), CONFIG_HIGH_PRIORITY, CONFIG_PROCESSOR_AFFINITY, CreatePIDFile(), GetConsoleArguments(), Acore::Asio::SteadyTimer::GetExpirationTime(), DBUpdaterUtil::GetFailedUpdateCount(), KeepDatabaseAliveHandler(), LOG_ERROR, LOG_FATAL, LOG_INFO, LoginDatabase, MINUTE, REALM_FLAG_OFFLINE, sAuthSocketMgr, sConfigMgr, SERVER_PROCESS_AUTHSERVER, SetProcessPriority(), Acore::Banner::Show(), SignalHandler(), sIPLocation, sLog, sRealmList, sSecretMgr, StartDB(), StopDB(), OpenSSLCrypto::threadsCleanup(), and OpenSSLCrypto::threadsSetup().

SignalHandler()

void SignalHandler	(	std::weak_ptr< Acore::Asio::IoContext >	ioContextRef,
		boost::system::error_code const &	error,
		int	signalNumber
	)

{
    if (!error)
    {
        if (std::shared_ptr<Acore::Asio::IoContext> ioContext = ioContextRef.lock())
        {
            ioContext->stop();
        }
    }
}

Referenced by main().

StartDB()

bool StartDB

(

)

Initialize connection to the database.

{
    MySQL::Library_Init();
 
    // Load databases
    // NOTE: While authserver is singlethreaded you should keep synch_threads == 1.
    // Increasing it is just silly since only 1 will be used ever.
    DatabaseLoader loader("server.authserver");
    loader
        .AddDatabase(LoginDatabase, "Login");
 
    if (!loader.Load())
        return false;
 
    LOG_INFO("server.authserver", "Started auth database connection pool.");
    sLog->SetRealmId(0); // Enables DB appenders when realm is set.
    return true;
}

References DatabaseLoader::AddDatabase(), MySQL::Library_Init(), DatabaseLoader::Load(), LOG_INFO, LoginDatabase, and sLog.

Referenced by main().

StopDB()

void StopDB

(

)

Close the connection to the database.

{
    LoginDatabase.Close();
    MySQL::Library_End();
}

References MySQL::Library_End(), and LoginDatabase.

Referenced by main().