Main.cpp

/**
 * MaNGOS is a full featured server for World of Warcraft, supporting
 * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8
 *
 * Copyright (C) 2005-2026 MaNGOS <https://www.getmangos.eu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,r
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * World of Warcraft, and all World of Warcraft or Warcraft art, images,
 * and lore are copyrighted by Blizzard Entertainment, Inc.
 */

/**
 * @file Main.cpp
 * @brief Realm daemon entry point and main loop
 *
 * This file implements the realm daemon (realmd) which handles:
 * - Client authentication and login
 * - Realm list provision
 * - Account verification
 * - Connection to world servers
 * - Database access for account data
 *
 * The realm daemon listens on a configured port for incoming client
 * connections, authenticates users against the database, and provides
 * the realm list for world server selection.
 *
 * @addtogroup realmd Realm Daemon
 * @{
 */

#include <csignal>
#include "Platform/Define.h"
#include "Common/TimeConstants.h"
#include <cstdio>
#include <cstdlib>
#include "Database/DatabaseEnv.h"
#include "Realm/RealmList.h"

#include "Config/Config.h"
#include "GitRevision.h"
#include "Log.h"
#include "Auth/PatchPolicy.h"
#include "Auth/AuthSocket.h"
#include "Auth/AuthServer.h"
#include "SystemConfig.h"
#include "ScheduledExit.h"
#include "Util.h"

#include <openssl/opensslv.h>
#include <openssl/crypto.h>
#include <openssl/provider.h>
#include "Auth/OpenSSLProvider.h"

#include <chrono>
#include <cstring>
#include <thread>
#include <utility>

#ifdef WIN32
#include "ServiceWin32.h"
#include "WheatyExceptionReport.h"
char serviceName[] = "realmd";
char serviceLongName[] = "MaNGOS realmd service";
char serviceDescription[] = "Massive Network Game Object Server";
/**
 * -1 - not in service mode
 *  0 - stopped
 *  1 - running
 *  2 - paused
 */
int m_ServiceStatus = -1;
#else
#include "PosixDaemon.h"
#endif

bool StartDB();
void UnhookSignals();
void HookSignals();

#ifdef _WIN32
#include <windows.h>
#include <string>
/** Update the console title with current auth/waiting and connection counts, only if changed. */
static void UpdateConsoleTitle(uint32 authWaiting, uint32 connections)
{
    static std::string s_lastTitle;
    char title[128];
    snprintf(title, sizeof(title), "MaNGOS Realm-Daemon (%u Auth/Waiting - %u Connections)", authWaiting, connections);
    std::string newTitle(title);
    if (s_lastTitle != newTitle)
    {
        s_lastTitle = newTitle;
        SetConsoleTitleA(title);
    }
}
#endif

bool stopEvent = false;                                     ///< Setting it to true stops the server
uint8 exitCode = 0;                                         ///< Process exit code

DatabaseType LoginDatabase;                                 ///< Accessor to the realm server database

namespace
{
    uint8 const REALMD_SHUTDOWN_EXIT_CODE = 0;
    uint8 const REALMD_RESTART_EXIT_CODE = 2;

    MaNGOS::ScheduledExitSchedule s_scheduledExit;
    MaNGOS::ScheduledExitState s_scheduledExitState;

