From f483074cd2ff2cc9e9c3ef1df4430d4a65d1fb2a Mon Sep 17 00:00:00 2001 From: kuwa Date: Sun, 15 Mar 2026 16:32:50 +0900 Subject: Dedicated Server Software - Minecraft.Server.exe (#498) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add: Dedicated Server implementation - Introduced `ServerMain.cpp` for the dedicated server logic, handling command-line arguments, server initialization, and network management. - Created `postbuild_server.ps1` script for post-build tasks, including copying necessary resources and DLLs for the dedicated server. - Added `CopyServerAssets.cmake` to manage the copying of server assets during the build process, ensuring required files are available for the dedicated server. - Defined project filters in `Minecraft.Server.vcxproj.filters` for better organization of server-related files. * add: refactor world loader & add server properties - Introduced ServerLogger for logging startup steps and world I/O operations. - Implemented ServerProperties for loading and saving server configuration from `server.properties`. - Added WorldManager to handle world loading and creation based on server properties. - Updated ServerMain to integrate server properties loading and world management. - Enhanced project files to include new source and header files for the server components. * update: implement enhanced logging functionality with configurable log levels * update: update keyboard and mouse input initialization 1dc8a005ed111463c22c17b487e5ec8a3e2d30f3 * fix: change virtual screen resolution to 1920x1080(HD) Since 31881af56936aeef38ff322b975fd0 , `skinHud.swf` for 720 is not included in `MediaWindows64.arc`, the app crashes unless the virtual screen is set to HD. * fix: dedicated server build settings for miniaudio migration and missing sources - remove stale Windows64 Miles (mss64) link/copy references from server build - add Common/Filesystem/Filesystem.cpp to Minecraft.Server.vcxproj - add Windows64/PostProcesser.cpp to Minecraft.Server.vcxproj - fix unresolved externals (PostProcesser::*, FileExists) in dedicated server build * update: changed the virtual screen to 720p Since the crash caused by the 720p `skinHud.swf` not being included in `MediaWindows64.arc` has been resolved, switching back to 720p to reduce resource usage. * add: add Docker support for Dedicated Server add with entrypoint and build scripts * fix: add initial save for newly created worlds in dedicated server on the server side, I fixed the behavior introduced after commit aadb511, where newly created worlds are intentionally not saved to disk immediately. * update: add basically all configuration options that are implemented in the classes to `server.properties` * update: add LAN advertising configuration for server.properties LAN-Discovery, which isn’t needed in server mode and could potentially be a security risk, has also been disabled(only server mode). * add: add implementing interactive command line using linenoise - Integrated linenoise library for line editing and completion in the server console. - Updated ServerLogger to handle external writes safely during logging. - Modified ServerMain to initialize and manage the ServerCli for command input. - The implementation is separate from everything else, so it doesn't affect anything else. - The command input section and execution section are separated into threads. * update: enhance command line completion with predictive hints Like most command line tools, it highlights predictions in gray. * add: implement `StringUtils` for string manipulation and refactor usages Unified the scattered utility functions. * fix: send DisconnectPacket on shutdown and fix Win64 recv-thread teardown race Before this change, server/host shutdown closed sockets directly in ServerConnection::stop(), which bypassed the normal disconnect flow. As a result, clients could be dropped without receiving a proper DisconnectPacket during stop/kill/world-close paths. Also, WinsockNetLayer::Shutdown() could destroy synchronization objects while host-side recv threads were still exiting, causing a crash in RecvThreadProc (access violation on world close in host mode). * fix: return client to menus when Win64 host connection drops - Add client-side host disconnect handling in CPlatformNetworkManagerStub::DoWork() for _WINDOWS64. - When in QNET_STATE_GAME_PLAY as a non-host and WinsockNetLayer::IsConnected() becomes false, trigger g_NetworkManager.HandleDisconnect(false) to enter the normal disconnect/UI flow. - Use m_bLeaveGameOnTick as a one-shot guard to prevent repeated disconnect handling while the link remains down. - Reset m_bLeaveGameOnTick on LeaveGame(), HostGame(), and JoinGame() to avoid stale state across sessions. * update: converted Japanese comments to English * add: create `Minecraft.Server` developer guide in English and Japanese * update: add note about issue * add: add `nlohmann/json` json lib * add: add FileUtils Moved file operations to `utils`. * add: Dedicated Server BAN access manager with persistent player and IP bans - add Access frontend that publishes thread-safe ban manager snapshots for dedicated server use - add BanManager storage for banned-players.json and banned-ips.json with load/save/update flows - add persistent player and IP ban checks during dedicated server connection handling - add UTF-8 BOM-safe JSON parsing and shared file helpers backed by nlohmann/json - add Unicode-safe ban file read/write and safer atomic replacement behavior on Windows - add active-ban snapshot APIs and expiry-aware filtering for expires metadata - add RAII-based dedicated access shutdown handling during server startup and teardown * update: changed file read/write operations to use `FileUtils`. - As a side effect, saving has become faster! * fix: Re-added the source that had somehow disappeared. * add: significantly improved the dedicated server logging system - add ServerLogManager to Minecraft.Server as the single entry point for dedicated-server log output - forward CMinecraftApp logger output to the server logger when running with g_Win64DedicatedServer - add named network logs for incoming, accepted, rejected, and disconnected connections - cache connection metadata by smallId so player name and remote IP remain available for disconnect logs - keep Minecraft.Client changes minimal by using lightweight hook points and handling log orchestration on the server side * fix: added the updated library source * add: add `ban` and `pardon` commands for Player and IP * fix: fix stop command shutdown process add dedicated server shutdown request handling * fix: fixed the save logic during server shutdown Removed redundant repeated saves and eliminated the risks of async writes. * update: added new sever files to Docker entrypoint * fix: replace shutdown flag with atomic variable for thread safety * update: update Dedicated Server developer guide English is machine translated. Please forgive me. * update: check for the existence of `GameHDD` and create * add: add Whitelist to Dedicated Server * refactor: clean up and refactor the code - unify duplicated implementations that were copied repeatedly - update outdated patterns to more modern ones * fix: include UI header (new update fix) * fix: fix the detection range for excessive logging `getHighestNonEmptyY()` returning `-1` occurs normally when the chunk is entirely air. The caller (`Minecraft.World/LevelChunk.cpp:2400`) normalizes `-1` to `0`. * update: add world size config to dedicated server properties * update: update README add explanation of `server.properties` & launch arguments * update: add nightly release workflow for dedicated server and client builds to Actions * fix: update name for workflow * add random seed generation * add: add Docker nightly workflow for Dedicated Server publish to GitHub Container Registry * fix: ghost player when clients disconnect out of order #4 * fix: fix 7zip option * fix: fix Docker workflow for Dedicated Server artifact handling * add: add no build Dedicated Server startup scripts and Docker Compose * update: add README for Docker Dedicated Server setup with no local build * refactor: refactor command path structure As the number of commands has increased and become harder to navigate, each command has been organized into separate folders. * update: support stream(file stdin) input mode for server CLI Support for the stream (file stdin) required when attaching a tty to a Docker container on Linux. * add: add new CLI Console Commands for Dedicated Server Most of these commands are executed using the command dispatcher implemented on the `Minecraft.World` side. When registering them with the dispatcher, the sender uses a permission-enabled configuration that treats the CLI as a player. - default game. - enchant - experience. - give - kill(currently, getting a permission error for some reason) - time - weather. - update tp & gamemode command * fix: change player map icon to random select * update: increase the player limit * add: restore the basic anti-cheat implementation and add spawn protection Added the following anti-cheat measures and add spawn protection to `server.properties`. - instant break - speed - reach * fix: fix Docker image tag --------- Co-authored-by: sylvessa <225480449+sylvessa@users.noreply.github.com> --- Minecraft.Server/Common/AccessStorageUtils.h | 105 +++++++++++++ Minecraft.Server/Common/FileUtils.cpp | 146 ++++++++++++++++++ Minecraft.Server/Common/FileUtils.h | 25 ++++ Minecraft.Server/Common/NetworkUtils.h | 29 ++++ Minecraft.Server/Common/StringUtils.cpp | 212 +++++++++++++++++++++++++++ Minecraft.Server/Common/StringUtils.h | 23 +++ 6 files changed, 540 insertions(+) create mode 100644 Minecraft.Server/Common/AccessStorageUtils.h create mode 100644 Minecraft.Server/Common/FileUtils.cpp create mode 100644 Minecraft.Server/Common/FileUtils.h create mode 100644 Minecraft.Server/Common/NetworkUtils.h create mode 100644 Minecraft.Server/Common/StringUtils.cpp create mode 100644 Minecraft.Server/Common/StringUtils.h (limited to 'Minecraft.Server/Common') diff --git a/Minecraft.Server/Common/AccessStorageUtils.h b/Minecraft.Server/Common/AccessStorageUtils.h new file mode 100644 index 00000000..c5d3477c --- /dev/null +++ b/Minecraft.Server/Common/AccessStorageUtils.h @@ -0,0 +1,105 @@ +#pragma once + +#include "FileUtils.h" +#include "StringUtils.h" + +#include "..\vendor\nlohmann\json.hpp" + +#include + +namespace ServerRuntime +{ + namespace AccessStorageUtils + { + inline bool IsRegularFile(const std::string &path) + { + const std::wstring widePath = StringUtils::Utf8ToWide(path); + if (widePath.empty()) + { + return false; + } + + const DWORD attributes = GetFileAttributesW(widePath.c_str()); + return (attributes != INVALID_FILE_ATTRIBUTES) && ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0); + } + + inline bool EnsureJsonListFileExists(const std::string &path) + { + return IsRegularFile(path) || FileUtils::WriteTextFileAtomic(path, "[]\n"); + } + + inline bool TryGetStringField(const nlohmann::ordered_json &object, const char *key, std::string *outValue) + { + if (key == nullptr || outValue == nullptr || !object.is_object()) + { + return false; + } + + const auto it = object.find(key); + if (it == object.end() || !it->is_string()) + { + return false; + } + + *outValue = it->get(); + return true; + } + + inline std::string NormalizeXuid(const std::string &xuid) + { + const std::string trimmed = StringUtils::TrimAscii(xuid); + if (trimmed.empty()) + { + return ""; + } + + unsigned long long numericXuid = 0; + if (StringUtils::TryParseUnsignedLongLong(trimmed, &numericXuid)) + { + if (numericXuid == 0ULL) + { + return ""; + } + + char buffer[32] = {}; + sprintf_s(buffer, sizeof(buffer), "0x%016llx", numericXuid); + return buffer; + } + + return StringUtils::ToLowerAscii(trimmed); + } + + inline std::string BuildPathFromBaseDirectory(const std::string &baseDirectory, const char *fileName) + { + if (fileName == nullptr || fileName[0] == 0) + { + return ""; + } + + const std::wstring wideFileName = StringUtils::Utf8ToWide(fileName); + if (wideFileName.empty()) + { + return ""; + } + + if (baseDirectory.empty() || baseDirectory == ".") + { + return StringUtils::WideToUtf8(wideFileName); + } + + const std::wstring wideBaseDirectory = StringUtils::Utf8ToWide(baseDirectory); + if (wideBaseDirectory.empty()) + { + return StringUtils::WideToUtf8(wideFileName); + } + + const wchar_t last = wideBaseDirectory[wideBaseDirectory.size() - 1]; + if (last == L'\\' || last == L'/') + { + return StringUtils::WideToUtf8(wideBaseDirectory + wideFileName); + } + + return StringUtils::WideToUtf8(wideBaseDirectory + L"\\" + wideFileName); + } + } +} diff --git a/Minecraft.Server/Common/FileUtils.cpp b/Minecraft.Server/Common/FileUtils.cpp new file mode 100644 index 00000000..50eeeb72 --- /dev/null +++ b/Minecraft.Server/Common/FileUtils.cpp @@ -0,0 +1,146 @@ +#include "stdafx.h" + +#include "FileUtils.h" + +#include "StringUtils.h" + +#include +#include + +namespace ServerRuntime +{ + namespace FileUtils + { + namespace + { + static std::wstring ToWidePath(const std::string &filePath) + { + return StringUtils::Utf8ToWide(filePath); + } + } + + unsigned long long GetCurrentUtcFileTime() + { + FILETIME now = {}; + GetSystemTimeAsFileTime(&now); + + ULARGE_INTEGER value = {}; + value.LowPart = now.dwLowDateTime; + value.HighPart = now.dwHighDateTime; + return value.QuadPart; + } + + bool ReadTextFile(const std::string &filePath, std::string *outText) + { + if (outText == nullptr) + { + return false; + } + + outText->clear(); + + const std::wstring widePath = ToWidePath(filePath); + if (widePath.empty()) + { + return false; + } + + FILE *inFile = nullptr; + if (_wfopen_s(&inFile, widePath.c_str(), L"rb") != 0 || inFile == nullptr) + { + return false; + } + + if (fseek(inFile, 0, SEEK_END) != 0) + { + fclose(inFile); + return false; + } + + long fileSize = ftell(inFile); + if (fileSize < 0) + { + fclose(inFile); + return false; + } + + if (fseek(inFile, 0, SEEK_SET) != 0) + { + fclose(inFile); + return false; + } + + if (fileSize == 0) + { + fclose(inFile); + return true; + } + + outText->resize((size_t)fileSize); + size_t bytesRead = fread(&(*outText)[0], 1, (size_t)fileSize, inFile); + fclose(inFile); + + if (bytesRead != (size_t)fileSize) + { + outText->clear(); + return false; + } + + return true; + } + + bool WriteTextFileAtomic(const std::string &filePath, const std::string &text) + { + const std::wstring widePath = ToWidePath(filePath); + if (widePath.empty()) + { + return false; + } + + const std::wstring tmpPath = widePath + L".tmp"; + + FILE *outFile = nullptr; + if (_wfopen_s(&outFile, tmpPath.c_str(), L"wb") != 0 || outFile == nullptr) + { + return false; + } + + if (!text.empty()) + { + size_t bytesWritten = fwrite(text.data(), 1, text.size(), outFile); + if (bytesWritten != text.size()) + { + fclose(outFile); + DeleteFileW(tmpPath.c_str()); + return false; + } + } + + if (fflush(outFile) != 0 || _commit(_fileno(outFile)) != 0) + { + fclose(outFile); + DeleteFileW(tmpPath.c_str()); + return false; + } + fclose(outFile); + + DWORD attrs = GetFileAttributesW(widePath.c_str()); + if (attrs != INVALID_FILE_ATTRIBUTES && ((attrs & FILE_ATTRIBUTE_DIRECTORY) == 0)) + { + // Replace the destination without deleting the last known-good file first. + if (ReplaceFileW(widePath.c_str(), tmpPath.c_str(), nullptr, REPLACEFILE_IGNORE_MERGE_ERRORS, nullptr, nullptr)) + { + return true; + } + } + + if (MoveFileExW(tmpPath.c_str(), widePath.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) + { + return true; + } + + // Keep the temp file on failure so the original file remains recoverable and the caller can inspect the write result. + return false; + } + } +} \ No newline at end of file diff --git a/Minecraft.Server/Common/FileUtils.h b/Minecraft.Server/Common/FileUtils.h new file mode 100644 index 00000000..96e398cc --- /dev/null +++ b/Minecraft.Server/Common/FileUtils.h @@ -0,0 +1,25 @@ +#pragma once + +#include + +namespace ServerRuntime +{ + namespace FileUtils + { + /** + * Reads the full UTF-8 path target into memory without interpreting JSON or line endings + * UTF-8パスのテキストファイル全体をそのまま読み込む + */ + bool ReadTextFile(const std::string &filePath, std::string *outText); + /** + * Writes text through a same-directory temporary file and publishes it with a single replacement step + * 同一ディレクトリの一時ファイル経由で安全に書き換える + */ + bool WriteTextFileAtomic(const std::string &filePath, const std::string &text); + /** + * Returns the current UTC timestamp encoded in Windows FILETIME units for expiry comparisons + * 期限判定用に現在UTC時刻をWindows FILETIME単位で返す + */ + unsigned long long GetCurrentUtcFileTime(); + } +} \ No newline at end of file diff --git a/Minecraft.Server/Common/NetworkUtils.h b/Minecraft.Server/Common/NetworkUtils.h new file mode 100644 index 00000000..c77d4506 --- /dev/null +++ b/Minecraft.Server/Common/NetworkUtils.h @@ -0,0 +1,29 @@ +#pragma once + +#include "StringUtils.h" + +#include + +namespace ServerRuntime +{ + namespace NetworkUtils + { + inline std::string NormalizeIpToken(const std::string &ip) + { + return StringUtils::ToLowerAscii(StringUtils::TrimAscii(ip)); + } + + inline bool IsIpLiteral(const std::string &text) + { + const std::string trimmed = StringUtils::TrimAscii(text); + if (trimmed.empty()) + { + return false; + } + + IN_ADDR ipv4 = {}; + IN6_ADDR ipv6 = {}; + return InetPtonA(AF_INET, trimmed.c_str(), &ipv4) == 1 || InetPtonA(AF_INET6, trimmed.c_str(), &ipv6) == 1; + } + } +} diff --git a/Minecraft.Server/Common/StringUtils.cpp b/Minecraft.Server/Common/StringUtils.cpp new file mode 100644 index 00000000..40881ae7 --- /dev/null +++ b/Minecraft.Server/Common/StringUtils.cpp @@ -0,0 +1,212 @@ +#include "stdafx.h" + +#include "StringUtils.h" + +#include +#include +#include +#include + +namespace ServerRuntime +{ + namespace StringUtils + { + std::string WideToUtf8(const std::wstring &value) + { + if (value.empty()) + { + return std::string(); + } + + int charCount = WideCharToMultiByte(CP_UTF8, 0, value.c_str(), (int)value.length(), NULL, 0, NULL, NULL); + if (charCount <= 0) + { + return std::string(); + } + + std::string utf8; + utf8.resize(charCount); + WideCharToMultiByte(CP_UTF8, 0, value.c_str(), (int)value.length(), &utf8[0], charCount, NULL, NULL); + return utf8; + } + + std::wstring Utf8ToWide(const char *value) + { + if (value == NULL || value[0] == 0) + { + return std::wstring(); + } + + int wideCount = MultiByteToWideChar(CP_UTF8, 0, value, -1, NULL, 0); + if (wideCount <= 0) + { + // Fall back to the current ANSI code page so legacy non-UTF-8 inputs remain readable. + wideCount = MultiByteToWideChar(CP_ACP, 0, value, -1, NULL, 0); + if (wideCount <= 0) + { + return std::wstring(); + } + + std::wstring wide; + wide.resize(wideCount - 1); + MultiByteToWideChar(CP_ACP, 0, value, -1, &wide[0], wideCount); + return wide; + } + + std::wstring wide; + wide.resize(wideCount - 1); + MultiByteToWideChar(CP_UTF8, 0, value, -1, &wide[0], wideCount); + return wide; + } + + std::wstring Utf8ToWide(const std::string &value) + { + return Utf8ToWide(value.c_str()); + } + + std::string StripUtf8Bom(const std::string &value) + { + if (value.size() >= 3 && + (unsigned char)value[0] == 0xEF && + (unsigned char)value[1] == 0xBB && + (unsigned char)value[2] == 0xBF) + { + return value.substr(3); + } + + return value; + } + + std::string TrimAscii(const std::string &value) + { + size_t start = 0; + while (start < value.length() && std::isspace((unsigned char)value[start])) + { + ++start; + } + + size_t end = value.length(); + while (end > start && std::isspace((unsigned char)value[end - 1])) + { + --end; + } + + return value.substr(start, end - start); + } + + std::string ToLowerAscii(const std::string &value) + { + std::string lowered = value; + for (size_t i = 0; i < lowered.length(); ++i) + { + lowered[i] = (char)std::tolower((unsigned char)lowered[i]); + } + return lowered; + } + + std::string JoinTokens(const std::vector &tokens, size_t startIndex, const char *separator) + { + if (startIndex >= tokens.size()) + { + return std::string(); + } + + const auto joinSeparator = std::string((separator != nullptr) ? separator : " "); + size_t totalLength = 0; + for (size_t i = startIndex; i < tokens.size(); ++i) + { + totalLength += tokens[i].size(); + } + + totalLength += (tokens.size() - startIndex - 1) * joinSeparator.size(); + std::string joined; + joined.reserve(totalLength); + for (size_t i = startIndex; i < tokens.size(); ++i) + { + if (!joined.empty()) + { + joined += joinSeparator; + } + + joined += tokens[i]; + } + + return joined; + } + + bool StartsWithIgnoreCase(const std::string &value, const std::string &prefix) + { + if (prefix.size() > value.size()) + { + return false; + } + + for (size_t i = 0; i < prefix.size(); ++i) + { + unsigned char a = (unsigned char)value[i]; + unsigned char b = (unsigned char)prefix[i]; + if (std::tolower(a) != std::tolower(b)) + { + return false; + } + } + + return true; + } + + bool TryParseUnsignedLongLong(const std::string &value, unsigned long long *outValue) + { + if (outValue == nullptr) + { + return false; + } + + const std::string trimmed = TrimAscii(value); + if (trimmed.empty()) + { + return false; + } + + errno = 0; + char *end = nullptr; + const unsigned long long parsed = _strtoui64(trimmed.c_str(), &end, 0); + if (end == trimmed.c_str() || errno != 0) + { + return false; + } + + while (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n') + { + ++end; + } + + if (*end != 0) + { + return false; + } + + *outValue = parsed; + return true; + } + + std::string GetCurrentUtcTimestampIso8601() + { + SYSTEMTIME utc = {}; + GetSystemTime(&utc); + + char created[64] = {}; + sprintf_s( + created, + sizeof(created), + "%04u-%02u-%02uT%02u:%02u:%02uZ", + (unsigned)utc.wYear, + (unsigned)utc.wMonth, + (unsigned)utc.wDay, + (unsigned)utc.wHour, + (unsigned)utc.wMinute, + (unsigned)utc.wSecond); + return created; + } + } +} + diff --git a/Minecraft.Server/Common/StringUtils.h b/Minecraft.Server/Common/StringUtils.h new file mode 100644 index 00000000..68f818e1 --- /dev/null +++ b/Minecraft.Server/Common/StringUtils.h @@ -0,0 +1,23 @@ +#pragma once + +#include +#include + +namespace ServerRuntime +{ + namespace StringUtils + { + std::string WideToUtf8(const std::wstring &value); + std::wstring Utf8ToWide(const char *value); + std::wstring Utf8ToWide(const std::string &value); + std::string StripUtf8Bom(const std::string &value); + + std::string TrimAscii(const std::string &value); + std::string ToLowerAscii(const std::string &value); + std::string JoinTokens(const std::vector &tokens, size_t startIndex = 0, const char *separator = " "); + bool StartsWithIgnoreCase(const std::string &value, const std::string &prefix); + bool TryParseUnsignedLongLong(const std::string &value, unsigned long long *outValue); + std::string GetCurrentUtcTimestampIso8601(); + } +} + -- cgit v1.2.3