feat: add smartcmd dedicated server

major bug: when connecting to the server a second time, it gets softlocked and keeps repeating ticking connection A\n in debug logs until it times out.
2026-08-29 14:01:24 +03:00
parent a1541c590d
commit 4b962fcb21
146 changed files with 32837 additions and 272 deletions
@@ -0,0 +1,460 @@
+#include "stdafx.h"
+
+#include "Access.h"
+
+#include "../Common/StringUtils.h"
+#include "../ServerLogger.h"
+
+#include <memory>
+#include <mutex>
+
+namespace ServerRuntime
+{
+	namespace Access
+	{
+		namespace
+		{
+			/**
+			 * **Access State**
+			 *
+			 * These features are used extensively from various parts of the code, so safe read/write handling is implemented
+			 * Stores the published BAN manager snapshot plus a writer gate for clone-and-publish updates
+			 * 公開中のBanManagerスナップショットと更新直列化用ロックを保持する
+			 */
+			struct AccessState
+			{
+				std::mutex stateLock;
+				std::mutex writeLock;
+				std::shared_ptr<BanManager> banManager;
+				std::shared_ptr<WhitelistManager> whitelistManager;
+				bool whitelistEnabled;
+			};
+
+			AccessState g_accessState;
+
+			/**
+			 * Copies the currently published manager pointer so readers can work without holding the publish mutex
+			 * 公開中のBanManager共有ポインタを複製取得する
+			 */
+			static std::shared_ptr<BanManager> GetBanManagerSnapshot()
+			{
+				std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+				return g_accessState.banManager;
+			}
+
+			/**
+			 * Replaces the shared manager pointer with a fully prepared snapshot in one short critical section
+			 * 準備完了したBanManagerスナップショットを短いロックで公開する
+			 */
+			static void PublishBanManagerSnapshot(const std::shared_ptr<BanManager> &banManager)
+			{
+				std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+				g_accessState.banManager = banManager;
+			}
+
+			static std::shared_ptr<WhitelistManager> GetWhitelistManagerSnapshot()
+			{
+				std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+				return g_accessState.whitelistManager;
+			}
+
+			static void PublishWhitelistManagerSnapshot(const std::shared_ptr<WhitelistManager> &whitelistManager)
+			{
+				std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+				g_accessState.whitelistManager = whitelistManager;
+			}
+		}
+
+		std::string FormatXuid(PlayerUID xuid)
+		{
+			if (xuid == INVALID_XUID)
+			{
+				return "";
+			}
+
+			char buffer[32] = {};
+			sprintf_s(buffer, sizeof(buffer), "0x%016llx", (unsigned long long)xuid);
+			return buffer;
+		}
+
+		bool TryParseXuid(const std::string &text, PlayerUID *outXuid)
+		{
+			if (outXuid == nullptr)
+			{
+				return false;
+			}
+
+			unsigned long long parsed = 0;
+			if (!StringUtils::TryParseUnsignedLongLong(text, &parsed) || parsed == 0ULL)
+			{
+				return false;
+			}
+
+			*outXuid = (PlayerUID)parsed;
+			return true;
+		}
+
+		bool Initialize(const std::string &baseDirectory, bool whitelistEnabled)
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+
+			// Build the replacement manager privately so readers keep using the last published snapshot during disk I/O.
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(baseDirectory);
+			std::shared_ptr<WhitelistManager> whitelistManager = std::make_shared<WhitelistManager>(baseDirectory);
+			if (!banManager->EnsureBanFilesExist())
+			{
+				LogError("access", "failed to ensure dedicated server ban files exist");
+				return false;
+			}
+			if (!whitelistManager->EnsureWhitelistFileExists())
+			{
+				LogError("access", "failed to ensure dedicated server whitelist file exists");
+				return false;
+			}
+
+			if (!banManager->Reload())
+			{
+				LogError("access", "failed to load dedicated server ban files");
+				return false;
+			}
+			if (!whitelistManager->Reload())
+			{
+				LogError("access", "failed to load dedicated server whitelist file");
+				return false;
+			}
+
+			std::vector<BannedPlayerEntry> playerEntries;
+			std::vector<BannedIpEntry> ipEntries;
+			std::vector<WhitelistedPlayerEntry> whitelistEntries;
+			banManager->SnapshotBannedPlayers(&playerEntries);
+			banManager->SnapshotBannedIps(&ipEntries);
+			whitelistManager->SnapshotWhitelistedPlayers(&whitelistEntries);
+			PublishBanManagerSnapshot(banManager);
+			PublishWhitelistManagerSnapshot(whitelistManager);
+			{
+				std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+				g_accessState.whitelistEnabled = whitelistEnabled;
+			}
+
+			LogInfof(
+				"access",
+				"loaded %u player bans, %u ip bans, and %u whitelist entries (whitelist=%s)",
+				(unsigned)playerEntries.size(),
+				(unsigned)ipEntries.size(),
+				(unsigned)whitelistEntries.size(),
+				whitelistEnabled ? "enabled" : "disabled");
+			return true;
+		}
+
+		void Shutdown()
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			PublishWhitelistManagerSnapshot(std::shared_ptr<WhitelistManager>());
+			PublishWhitelistManagerSnapshot(std::shared_ptr<WhitelistManager>());
+			std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+			g_accessState.whitelistEnabled = false;
+		}
+
+		bool Reload()
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::shared_ptr<BanManager> current = GetBanManagerSnapshot();
+			std::shared_ptr<WhitelistManager> currentWhitelist = GetWhitelistManagerSnapshot();
+			if (current == nullptr || currentWhitelist == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(*current);
+			std::shared_ptr<WhitelistManager> whitelistManager = std::make_shared<WhitelistManager>(*currentWhitelist);
+			if (!banManager->EnsureBanFilesExist())
+			{
+				return false;
+			}
+			if (!whitelistManager->EnsureWhitelistFileExists())
+			{
+				return false;
+			}
+			if (!banManager->Reload())
+			{
+				return false;
+			}
+			if (!whitelistManager->Reload())
+			{
+				return false;
+			}
+
+			PublishBanManagerSnapshot(banManager);
+			PublishWhitelistManagerSnapshot(whitelistManager);
+			return true;
+		}
+
+		bool ReloadWhitelist()
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			const auto current = GetWhitelistManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			auto whitelistManager = std::make_shared<WhitelistManager>(*current);
+			if (!whitelistManager->EnsureWhitelistFileExists())
+			{
+				return false;
+			}
+			if (!whitelistManager->Reload())
+			{
+				return false;
+			}
+
+			PublishWhitelistManagerSnapshot(whitelistManager);
+			return true;
+		}
+
+		bool IsInitialized()
+		{
+			return GetBanManagerSnapshot() != nullptr && GetWhitelistManagerSnapshot() != nullptr;
+		}
+
+		bool IsWhitelistEnabled()
+		{
+			std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+			return g_accessState.whitelistEnabled;
+		}
+
+		void SetWhitelistEnabled(bool enabled)
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::lock_guard<std::mutex> stateLock(g_accessState.stateLock);
+			g_accessState.whitelistEnabled = enabled;
+		}
+
+		bool IsPlayerBanned(PlayerUID xuid)
+		{
+			const std::string formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = GetBanManagerSnapshot();
+			return (banManager != nullptr) ? banManager->IsPlayerBannedByXuid(formatted) : false;
+		}
+
+		bool IsIpBanned(const std::string &ip)
+		{
+			std::shared_ptr<BanManager> banManager = GetBanManagerSnapshot();
+			return (banManager != nullptr) ? banManager->IsIpBanned(ip) : false;
+		}
+
+		bool IsPlayerWhitelisted(PlayerUID xuid)
+		{
+			const std::string formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::shared_ptr<WhitelistManager> whitelistManager = GetWhitelistManagerSnapshot();
+			return (whitelistManager != nullptr) ? whitelistManager->IsPlayerWhitelistedByXuid(formatted) : false;
+		}
+
+		bool AddPlayerBan(PlayerUID xuid, const std::string &name, const BanMetadata &metadata)
+		{
+			const std::string formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::shared_ptr<BanManager> current = GetBanManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(*current);
+			BannedPlayerEntry entry;
+			entry.xuid = formatted;
+			entry.name = name;
+			entry.metadata = metadata;
+			if (!banManager->AddPlayerBan(entry))
+			{
+				return false;
+			}
+
+			PublishBanManagerSnapshot(banManager);
+			return true;
+		}
+
+		bool AddIpBan(const std::string &ip, const BanMetadata &metadata)
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::shared_ptr<BanManager> current = GetBanManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(*current);
+			BannedIpEntry entry;
+			entry.ip = ip;
+			entry.metadata = metadata;
+			if (!banManager->AddIpBan(entry))
+			{
+				return false;
+			}
+
+			PublishBanManagerSnapshot(banManager);
+			return true;
+		}
+
+		bool RemovePlayerBan(PlayerUID xuid)
+		{
+			const std::string formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::shared_ptr<BanManager> current = GetBanManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(*current);
+			if (!banManager->RemovePlayerBanByXuid(formatted))
+			{
+				return false;
+			}
+
+			PublishBanManagerSnapshot(banManager);
+			return true;
+		}
+
+		bool RemoveIpBan(const std::string &ip)
+		{
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			std::shared_ptr<BanManager> current = GetBanManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = std::make_shared<BanManager>(*current);
+			if (!banManager->RemoveIpBan(ip))
+			{
+				return false;
+			}
+
+			PublishBanManagerSnapshot(banManager);
+			return true;
+		}
+
+		bool AddWhitelistedPlayer(PlayerUID xuid, const std::string &name, const WhitelistMetadata &metadata)
+		{
+			const auto formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			const auto current = GetWhitelistManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			auto whitelistManager = std::make_shared<WhitelistManager>(*current);
+			const WhitelistedPlayerEntry entry = { formatted, name, metadata };
+			if (!whitelistManager->AddPlayer(entry))
+			{
+				return false;
+			}
+
+			PublishWhitelistManagerSnapshot(whitelistManager);
+			return true;
+		}
+
+		bool RemoveWhitelistedPlayer(PlayerUID xuid)
+		{
+			const auto formatted = FormatXuid(xuid);
+			if (formatted.empty())
+			{
+				return false;
+			}
+
+			std::lock_guard<std::mutex> writeLock(g_accessState.writeLock);
+			const auto current = GetWhitelistManagerSnapshot();
+			if (current == nullptr)
+			{
+				return false;
+			}
+
+			auto whitelistManager = std::make_shared<WhitelistManager>(*current);
+			if (!whitelistManager->RemovePlayerByXuid(formatted))
+			{
+				return false;
+			}
+
+			PublishWhitelistManagerSnapshot(whitelistManager);
+			return true;
+		}
+
+		bool SnapshotBannedPlayers(std::vector<BannedPlayerEntry> *outEntries)
+		{
+			if (outEntries == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = GetBanManagerSnapshot();
+			if (banManager == nullptr)
+			{
+				outEntries->clear();
+				return false;
+			}
+
+			return banManager->SnapshotBannedPlayers(outEntries);
+		}
+
+		bool SnapshotBannedIps(std::vector<BannedIpEntry> *outEntries)
+		{
+			if (outEntries == nullptr)
+			{
+				return false;
+			}
+
+			std::shared_ptr<BanManager> banManager = GetBanManagerSnapshot();
+			if (banManager == nullptr)
+			{
+				outEntries->clear();
+				return false;
+			}
+
+			return banManager->SnapshotBannedIps(outEntries);
+		}
+
+		bool SnapshotWhitelistedPlayers(std::vector<WhitelistedPlayerEntry> *outEntries)
+		{
+			if (outEntries == nullptr)
+			{
+				return false;
+			}
+
+			const auto whitelistManager = GetWhitelistManagerSnapshot();
+			if (whitelistManager == nullptr)
+			{
+				outEntries->clear();
+				return false;
+			}
+
+			return whitelistManager->SnapshotWhitelistedPlayers(outEntries);
+		}
+	}
+}