    void LoadScheduledExitConfig()
    {
        s_scheduledExit = MaNGOS::ScheduledExitSchedule();
        s_scheduledExitState = MaNGOS::ScheduledExitState();

        if (!sConfig.GetBoolDefault("ScheduledExit.Enable", false))
        {
            sLog.outString("ScheduledExit: disabled");
            return;
        }

        std::string dayText = sConfig.GetStringDefault("ScheduledExit.DayOfWeek", "3");
        uint32 dayOfWeek = 0;
        if (!MaNGOS::ParseScheduledExitUInt32(dayText, dayOfWeek) || dayOfWeek > 6)
        {
            sLog.outError("ScheduledExit: invalid ScheduledExit.DayOfWeek '%s'; "
                "disabling scheduled exit", dayText.c_str());
            return;
        }

        std::string timeText = sConfig.GetStringDefault("ScheduledExit.Time", "05:00");
        uint32 hour = 0;
        uint32 minute = 0;
        if (!MaNGOS::ParseScheduledExitTime(timeText, hour, minute))
        {
            sLog.outError("ScheduledExit: invalid ScheduledExit.Time '%s'; "
                "disabling scheduled exit", timeText.c_str());
            return;
        }

        std::string modeText = sConfig.GetStringDefault("ScheduledExit.Mode", "restart");
        MaNGOS::ScheduledExitMode mode = MaNGOS::SCHEDULED_EXIT_MODE_RESTART;
        if (!MaNGOS::ParseScheduledExitMode(modeText, mode))
        {
            sLog.outError("ScheduledExit: invalid ScheduledExit.Mode '%s'; "
                "disabling scheduled exit", modeText.c_str());
            return;
        }

        s_scheduledExit.enabled = true;
        s_scheduledExit.dayOfWeek = dayOfWeek;
        s_scheduledExit.hour = hour;
        s_scheduledExit.minute = minute;
        s_scheduledExit.mode = mode;

        if (MaNGOS::MarkScheduledExitHandledIfMatching(
            s_scheduledExit, safe_localtime(time(NULL)), s_scheduledExitState))
        {
            sLog.outString("ScheduledExit: startup minute matches configured "
                "schedule; suppressing this minute to avoid restart loop");
        }

        sLog.outString("ScheduledExit: enabled day=%u time=%02u:%02u mode=%s",
            s_scheduledExit.dayOfWeek, s_scheduledExit.hour, s_scheduledExit.minute,
            MaNGOS::ScheduledExitModeToString(s_scheduledExit.mode));
    }

    void CheckScheduledExit()
    {
        if (!s_scheduledExit.enabled || stopEvent)
        {
            return;
        }

        std::tm localTime = safe_localtime(time(NULL));
        if (!MaNGOS::CheckAndMarkScheduledExit(s_scheduledExit, localTime, s_scheduledExitState))
        {
            return;
        }

        exitCode = s_scheduledExit.mode == MaNGOS::SCHEDULED_EXIT_MODE_RESTART
            ? REALMD_RESTART_EXIT_CODE : REALMD_SHUTDOWN_EXIT_CODE;
        sLog.outString("ScheduledExit: firing scheduled %s",
            MaNGOS::ScheduledExitModeToString(s_scheduledExit.mode));
        stopEvent = true;
    }
}

/**
 * @brief Print command line usage information
 * @param prog Program name (argv[0])
 *
 * Displays usage information including available command line options.
 * Shows platform-specific options (Windows service vs POSIX daemon).
 */
void usage(const char* prog)
{
    sLog.outString("Usage: \n %s [<options>]\n"
        "    -v, --version            print version and exist\n\r"
        "    -c config_file           use config_file as configuration file\n\r"
#ifdef WIN32
        "    Running as service functions:\n\r"
        "    -s run                   run as service\n\r"
        "    -s install               install service\n\r"
        "    -s uninstall             uninstall service\n\r"
#else
        "    Running as daemon functions:\n\r"
        "    -s run                   run as daemon\n\r"
        "    -s stop                  stop daemon\n\r"
#endif
    , prog);
}

/**
 * @brief Realm daemon entry point
 * @param argc Argument count
 * @param argv Argument values
 * @return Exit code (0 for success, non-zero for errors)
 *
 * Main entry point for the realm daemon. Performs:
 * 1. Command line parsing
 * 2. Service/daemon mode handling
 * 3. Configuration loading
 * 4. Database initialization
 * 5. Network setup
 * 6. Main event loop
 * 7. Graceful shutdown
 *
 * The function runs until a shutdown signal is received or an
 * unrecoverable error occurs.
 */
extern int main(int argc, char** argv)
{
#ifdef _WIN32
    static WheatyExceptionReport exceptionReport;
    SetUnhandledExceptionFilter(WheatyExceptionReport::WheatyUnhandledExceptionFilter);
#endif

    ///- Command line parsing
    char const* cfg_file = REALMD_CONFIG_LOCATION;

    char serviceDaemonMode = '\0';

    // Minimal command-line parser. Recognised options:
    //   -c <file>            configuration file
    //   -s <mode>            service/daemon control (run / install / uninstall / stop)
    //   -v / --version       print version and exit
    // An option that takes an argument accepts it either attached ("-cFILE") or
    // as the following token ("-c FILE").
    auto takeArg = [&](int& i, char const* attached, char opt) -> char const*
    {
        if (attached && *attached)
        {
            return attached;                    // "-cFILE"
        }
        if (i + 1 < argc)
        {
            return argv[++i];                   // "-c FILE"
        }
        sLog.outError("Runtime-Error: -%c option requires an input argument", opt);
        usage(argv[0]);
        Log::WaitBeforeContinueIfNeed();
        return nullptr;
    };

    for (int i = 1; i < argc; ++i)
    {
        char const* arg = argv[i];

        // Long options.
        if (!strcmp(arg, "--version"))
        {
            printf("%s\n", GitRevision::GetProjectRevision());
            return 0;
        }

        // Short options: "-x" possibly with an attached value ("-xVALUE").
        if (arg[0] != '-' || arg[1] == '\0')
        {
            sLog.outError("Runtime-Error: bad format of commandline arguments");
            usage(argv[0]);
            Log::WaitBeforeContinueIfNeed();
            return 1;
        }

        char const opt = arg[1];
        char const* attached = arg + 2;         // "" when the value is a separate token

        switch (opt)
        {
            case 'v':
                printf("%s\n", GitRevision::GetProjectRevision());
                return 0;
            case 'c':
            {
                char const* val = takeArg(i, attached, 'c');
                if (!val)
                {
                    return 1;
                }
                cfg_file = val;
                break;
            }
            case 's':
            {
                char const* mode = takeArg(i, attached, 's');
                if (!mode)
                {
                    return 1;
                }

                if (!strcmp(mode, "run"))
                {
                    serviceDaemonMode = 'r';
                }
#ifdef WIN32
                else if (!strcmp(mode, "install"))
                {
                    serviceDaemonMode = 'i';
                }
                else if (!strcmp(mode, "uninstall"))
                {
                    serviceDaemonMode = 'u';
                }
#else
                else if (!strcmp(mode, "stop"))
                {
                    serviceDaemonMode = 's';
                }
#endif
                else
                {
                    sLog.outError("Runtime-Error: -%c unsupported argument %s", opt, mode);
                    usage(argv[0]);
                    Log::WaitBeforeContinueIfNeed();
                    return 1;
                }
                break;
            }
            default:
                sLog.outError("Runtime-Error: bad format of commandline arguments");
                usage(argv[0]);
                Log::WaitBeforeContinueIfNeed();
                return 1;
        }
    }

#ifdef WIN32                                                // windows service command need execute before config read
    switch (serviceDaemonMode)
    {
        case 'i':
            if (WinServiceInstall())
            {
                sLog.outString("Installing service");
            }
            return 1;
        case 'u':
            if (WinServiceUninstall())
            {
                sLog.outString("Uninstalling service");
            }
            return 1;
        case 'r':
            WinServiceRun();
            break;
    }
#endif

    if (!sConfig.SetSource(cfg_file))
    {
        // Try current folder as fallback if SYSCONFDIR path fails
        if (!sConfig.SetSource(REALMD_CONFIG_NAME))
        {
            sLog.outError("Could not find configuration file %s.", cfg_file);
            Log::WaitBeforeContinueIfNeed();
            return 1;
        }
        cfg_file = REALMD_CONFIG_NAME;
    }

#ifndef WIN32                                               // posix daemon commands need apply after config read
    switch (serviceDaemonMode)
    {
        case 'r':
            startDaemon();
            break;
        case 's':
            stopDaemon();
            break;
    }
#endif

    sLog.Initialize();

    sLog.outString("%s [realm-daemon]", GitRevision::GetProjectRevision());
    sLog.outString("%s", GitRevision::GetFullRevision());
    sLog.outString("<Ctrl-C> to stop.\n");
    sLog.outString("Using configuration file %s.", cfg_file);

    ///- Check the version of the configuration file
    uint32 confVersion = sConfig.GetIntDefault("ConfVersion", 0);
    if (confVersion < REALMD_CONFIG_VERSION)
    {
        sLog.outError("*****************************************************************************");
        sLog.outError(" WARNING: Your realmd.conf version indicates your conf file is out of date!");
        sLog.outError("          Please check for updates, as your current default values may cause");
        sLog.outError("          strange behavior.");
        sLog.outError("*****************************************************************************");
        Log::WaitBeforeContinueIfNeed();
    }

    LoadScheduledExitConfig();

    DETAIL_LOG("Using SSL version: %s (Library: %s)", OPENSSL_VERSION_TEXT, OpenSSL_version(OPENSSL_VERSION));

    // RAII provider management - automatically handles cleanup
    OpenSSLProviderManager providerManager;
    if (!providerManager.IsInitialized())
    {
        Log::WaitBeforeContinueIfNeed();
        return 1;
    }

    /// realmd PID file creation
    std::string pidfile = sConfig.GetStringDefault("PidFile", "");
    if (!pidfile.empty())
    {
        uint32 pid = CreatePIDFile(pidfile);
        if (!pid)
        {
            sLog.outError("Can not create PID file %s.\n", pidfile.c_str());
            Log::WaitBeforeContinueIfNeed();
            return 1;
        }

        sLog.outString("Daemon PID: %u\n", pid);
    }

    ///- Initialize the database connection
    if (!StartDB())
    {
        Log::WaitBeforeContinueIfNeed();
        return 1;
    }

    ///- Get the list of realms for the server
    sRealmList.Initialize(sConfig.GetIntDefault("RealmsStateUpdateDelay", 20));
    if (sRealmList.size() == 0)
    {
        sLog.outError("No valid realms specified.");
        Log::WaitBeforeContinueIfNeed();
        return 1;
    }

    // cleanup query
    // set expired bans to inactive
    LoginDatabase.BeginTransaction();
    LoginDatabase.Execute("UPDATE `account_banned` SET `active` = 0 WHERE `unbandate`<=UNIX_TIMESTAMP() AND `unbandate`<>`bandate`");
    LoginDatabase.Execute("DELETE FROM `ip_banned` WHERE `unbandate`<=UNIX_TIMESTAMP() AND `unbandate`<>`bandate`");
    LoginDatabase.CommitTransaction();

    ///- Launch the listening network socket
    uint16 rmport = sConfig.GetIntDefault("RealmServerPort", DEFAULT_REALMSERVER_PORT);

    // Honour the configured BindIP: empty or "0.0.0.0" listens on every local
    // interface, otherwise realmd binds only that IPv4/hostname.
    std::string bindIp = sConfig.GetStringDefault("BindIP", "0.0.0.0");
    int32 const configuredAuthTimeout =
        sConfig.GetIntDefault("AuthSessionTimeout", 30);
    uint32 authTimeoutSeconds = 30;
    if (configuredAuthTimeout < 0)
    {
        sLog.outError(
            "AuthSessionTimeout cannot be negative; using 30 seconds.");
    }
    else
    {
        authTimeoutSeconds = static_cast<uint32>(configuredAuthTimeout);
    }

    bool const patchEnabled =
        sConfig.GetBoolDefault("Patch.Enable", true);
    auto patchPolicy = PatchPolicy::Parse(
        patchEnabled,
        sConfig.GetStringDefault("Patch.ForceBuilds", ""));
    if (!patchPolicy)
    {
        sLog.outError("Invalid Patch.ForceBuilds configuration");
        return 1;
    }

    AuthServer authServer;

    if (!authServer.Start(
            rmport,
            bindIp,
            std::chrono::seconds(authTimeoutSeconds),
            std::move(*patchPolicy)))
    {
        sLog.outError("MaNGOS realmd can not bind to port %d", rmport);
        Log::WaitBeforeContinueIfNeed();
        return 1;
    }

    ///- Catch termination signals
    HookSignals();

    ///- Handle affinity for multiple processors and process priority on Windows
#ifdef WIN32
    {
        HANDLE hProcess = GetCurrentProcess();

        uint32 Aff = sConfig.GetIntDefault("UseProcessors", 0);
        if (Aff > 0)
        {
            ULONG_PTR appAff;
            ULONG_PTR sysAff;

            if (GetProcessAffinityMask(hProcess, &appAff, &sysAff))
            {
                ULONG_PTR curAff = Aff & appAff;            // remove non accessible processors

                if (!curAff)
                {
                    sLog.outError("Processors marked in UseProcessors bitmask (hex) %x not accessible for realmd. Accessible processors bitmask (hex): %x", Aff, appAff);
                }
                else
                {
                    if (SetProcessAffinityMask(hProcess, curAff))
                    {
                        sLog.outString("Using processors (bitmask, hex): %x", curAff);
                    }
                    else
                    {
                        sLog.outError("Can't set used processors (hex): %x", curAff);
                    }
                }
            }
            sLog.outString();
        }

        bool Prio = sConfig.GetBoolDefault("ProcessPriority", false);

        if (Prio)
        {
            if (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS))
            {
                sLog.outString("realmd process priority class set to HIGH");
            }
            else
            {
                sLog.outError("Can't set realmd process priority class.");
            }
            sLog.outString();
        }
    }
#endif

    // server has started up successfully => enable async DB requests
    LoginDatabase.AllowAsyncTransactions();

    // maximum counter for next ping
    uint32 numLoops = (sConfig.GetIntDefault("MaxPingTime", 30) * (MINUTE * 1000000 / 100000));
    uint32 loopCounter = 0;
    uint32 logFlushCounter = 0;

#ifndef WIN32
    detachDaemon();
#endif
    ///- Wait for termination signal. The networking engine runs on its own
    ///- worker threads; this loop only performs periodic housekeeping.
    while (!stopEvent)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        authServer.Update();

        if ((++logFlushCounter) >= 10)
        {
            logFlushCounter = 0;
            sLog.Flush();
        }

        if ((++loopCounter) == numLoops)
        {
            loopCounter = 0;
            DETAIL_LOG("Ping MySQL to keep connection alive");
            LoginDatabase.Ping();
        }

        CheckScheduledExit();
#ifdef _WIN32
        static uint32 titleUpdateCounter = 0;
        if ((++titleUpdateCounter) >= 30) // ~3 seconds at 100ms reactor interval
        {
            titleUpdateCounter = 0;
            UpdateConsoleTitle(AuthSocket::GetAuthWaitingCount(), AuthSocket::GetConnectionCount());
        }
#endif
#ifdef WIN32
        if (m_ServiceStatus == 0)
        {
            stopEvent = true;
        }
        while (m_ServiceStatus == 2)
        {
            Sleep(1000);
        }
#endif
    }

    ///- Stop accepting connections and join the network worker threads
    authServer.Stop();

    ///- Wait for the delay thread to exit
    LoginDatabase.HaltDelayThread();

    ///- Remove signal handling before leaving
    UnhookSignals();

    sLog.outString("Halting process...");
    sLog.Flush();
    return exitCode;
}

/// Handle termination signals

/** Put the global variable stopEvent to 'true' if a termination signal is caught **/
void OnSignal(int s)
{
    switch (s)
    {
        case SIGINT:
        case SIGTERM:
            stopEvent = true;
            break;
#ifdef _WIN32
        case SIGBREAK:
            stopEvent = true;
            break;
#endif
    }

    signal(s, OnSignal);
}

/// Initialize connection to the database
bool StartDB()
{
    std::string dbstring = sConfig.GetStringDefault("LoginDatabaseInfo", "");
    if (dbstring.empty())
    {
        sLog.outError("Database not specified");
        return false;
    }

    sLog.outString("Login Database total connections: %i", 1 + 1);

    if (!LoginDatabase.Initialize(dbstring.c_str()))
    {
        sLog.outError("Can not connect to database");
        return false;
    }

    if (!LoginDatabase.CheckDatabaseVersion(DATABASE_REALMD))
    {
        ///- Wait for already started DB delay threads to end
        LoginDatabase.HaltDelayThread();
        return false;
    }

    return true;
}

/// Define hook 'OnSignal' for all termination signals
void HookSignals()
{
    signal(SIGINT, OnSignal);
    signal(SIGTERM, OnSignal);
#ifdef _WIN32
    signal(SIGBREAK, OnSignal);
#endif
}

/// Unhook the signals before leaving
void UnhookSignals()
{
    signal(SIGINT, 0);
    signal(SIGTERM, 0);
#ifdef _WIN32
    signal(SIGBREAK, 0);
#endif
}

/// @}