summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/BlockEntities/CommandBlockEntity.cpp2
-rw-r--r--src/Globals.h8
-rw-r--r--src/OSSupport/CMakeLists.txt2
-rw-r--r--src/OSSupport/MiniDumpWriter.h139
-rw-r--r--src/OSSupport/StartAsService.h173
-rw-r--r--src/OverridesSettingsRepository.cpp4
-rw-r--r--src/OverridesSettingsRepository.h4
-rw-r--r--src/RCONServer.cpp2
-rw-r--r--src/Root.cpp370
-rw-r--r--src/Root.h55
-rw-r--r--src/Server.cpp48
-rw-r--r--src/Server.h21
-rw-r--r--src/main.cpp590
13 files changed, 737 insertions, 681 deletions
diff --git a/src/BlockEntities/CommandBlockEntity.cpp b/src/BlockEntities/CommandBlockEntity.cpp
index ad78c4ea3..6cc83ff68 100644
--- a/src/BlockEntities/CommandBlockEntity.cpp
+++ b/src/BlockEntities/CommandBlockEntity.cpp
@@ -203,7 +203,7 @@ void cCommandBlockEntity::Execute()
{
cServer * Server = cRoot::Get()->GetServer();
LOGD("cCommandBlockEntity: Executing command %s", m_Command.c_str());
- Server->ExecuteConsoleCommand(RealCommand, CmdBlockOutCb);
+ Server->QueueExecuteConsoleCommand(RealCommand, CmdBlockOutCb);
}
else
{
diff --git a/src/Globals.h b/src/Globals.h
index c2f117e23..7fc9addf6 100644
--- a/src/Globals.h
+++ b/src/Globals.h
@@ -280,23 +280,23 @@ template class SizeChecker<UInt8, 1>;
#endif
// Pretty much the same as ASSERT() but stays in Release builds
- #define VERIFY(x) (!!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__), exit(1), 0))
+ #define VERIFY(x) (!!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__), std::abort(), 0))
#else // TEST_GLOBALS
#ifdef _DEBUG
- #define ASSERT(x) ( !!(x) || ( LOGERROR("Assertion failed: %s, file %s, line %i", #x, __FILE__, __LINE__), PrintStackTrace(), assert(0), 0))
+ #define ASSERT(x) ( !!(x) || ( LOGERROR("Assertion failed: %s, file %s, line %i", #x, __FILE__, __LINE__), std::abort(), 0))
#else
#define ASSERT(x)
#endif
// Pretty much the same as ASSERT() but stays in Release builds
- #define VERIFY(x) (!!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__), PrintStackTrace(), exit(1), 0))
+ #define VERIFY(x) (!!(x) || ( LOGERROR("Verification failed: %s, file %s, line %i", #x, __FILE__, __LINE__), std::abort(), 0))
#endif // else TEST_GLOBALS
/** Use to mark code that should be impossible to reach. */
-#define UNREACHABLE(x) do { FLOGERROR("Hit unreachable code: {0}, file {1}, line {2}", #x, __FILE__, __LINE__); PrintStackTrace(); std::terminate(); } while (false)
+#define UNREACHABLE(x) do { FLOGERROR("Hit unreachable code: {0}, file {1}, line {2}", #x, __FILE__, __LINE__); std::abort(); } while (false)
diff --git a/src/OSSupport/CMakeLists.txt b/src/OSSupport/CMakeLists.txt
index 1b853c202..42ce6934d 100644
--- a/src/OSSupport/CMakeLists.txt
+++ b/src/OSSupport/CMakeLists.txt
@@ -28,12 +28,14 @@ target_sources(
HostnameLookup.h
IPLookup.h
IsThread.h
+ MiniDumpWriter.h
Network.h
NetworkLookup.h
NetworkSingleton.h
Queue.h
ServerHandleImpl.h
StackTrace.h
+ StartAsService.h
TCPLinkImpl.h
UDPEndpointImpl.h
WinStackWalker.h
diff --git a/src/OSSupport/MiniDumpWriter.h b/src/OSSupport/MiniDumpWriter.h
new file mode 100644
index 000000000..e5cd1a0ac
--- /dev/null
+++ b/src/OSSupport/MiniDumpWriter.h
@@ -0,0 +1,139 @@
+
+#pragma once
+
+
+
+
+
+/** Flags to control minidump contents on supported platforms. */
+enum class MiniDumpFlags
+{
+ WithDataSegments,
+ WithFullMemory
+};
+
+
+
+
+
+#if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER) // 32-bit Windows app compiled in MSVC
+
+#include <dbghelp.h>
+
+
+
+
+
+/** Windows 32-bit stuff:
+When the server crashes, create a "dump file" containing the callstack of each thread and some variables;
+let the user send us that crash file for analysis */
+class MiniDumpWriter
+{
+ typedef BOOL(WINAPI *pMiniDumpWriteDump)(
+ HANDLE hProcess,
+ DWORD ProcessId,
+ HANDLE hFile,
+ MINIDUMP_TYPE DumpType,
+ PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
+ PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
+ PMINIDUMP_CALLBACK_INFORMATION CallbackParam
+ );
+
+public:
+
+ MiniDumpWriter()
+ {
+ // Magic code to produce dump-files on Windows if the server crashes:
+
+ m_DbgHelp = LoadLibrary(L"DBGHELP.DLL");
+ if (m_DbgHelp == INVALID_HANDLE_VALUE)
+ {
+ return;
+ }
+
+ s_WriteMiniDump = (pMiniDumpWriteDump)GetProcAddress(m_DbgHelp, "MiniDumpWriteDump");
+ if (s_WriteMiniDump != nullptr)
+ {
+ ASSERT(swprintf(s_DumpFileName, ARRAYCOUNT(s_DumpFileName), L"crash_mcs_%x.dmp", GetCurrentProcessId()) > 0);
+ SetUnhandledExceptionFilter(LastChanceExceptionFilter);
+ }
+
+ // End of dump-file magic
+ }
+
+ void AddDumpFlags(const MiniDumpFlags a_Flags)
+ {
+ switch (a_Flags)
+ {
+ case MiniDumpFlags::WithDataSegments:
+ {
+ s_DumpFlags = static_cast<MINIDUMP_TYPE>(s_DumpFlags | MINIDUMP_TYPE::MiniDumpWithDataSegs);
+ break;
+ }
+ case MiniDumpFlags::WithFullMemory:
+ {
+ s_DumpFlags = static_cast<MINIDUMP_TYPE>(s_DumpFlags | MINIDUMP_TYPE::MiniDumpWithFullMemory);
+ break;
+ }
+ }
+ }
+
+ ~MiniDumpWriter()
+ {
+ FreeLibrary(m_DbgHelp);
+ }
+
+private:
+
+ /** This function gets called just before the "program executed an illegal instruction and will be terminated" or similar.
+ Its purpose is to create the crashdump using the dbghlp DLLs */
+ static LONG WINAPI LastChanceExceptionFilter(__in struct _EXCEPTION_POINTERS * a_ExceptionInfo)
+ {
+ char * newStack = &s_ExceptionStack[sizeof(s_ExceptionStack) - 1];
+ char * oldStack;
+
+ // Use the substitute stack:
+ // This code is the reason why we don't support 64-bit (yet)
+ _asm
+ {
+ mov oldStack, esp
+ mov esp, newStack
+ }
+
+ MINIDUMP_EXCEPTION_INFORMATION ExcInformation;
+ ExcInformation.ThreadId = GetCurrentThreadId();
+ ExcInformation.ExceptionPointers = a_ExceptionInfo;
+ ExcInformation.ClientPointers = 0;
+
+ // Write the dump file:
+ HANDLE dumpFile = CreateFile(s_DumpFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+ s_WriteMiniDump(GetCurrentProcess(), GetCurrentProcessId(), dumpFile, s_DumpFlags, (a_ExceptionInfo) ? &ExcInformation : nullptr, nullptr, nullptr);
+ CloseHandle(dumpFile);
+
+ // Revert to old stack:
+ _asm
+ {
+ mov esp, oldStack
+ }
+
+ return 0;
+ }
+
+ HINSTANCE m_DbgHelp;
+
+ static inline pMiniDumpWriteDump s_WriteMiniDump; // The function in dbghlp DLL that creates dump files
+ static inline wchar_t s_DumpFileName[MAX_PATH]; // Filename of the dump file; hes to be created before the dump handler kicks in
+ static inline char s_ExceptionStack[128 * 1024]; // Substitute stack, just in case the handler kicks in because of "insufficient stack space"
+ static inline MINIDUMP_TYPE s_DumpFlags = MiniDumpNormal; // By default dump only the stack and some helpers
+};
+
+#else
+
+struct MiniDumpWriter
+{
+ void AddDumpFlags(const MiniDumpFlags)
+ {
+ }
+};
+
+#endif
diff --git a/src/OSSupport/StartAsService.h b/src/OSSupport/StartAsService.h
new file mode 100644
index 000000000..472184367
--- /dev/null
+++ b/src/OSSupport/StartAsService.h
@@ -0,0 +1,173 @@
+
+#pragma once
+
+
+
+
+
+#ifdef _WIN32
+
+#include <csignal>
+
+
+
+
+
+class cStartAsService
+{
+public:
+
+ /** Make a Windows service. */
+ template <auto UniversalMain>
+ static bool MakeIntoService()
+ {
+ SERVICE_TABLE_ENTRY ServiceTable[] =
+ {
+ { g_ServiceName, (LPSERVICE_MAIN_FUNCTION)serviceMain<UniversalMain> },
+ { nullptr, nullptr }
+ };
+
+ if (StartServiceCtrlDispatcher(ServiceTable) == FALSE)
+ {
+ throw std::system_error(GetLastError(), std::system_category());
+ }
+
+ return true;
+ }
+
+private:
+
+ /** Set the internal status of the service */
+ static void serviceSetState(DWORD acceptedControls, DWORD newState, DWORD exitCode)
+ {
+ SERVICE_STATUS serviceStatus = {};
+ serviceStatus.dwCheckPoint = 0;
+ serviceStatus.dwControlsAccepted = acceptedControls;
+ serviceStatus.dwCurrentState = newState;
+ serviceStatus.dwServiceSpecificExitCode = 0;
+ serviceStatus.dwServiceType = SERVICE_WIN32;
+ serviceStatus.dwWaitHint = 0;
+ serviceStatus.dwWin32ExitCode = exitCode;
+
+ if (SetServiceStatus(g_StatusHandle, &serviceStatus) == FALSE)
+ {
+ LOGERROR("SetServiceStatus() failed\n");
+ }
+ }
+
+ /** Handle stop events from the Service Control Manager */
+ static void WINAPI serviceCtrlHandler(DWORD CtrlCode)
+ {
+ if (CtrlCode == SERVICE_CONTROL_STOP)
+ {
+ std::raise(SIGINT);
+ serviceSetState(0, SERVICE_STOP_PENDING, 0);
+ }
+ }
+
+ /* Startup logic for running as a service */
+ template <auto MainFunction>
+ static void WINAPI serviceMain(DWORD argc, TCHAR *argv[])
+ {
+ wchar_t applicationFilename[MAX_PATH];
+ wchar_t applicationDirectory[MAX_PATH];
+
+ // Get this binary's file path:
+ if (GetModuleFileName(nullptr, applicationFilename, std::size(applicationFilename)) == 0)
+ {
+ serviceSetState(0, SERVICE_STOPPED, GetLastError());
+ return;
+ }
+
+ const auto LastComponent = wcsrchr(applicationFilename, L'\\');
+ if (LastComponent == nullptr)
+ {
+ serviceSetState(0, SERVICE_STOPPED, E_UNEXPECTED);
+ return;
+ }
+
+ const auto LengthToLastComponent = LastComponent - applicationFilename;
+
+ // Strip off the filename, keep only the path:
+ wcsncpy(applicationDirectory, applicationFilename, LengthToLastComponent);
+ applicationDirectory[LengthToLastComponent] = L'\0'; // Make sure new path is null terminated
+
+ // Services are run by the SCM, and inherit its working directory - usually System32.
+ // Set the working directory to the same location as the binary.
+ if (SetCurrentDirectory(applicationDirectory) == FALSE)
+ {
+ serviceSetState(0, SERVICE_STOPPED, GetLastError());
+ return;
+ }
+
+
+ g_StatusHandle = RegisterServiceCtrlHandler(g_ServiceName, serviceCtrlHandler);
+ if (g_StatusHandle == nullptr)
+ {
+ OutputDebugStringA("RegisterServiceCtrlHandler() failed\n");
+ serviceSetState(0, SERVICE_STOPPED, GetLastError());
+ return;
+ }
+
+ serviceSetState(SERVICE_ACCEPT_STOP, SERVICE_RUNNING, 0);
+
+ char MultibyteArgV0[MAX_PATH];
+ char * MultibyteArgV[] = { MultibyteArgV0 };
+
+ const auto OutputSize = std::size(MultibyteArgV0);
+ const auto TranslateResult = wcstombs(MultibyteArgV0, argv[0], OutputSize);
+
+ if (TranslateResult == static_cast<size_t>(-1))
+ {
+ // Translation failed entirely (!):
+ MultibyteArgV0[0] = '\0';
+ }
+ else if (TranslateResult == OutputSize)
+ {
+ // Output too small:
+ MultibyteArgV0[OutputSize - 1] = '\0';
+ }
+
+ const auto Result = MainFunction(1, MultibyteArgV, true);
+ const auto Return = (Result == EXIT_SUCCESS) ? S_OK : E_FAIL;
+
+ serviceSetState(0, SERVICE_STOPPED, Return);
+ }
+
+ static inline SERVICE_STATUS_HANDLE g_StatusHandle = nullptr;
+ static inline HANDLE g_ServiceThread = INVALID_HANDLE_VALUE;
+ static inline wchar_t g_ServiceName[] = L"Cuberite";
+};
+
+#else
+
+struct cStartAsService
+{
+ /** Make a UNIX daemon. */
+ template <auto>
+ static bool MakeIntoService()
+ {
+ pid_t pid = fork();
+
+ // fork() returns a negative value on error.
+ if (pid < 0)
+ {
+ throw std::system_error(errno, std::system_category());
+ }
+
+ // Check if we are the parent or child process. Parent stops here.
+ if (pid > 0)
+ {
+ return true;
+ }
+
+ // Child process now goes quiet, running in the background.
+ close(STDIN_FILENO);
+ close(STDOUT_FILENO);
+ close(STDERR_FILENO);
+
+ return false;
+ }
+};
+
+#endif
diff --git a/src/OverridesSettingsRepository.cpp b/src/OverridesSettingsRepository.cpp
index f4f56eac4..d07c39c73 100644
--- a/src/OverridesSettingsRepository.cpp
+++ b/src/OverridesSettingsRepository.cpp
@@ -2,9 +2,9 @@
#include "Globals.h"
#include "OverridesSettingsRepository.h"
-cOverridesSettingsRepository::cOverridesSettingsRepository(std::unique_ptr<cSettingsRepositoryInterface> a_Main, std::unique_ptr<cSettingsRepositoryInterface> a_Overrides) :
+cOverridesSettingsRepository::cOverridesSettingsRepository(std::unique_ptr<cSettingsRepositoryInterface> a_Main, cSettingsRepositoryInterface & a_Overrides) :
m_Main(std::move(a_Main)),
- m_Overrides(std::move(a_Overrides))
+ m_Overrides(&a_Overrides)
{
}
diff --git a/src/OverridesSettingsRepository.h b/src/OverridesSettingsRepository.h
index 05260f711..fdb2d7d17 100644
--- a/src/OverridesSettingsRepository.h
+++ b/src/OverridesSettingsRepository.h
@@ -7,7 +7,7 @@ class cOverridesSettingsRepository : public cSettingsRepositoryInterface
{
public:
- cOverridesSettingsRepository(std::unique_ptr<cSettingsRepositoryInterface> a_Main, std::unique_ptr<cSettingsRepositoryInterface> a_Overrides);
+ cOverridesSettingsRepository(std::unique_ptr<cSettingsRepositoryInterface> a_Main, cSettingsRepositoryInterface & a_Overrides);
virtual ~cOverridesSettingsRepository() override = default;
@@ -44,7 +44,7 @@ public:
private:
std::unique_ptr<cSettingsRepositoryInterface> m_Main;
- std::unique_ptr<cSettingsRepositoryInterface> m_Overrides;
+ cSettingsRepositoryInterface * m_Overrides;
};
diff --git a/src/RCONServer.cpp b/src/RCONServer.cpp
index dbce003b3..64ddfb4eb 100644
--- a/src/RCONServer.cpp
+++ b/src/RCONServer.cpp
@@ -295,7 +295,7 @@ bool cRCONServer::cConnection::ProcessPacket(UInt32 a_RequestID, UInt32 a_Packet
AString cmd(a_Payload, a_PayloadLength);
LOGD("RCON command from %s: \"%s\"", m_IPAddress.c_str(), cmd.c_str());
- cRoot::Get()->ExecuteConsoleCommand(cmd, *(new cRCONCommandOutput(*this, a_RequestID)));
+ cRoot::Get()->QueueExecuteConsoleCommand(cmd, *(new cRCONCommandOutput(*this, a_RequestID)));
// Send an empty response:
SendResponse(a_RequestID, RCON_PACKET_RESPONSE, 0, nullptr);
diff --git a/src/Root.cpp b/src/Root.cpp
index 4b40fd983..4291c5779 100644
--- a/src/Root.cpp
+++ b/src/Root.cpp
@@ -46,7 +46,10 @@
-cRoot * cRoot::s_Root = nullptr;
+extern bool g_RunAsService;
+decltype(cRoot::s_Root) cRoot::s_Root;
+decltype(cRoot::s_NextState) cRoot::s_NextState;
+decltype(cRoot::s_StopEvent) cRoot::s_StopEvent;
@@ -65,7 +68,7 @@ cRoot::cRoot(void) :
{
Temporary::RegisterAllBlockHandlers(m_BlockTypeRegistry);
s_Root = this;
- m_InputThreadRunFlag.clear();
+ TransitionNextState(NextState::Run);
}
@@ -81,85 +84,28 @@ cRoot::~cRoot()
-void cRoot::InputThread(cRoot & a_Params)
+bool cRoot::Run(cSettingsRepositoryInterface & a_OverridesRepo)
{
- cLogCommandOutputCallback Output;
- AString Command;
-
- while (a_Params.m_InputThreadRunFlag.test_and_set() && std::cin.good())
- {
- #ifndef _WIN32
- timeval Timeout{ 0, 0 };
- Timeout.tv_usec = 100 * 1000; // 100 msec
-
- fd_set ReadSet;
- FD_ZERO(&ReadSet);
- FD_SET(STDIN_FILENO, &ReadSet);
-
- if (select(STDIN_FILENO + 1, &ReadSet, nullptr, nullptr, &Timeout) <= 0)
- {
- // Don't call getline because there's nothing to read
- continue;
- }
- #endif
-
- std::getline(std::cin, Command);
-
- if (!a_Params.m_InputThreadRunFlag.test_and_set())
- {
- // Already shutting down, can't execute commands
- break;
- }
-
- if (!Command.empty())
- {
- // Execute and clear command string when submitted
- a_Params.ExecuteConsoleCommand(TrimString(Command), Output);
- }
- }
-
- // We have come here because the std::cin has received an EOF / a terminate signal has been sent, and the server is still running
- // Ignore this when running as a service, cin was never opened in that case
- if (!std::cin.good() && !m_RunAsService)
- {
- // Stop the server:
- a_Params.QueueExecuteConsoleCommand("stop");
- }
-}
-
-
-
-
-
-void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
-{
- #ifdef _WIN32
- HMENU ConsoleMenu = GetSystemMenu(GetConsoleWindow(), FALSE);
- EnableMenuItem(ConsoleMenu, SC_CLOSE, MF_GRAYED); // Disable close button when starting up; it causes problems with our CTRL-CLOSE handling
- #endif
-
- auto consoleLogListener = MakeConsoleListener(m_RunAsService);
+ auto consoleLogListener = MakeConsoleListener(g_RunAsService);
auto consoleAttachment = cLogger::GetInstance().AttachListener(std::move(consoleLogListener));
cLogger::cAttachment fileAttachment;
- if (!a_OverridesRepo->HasValue("Server","DisableLogFile"))
+ if (!a_OverridesRepo.HasValue("Server","DisableLogFile"))
{
auto fileLogListenerRet = MakeFileListener();
if (!fileLogListenerRet.first)
{
- m_TerminateEventRaised = true;
- LOGERROR("Failed to open log file, aborting");
- return;
+ throw std::runtime_error("failed to open log file");
}
fileAttachment = cLogger::GetInstance().AttachListener(std::move(fileLogListenerRet.second));
}
LOG("--- Started Log ---");
- #ifdef BUILD_ID
- LOG("Cuberite " BUILD_SERIES_NAME " build id: " BUILD_ID);
- LOG("from commit id: " BUILD_COMMIT_ID " built at: " BUILD_DATETIME);
- #endif
+#ifdef BUILD_ID
+ LOG("Cuberite " BUILD_SERIES_NAME " (id: " BUILD_ID ")");
+ LOG("from commit " BUILD_COMMIT_ID " built at: " BUILD_DATETIME);
+#endif
cDeadlockDetect dd;
auto BeginTime = std::chrono::steady_clock::now();
@@ -172,9 +118,9 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
LOG("Reading server config...");
m_SettingsFilename = "settings.ini";
- if (a_OverridesRepo->HasValue("Server","ConfigFile"))
+ if (a_OverridesRepo.HasValue("Server","ConfigFile"))
{
- m_SettingsFilename = a_OverridesRepo->GetValue("Server","ConfigFile");
+ m_SettingsFilename = a_OverridesRepo.GetValue("Server","ConfigFile");
}
auto IniFile = std::make_unique<cIniFile>();
@@ -187,7 +133,7 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
IniFile->AddHeaderComment(" Most of the settings here can be configured using the webadmin interface, if enabled in webadmin.ini");
}
- auto settingsRepo = std::make_unique<cOverridesSettingsRepository>(std::move(IniFile), std::move(a_OverridesRepo));
+ auto settingsRepo = std::make_unique<cOverridesSettingsRepository>(std::move(IniFile), a_OverridesRepo);
LOG("Starting server...");
@@ -200,8 +146,7 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
if (!m_Server->InitServer(*settingsRepo, ShouldAuthenticate))
{
settingsRepo->Flush();
- LOGERROR("Failure starting server, aborting...");
- return;
+ throw std::runtime_error("failure starting server");
}
m_WebAdmin = new cWebAdmin();
@@ -245,32 +190,13 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
{
m_WebAdmin->Start();
- LOGD("Starting InputThread...");
- try
- {
- m_InputThreadRunFlag.test_and_set();
- m_InputThread = std::thread(InputThread, std::ref(*this));
- }
- catch (std::system_error & a_Exception)
- {
- LOGERROR("cRoot::Start (std::thread) error %i: could not construct input thread; %s", a_Exception.code().value(), a_Exception.what());
- }
-
LOG("Startup complete, took %ldms!", static_cast<long int>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - BeginTime).count()));
// Save the current time
m_StartTime = std::chrono::steady_clock::now();
- #ifdef _WIN32
- EnableMenuItem(ConsoleMenu, SC_CLOSE, MF_ENABLED); // Re-enable close button
- #endif
-
- for (;;)
- {
- m_StopEvent.Wait();
-
- break;
- }
+ HandleInput();
+ s_StopEvent.Wait();
// Stop the server:
m_WebAdmin->Stop();
@@ -278,13 +204,6 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
LOG("Shutting down server...");
m_Server->Shutdown();
} // if (m_Server->Start()
- else
- {
- cRoot::m_TerminateEventRaised = true;
- #ifdef _WIN32
- EnableMenuItem(ConsoleMenu, SC_CLOSE, MF_ENABLED); // Re-enable close button
- #endif
- }
delete m_MojangAPI; m_MojangAPI = nullptr;
@@ -313,75 +232,28 @@ void cRoot::Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
LOG("Cleaning up...");
delete m_Server; m_Server = nullptr;
- m_InputThreadRunFlag.clear();
- #ifdef _WIN32
- DWORD Length;
- INPUT_RECORD Record
- {
- KEY_EVENT,
- {
- {
- TRUE,
- 1,
- VK_RETURN,
- static_cast<WORD>(MapVirtualKey(VK_RETURN, MAPVK_VK_TO_VSC)),
- { { VK_RETURN } },
- 0
- }
- }
- };
-
- // Can't kill the input thread since it breaks cin (getline doesn't block / receive input on restart)
- // Apparently no way to unblock getline
- // Only thing I can think of for now
- if (WriteConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &Record, 1, &Length) == 0)
- {
- LOGWARN("Couldn't notify the input thread; the server will hang before shutdown!");
- m_TerminateEventRaised = true;
- m_InputThread.detach();
- }
- else
- {
- m_InputThread.join();
- }
- #else
- m_InputThread.join();
- #endif
-
- if (m_TerminateEventRaised)
- {
- LOG("Shutdown successful!");
- }
- else
- {
- LOG("Shutdown successful - restarting...");
- }
+ LOG("Shutdown successful!");
LOG("--- Stopped Log ---");
+
+ return s_NextState == NextState::Restart;
}
-void cRoot::StopServer()
+void cRoot::Stop()
{
- // Kick all players from the server with custom disconnect message
+ TransitionNextState(NextState::Stop);
+}
- bool SentDisconnect = false;
- cRoot::Get()->ForEachPlayer([&](cPlayer & a_Player)
- {
- a_Player.GetClientHandlePtr()->Kick(m_Server->GetShutdownMessage());
- SentDisconnect = true;
- return false;
- }
- );
- if (SentDisconnect)
- {
- std::this_thread::sleep_for(std::chrono::seconds(1));
- }
- m_TerminateEventRaised = true;
- m_StopEvent.Set();
- m_InputThreadRunFlag.clear();
+
+
+
+
+void cRoot::Restart()
+{
+ TransitionNextState(NextState::Restart);
}
@@ -607,58 +479,39 @@ bool cRoot::ForEachWorld(cWorldListCallback a_Callback)
-void cRoot::TickCommands(void)
-{
- // Execute any pending commands:
- cCommandQueue PendingCommands;
- {
- cCSLock Lock(m_CSPendingCommands);
- std::swap(PendingCommands, m_PendingCommands);
- }
- for (cCommandQueue::iterator itr = PendingCommands.begin(), end = PendingCommands.end(); itr != end; ++itr)
- {
- ExecuteConsoleCommand(itr->m_Command, *(itr->m_Output));
- }
-}
-
-
-
-
-
void cRoot::QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
{
- // Put the command into a queue (Alleviates FS #363):
- cCSLock Lock(m_CSPendingCommands);
- m_PendingCommands.emplace_back(a_Cmd, &a_Output);
-}
-
-
-
-
-
-void cRoot::QueueExecuteConsoleCommand(const AString & a_Cmd)
-{
- // Put the command into a queue (Alleviates FS #363):
- cCSLock Lock(m_CSPendingCommands);
- m_PendingCommands.push_back(cCommand(a_Cmd, new cLogCommandDeleteSelfOutputCallback));
-}
-
-
+ const auto KickPlayers = [this]
+ {
+ // Kick all players from the server with custom disconnect message
+ bool SentDisconnect = false;
+ cRoot::Get()->ForEachPlayer(
+ [&](cPlayer & a_Player)
+ {
+ a_Player.GetClientHandlePtr()->Kick(m_Server->GetShutdownMessage());
+ SentDisconnect = true;
+ return false;
+ }
+ );
+ if (SentDisconnect)
+ {
+ std::this_thread::sleep_for(std::chrono::seconds(1));
+ }
+ };
-void cRoot::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
-{
// Some commands are built-in:
if (a_Cmd == "stop")
{
- StopServer();
+ KickPlayers();
+ cRoot::Stop();
return;
}
else if (a_Cmd == "restart")
{
- m_StopEvent.Set();
- m_InputThreadRunFlag.clear();
+ KickPlayers();
+ cRoot::Restart();
return;
}
@@ -670,6 +523,16 @@ void cRoot::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback
+void cRoot::QueueExecuteConsoleCommand(const AString & a_Cmd)
+{
+ // Put the command into a queue (Alleviates FS #363):
+ QueueExecuteConsoleCommand(a_Cmd, *new cLogCommandDeleteSelfOutputCallback);
+}
+
+
+
+
+
void cRoot::KickUser(int a_ClientID, const AString & a_Reason)
{
m_Server->KickUser(a_ClientID, a_Reason);
@@ -1068,3 +931,110 @@ AStringVector cRoot::GetPlayerTabCompletionMultiWorld(const AString & a_Text)
);
return Results;
}
+
+
+
+
+
+void cRoot::HandleInput()
+{
+ if (g_RunAsService)
+ {
+ // Ignore input when running as a service, cin was never opened in that case:
+ return;
+ }
+
+ cLogCommandOutputCallback Output;
+ AString Command;
+
+ while (s_NextState == NextState::Run)
+ {
+#ifndef _WIN32
+ timeval Timeout{ 0, 0 };
+ Timeout.tv_usec = 100 * 1000; // 100 msec
+
+ fd_set ReadSet;
+ FD_ZERO(&ReadSet);
+ FD_SET(STDIN_FILENO, &ReadSet);
+
+ if (select(STDIN_FILENO + 1, &ReadSet, nullptr, nullptr, &Timeout) <= 0)
+ {
+ // Don't call getline because there's nothing to read
+ continue;
+ }
+#endif
+
+ if (!std::getline(std::cin, Command))
+ {
+ cRoot::Stop();
+ return;
+ }
+
+ if (s_NextState != NextState::Run)
+ {
+ // Already shutting down, can't execute commands
+ break;
+ }
+
+ if (!Command.empty())
+ {
+ // Execute and clear command string when submitted
+ QueueExecuteConsoleCommand(TrimString(Command), Output);
+ }
+ }
+}
+
+
+
+
+
+void cRoot::TransitionNextState(NextState a_NextState)
+{
+ {
+ auto Current = s_NextState.load();
+ do
+ {
+ // Stopping is final, so stops override restarts:
+ if (Current == NextState::Stop)
+ {
+ return;
+ }
+ }
+ while (!s_NextState.compare_exchange_strong(Current, a_NextState));
+ }
+
+ if (s_NextState == NextState::Run)
+ {
+ return;
+ }
+
+ s_StopEvent.Set();
+
+#ifdef WIN32
+ if (g_RunAsService)
+ {
+ return;
+ }
+
+ DWORD Length;
+ INPUT_RECORD Record
+ {
+ KEY_EVENT,
+ {
+ {
+ TRUE,
+ 1,
+ VK_RETURN,
+ static_cast<WORD>(MapVirtualKey(VK_RETURN, MAPVK_VK_TO_VSC)),
+ { { VK_RETURN } },
+ 0
+ }
+ }
+ };
+
+ // Can't kill the input thread since it breaks cin (getline doesn't block / receive input on restart)
+ // Apparently no way to unblock getline apart from CancelIoEx, but xoft wants Windows XP support
+ // Only thing I can think of for now.
+ VERIFY(WriteConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &Record, 1, &Length) == TRUE);
+#endif
+}
diff --git a/src/Root.h b/src/Root.h
index 2610d28b8..1f5354c71 100644
--- a/src/Root.h
+++ b/src/Root.h
@@ -53,19 +53,20 @@ public:
static cRoot * Get() { return s_Root; }
// tolua_end
- static bool m_TerminateEventRaised;
- static bool m_RunAsService;
-
/** which ini file to load settings from, default is settings.ini */
AString m_SettingsFilename;
cRoot(void);
~cRoot();
- void Start(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo);
+ /** Run the server. Returns true if we should restart, false to quit. */
+ bool Run(cSettingsRepositoryInterface & a_OverridesRepo);
+
+ /** Interrupts the server and stops it, as if "/stop" typed in the console. */
+ static void Stop();
- /** Stops the server, as if "/stop" was typed in the console. */
- void StopServer();
+ /** Interrupts the server and restarts it, as if "/restart" was typed in the console. */
+ static void Restart();
// tolua_begin
cServer * GetServer(void) { return m_Server; }
@@ -127,18 +128,12 @@ public:
*/
void QueueExecuteConsoleCommand(const AString & a_Cmd); // tolua_export
- /** Executes a console command through the cServer class; does special handling for "stop" and "restart". */
- void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
-
/** Kicks the user, no matter in what world they are. Used from cAuthenticator */
void KickUser(int a_ClientID, const AString & a_Reason);
/** Called by cAuthenticator to auth the specified user */
void AuthenticateUser(int a_ClientID, const AString & a_Name, const cUUID & a_UUID, const Json::Value & a_Properties);
- /** Executes commands queued in the command queue */
- void TickCommands(void);
-
/** Returns the number of chunks loaded */
size_t GetTotalChunkCount(void); // tolua_export
@@ -195,31 +190,28 @@ public:
// tolua_end
private:
- class cCommand
- {
- public:
- cCommand(const AString & a_Command, cCommandOutputCallback * a_Output) :
- m_Command(a_Command),
- m_Output(a_Output)
- {
- }
- AString m_Command;
- cCommandOutputCallback * m_Output;
- } ;
+ /** States that the global cRoot can be in.
+ You can transition freely between Run and Restart, but the server unconditionally terminates in Stop. */
+ enum class NextState
+ {
+ Run,
+ Restart,
+ Stop
+ };
typedef std::map<AString, cWorld> WorldMap;
- typedef std::vector<cCommand> cCommandQueue;
+
+ /** Blocking reads and processes console input. */
+ void HandleInput();
+
+ /** Performs run state transition, enforcing guarantees about state transitions. */
+ static void TransitionNextState(NextState a_NextState);
cWorld * m_pDefaultWorld;
WorldMap m_WorldsByName;
- cCriticalSection m_CSPendingCommands;
- cCommandQueue m_PendingCommands;
-
- std::thread m_InputThread;
- cEvent m_StopEvent;
- std::atomic_flag m_InputThreadRunFlag;
+ static cEvent s_StopEvent;
cServer * m_Server;
cMonsterConfig * m_MonsterConfig;
@@ -254,5 +246,6 @@ private:
static cRoot * s_Root;
- static void InputThread(cRoot & a_Params);
+ /** Indicates the next action of cRoot, whether to run, stop or restart. */
+ static std::atomic<NextState> s_NextState;
}; // tolua_export
diff --git a/src/Server.cpp b/src/Server.cpp
index d9a0ced27..a1dedf333 100644
--- a/src/Server.cpp
+++ b/src/Server.cpp
@@ -94,7 +94,7 @@ void cServer::cTickThread::Execute(void)
{
auto NowTime = std::chrono::steady_clock::now();
auto msec = std::chrono::duration_cast<std::chrono::milliseconds>(NowTime - LastTime).count();
- m_ShouldTerminate = !m_Server.Tick(static_cast<float>(msec));
+ m_Server.Tick(static_cast<float>(msec));
auto TickTime = std::chrono::steady_clock::now() - NowTime;
if (TickTime < msPerTick)
@@ -118,7 +118,6 @@ cServer::cServer(void) :
m_PlayerCount(0),
m_ClientViewDistance(0),
m_bIsConnected(false),
- m_bRestarting(false),
m_RCONServer(*this),
m_MaxPlayers(0),
m_bIsHardcore(false),
@@ -331,27 +330,16 @@ cTCPLink::cCallbacksPtr cServer::OnConnectionAccepted(const AString & a_RemoteIP
-bool cServer::Tick(float a_Dt)
+void cServer::Tick(float a_Dt)
{
// Send the tick to the plugins, as well as let the plugin manager reload, if asked to (issue #102):
cPluginManager::Get()->Tick(a_Dt);
- // Let the Root process all the queued commands:
- cRoot::Get()->TickCommands();
+ // Process all the queued commands:
+ TickCommands();
// Tick all clients not yet assigned to a world:
TickClients(a_Dt);
-
- if (!m_bRestarting)
- {
- return true;
- }
- else
- {
- m_bRestarting = false;
- m_RestartEvent.Set();
- return false;
- }
}
@@ -445,6 +433,17 @@ bool cServer::Command(cClientHandle & a_Client, AString & a_Cmd)
+void cServer::QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
+{
+ // Put the command into a queue (Alleviates FS #363):
+ cCSLock Lock(m_CSPendingCommands);
+ m_PendingCommands.emplace_back(a_Cmd, &a_Output);
+}
+
+
+
+
+
void cServer::ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output)
{
AStringVector split = StringSplit(a_Cmd, " ");
@@ -647,8 +646,7 @@ void cServer::Shutdown(void)
m_ServerHandles.clear();
// Notify the tick thread and wait for it to terminate:
- m_bRestarting = true;
- m_RestartEvent.Wait();
+ m_TickThread.Stop();
cRoot::Get()->SaveAllChunks();
@@ -706,3 +704,17 @@ void cServer::AuthenticateUser(int a_ClientID, const AString & a_Name, const cUU
+void cServer::TickCommands(void)
+{
+ decltype(m_PendingCommands) PendingCommands;
+ {
+ cCSLock Lock(m_CSPendingCommands);
+ std::swap(PendingCommands, m_PendingCommands);
+ }
+
+ // Execute any pending commands:
+ for (const auto & Command : PendingCommands)
+ {
+ ExecuteConsoleCommand(Command.first, *Command.second);
+ }
+}
diff --git a/src/Server.h b/src/Server.h
index 208955237..5ac7fc998 100644
--- a/src/Server.h
+++ b/src/Server.h
@@ -100,8 +100,10 @@ public:
bool Command(cClientHandle & a_Client, AString & a_Cmd);
- /** Executes the console command, sends output through the specified callback */
- void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
+ /** Queues a console command for execution through the cServer class.
+ The command will be executed in the server tick thread.
+ The command's output will be written to the a_Output callback. */
+ void QueueExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
/** Lists all available console commands and their helpstrings */
void PrintHelp(const AStringVector & a_Split, cCommandOutputCallback & a_Output);
@@ -201,12 +203,13 @@ private:
/** Number of players currently playing in the server. */
std::atomic_size_t m_PlayerCount;
+ cCriticalSection m_CSPendingCommands;
+ std::vector<std::pair<AString, cCommandOutputCallback *>> m_PendingCommands;
+
int m_ClientViewDistance; // The default view distance for clients; settable in Settings.ini
bool m_bIsConnected; // true - connected false - not connected
- std::atomic<bool> m_bRestarting;
-
/** The private key used for the assymetric encryption start in the protocols */
cRsaPrivateKey m_PrivateKey;
@@ -229,7 +232,6 @@ private:
bool m_bAllowMultiLogin;
cTickThread m_TickThread;
- cEvent m_RestartEvent;
/** The server ID used for client authentication */
AString m_ServerID;
@@ -264,6 +266,9 @@ private:
cServer(void);
+ /** Executes the console command, sends output through the specified callback. */
+ void ExecuteConsoleCommand(const AString & a_Cmd, cCommandOutputCallback & a_Output);
+
/** Get the Forge mods registered for a given protocol, for modification */
AStringMap & RegisteredForgeMods(const UInt32 a_Protocol);
@@ -274,10 +279,14 @@ private:
Returns the cClientHandle reinterpreted as cTCPLink callbacks. */
cTCPLink::cCallbacksPtr OnConnectionAccepted(const AString & a_RemoteIPAddress);
- bool Tick(float a_Dt);
+ void Tick(float a_Dt);
/** Ticks the clients in m_Clients, manages the list in respect to removing clients */
void TickClients(float a_Dt);
+
+ /** Executes commands queued in the command queue. */
+ void TickCommands(void);
+
}; // tolua_export
diff --git a/src/main.cpp b/src/main.cpp
index 4d59fea0e..4a9f22f7d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,63 +1,38 @@
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
-#include "Root.h"
-#include "tclap/CmdLine.h"
-
-#include <exception>
-#include <csignal>
-#include <stdlib.h>
-
-
-
-#ifdef _MSC_VER
- #include <dbghelp.h>
-#endif // _MSC_VER
-
-#include "OSSupport/NetworkSingleton.h"
#include "BuildInfo.h"
#include "Logger.h"
-
#include "MemorySettingsRepository.h"
+#include "OSSupport/NetworkSingleton.h"
+#include "OSSupport/MiniDumpWriter.h"
+#include "OSSupport/StartAsService.h"
+#include "Root.h"
+#include "tclap/CmdLine.h"
-
-
-
-// Forward declarations to satisfy Clang's -Wmissing-variable-declarations:
-extern bool g_ShouldLogCommIn;
-extern bool g_ShouldLogCommOut;
-
+#include <csignal>
+#include <cstdlib>
-/** If something has told the server to stop; checked periodically in cRoot */
-bool cRoot::m_TerminateEventRaised = false;
-/** If set to true, the protocols will log each player's incoming (C->S) communication to a per-connection logfile */
+/** If set to true, the protocols will log each player's incoming (C->S) communication to a per-connection logfile. */
bool g_ShouldLogCommIn;
-/** If set to true, the protocols will log each player's outgoing (S->C) communication to a per-connection logfile */
+/** If set to true, the protocols will log each player's outgoing (S->C) communication to a per-connection logfile. */
bool g_ShouldLogCommOut;
-/** If set to true, binary will attempt to run as a service on Windows */
-bool cRoot::m_RunAsService = false;
+/** If set to true, binary will attempt to run as a service. */
+bool g_RunAsService;
+/** Global that registers itself as a last chance exception handler to write a minidump on crash. */
+MiniDumpWriter g_MiniDumpWriter;
-#if defined(_WIN32)
- SERVICE_STATUS_HANDLE g_StatusHandle = nullptr;
- HANDLE g_ServiceThread = INVALID_HANDLE_VALUE;
- #define SERVICE_NAME L"CuberiteService"
-#endif
-
-
-
-
-#ifndef _DEBUG
// Because SIG_DFL or SIG_IGN could be NULL instead of nullptr, we need to disable the Clang warning here
#ifdef __clang__
#pragma clang diagnostic push
@@ -69,119 +44,64 @@ bool cRoot::m_RunAsService = false;
static void NonCtrlHandler(int a_Signal)
{
LOGD("Terminate event raised from std::signal");
- cRoot::Get()->QueueExecuteConsoleCommand("stop");
switch (a_Signal)
{
case SIGSEGV:
{
- std::signal(SIGSEGV, SIG_DFL);
- LOGERROR(" D: | Cuberite has encountered an error and needs to close");
- LOGERROR("Details | SIGSEGV: Segmentation fault");
- #ifdef BUILD_ID
- LOGERROR("Cuberite " BUILD_SERIES_NAME " build id: " BUILD_ID);
- LOGERROR("from commit id: " BUILD_COMMIT_ID " built at: " BUILD_DATETIME);
- #endif
PrintStackTrace();
- abort();
+
+ LOGERROR("Failure report: \n\n"
+ " :( | Cuberite has encountered an error and needs to close\n"
+ " | SIGSEGV: Segmentation fault\n"
+ " |\n"
+#ifdef BUILD_ID
+ " | Cuberite " BUILD_SERIES_NAME " (id: " BUILD_ID ")\n"
+ " | from commit " BUILD_COMMIT_ID "\n");
+#endif
+
+ std::signal(SIGSEGV, SIG_DFL);
+ return;
}
case SIGABRT:
- #ifdef SIGABRT_COMPAT
+#ifdef SIGABRT_COMPAT
case SIGABRT_COMPAT:
- #endif
+#endif
{
- std::signal(a_Signal, SIG_DFL);
- LOGERROR(" D: | Cuberite has encountered an error and needs to close");
- LOGERROR("Details | SIGABRT: Server self-terminated due to an internal fault");
- #ifdef BUILD_ID
- LOGERROR("Cuberite " BUILD_SERIES_NAME " build id: " BUILD_ID);
- LOGERROR("from commit id: " BUILD_COMMIT_ID " built at: " BUILD_DATETIME);
- #endif
PrintStackTrace();
- abort();
+
+ LOGERROR("Failure report: \n\n"
+ " :( | Cuberite has encountered an error and needs to close\n"
+ " | SIGABRT: Server self-terminated due to an internal fault\n"
+ " |\n"
+#ifdef BUILD_ID
+ " | Cuberite " BUILD_SERIES_NAME " (id: " BUILD_ID ")\n"
+ " | from commit " BUILD_COMMIT_ID "\n");
+#endif
+
+ std::signal(SIGSEGV, SIG_DFL);
+ return;
}
case SIGINT:
case SIGTERM:
{
- std::signal(a_Signal, SIG_IGN); // Server is shutting down, wait for it...
- break;
+ // Server is shutting down, wait for it...
+ cRoot::Stop();
+ return;
}
- default: break;
+#ifdef SIGPIPE
+ case SIGPIPE:
+ {
+ // Ignore (PR #2487)
+ return;
+ }
+#endif
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
-#endif // _DEBUG
-
-
-
-
-
-#if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER)
-////////////////////////////////////////////////////////////////////////////////
-// Windows 32-bit stuff: when the server crashes, create a "dump file" containing the callstack of each thread and some variables; let the user send us that crash file for analysis
-
-typedef BOOL (WINAPI *pMiniDumpWriteDump)(
- HANDLE hProcess,
- DWORD ProcessId,
- HANDLE hFile,
- MINIDUMP_TYPE DumpType,
- PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
- PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
- PMINIDUMP_CALLBACK_INFORMATION CallbackParam
-);
-
-static pMiniDumpWriteDump g_WriteMiniDump; // The function in dbghlp DLL that creates dump files
-
-static wchar_t g_DumpFileName[MAX_PATH]; // Filename of the dump file; hes to be created before the dump handler kicks in
-static char g_ExceptionStack[128 * 1024]; // Substitute stack, just in case the handler kicks in because of "insufficient stack space"
-static MINIDUMP_TYPE g_DumpFlags = MiniDumpNormal; // By default dump only the stack and some helpers
-
-
-
-
-
-/** This function gets called just before the "program executed an illegal instruction and will be terminated" or similar.
-Its purpose is to create the crashdump using the dbghlp DLLs
-*/
-static LONG WINAPI LastChanceExceptionFilter(__in struct _EXCEPTION_POINTERS * a_ExceptionInfo)
-{
- char * newStack = &g_ExceptionStack[sizeof(g_ExceptionStack) - 1];
- char * oldStack;
-
- // Use the substitute stack:
- // This code is the reason why we don't support 64-bit (yet)
- _asm
- {
- mov oldStack, esp
- mov esp, newStack
- }
-
- MINIDUMP_EXCEPTION_INFORMATION ExcInformation;
- ExcInformation.ThreadId = GetCurrentThreadId();
- ExcInformation.ExceptionPointers = a_ExceptionInfo;
- ExcInformation.ClientPointers = 0;
-
- // Write the dump file:
- HANDLE dumpFile = CreateFile(g_DumpFileName, GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
- g_WriteMiniDump(GetCurrentProcess(), GetCurrentProcessId(), dumpFile, g_DumpFlags, (a_ExceptionInfo) ? &ExcInformation : nullptr, nullptr, nullptr);
- CloseHandle(dumpFile);
-
- // Print the stack trace for the basic debugging:
- PrintStackTrace();
-
- // Revert to old stack:
- _asm
- {
- mov esp, oldStack
- }
-
- return 0;
-}
-
-#endif // _WIN32 && !_WIN64
@@ -191,10 +111,12 @@ static LONG WINAPI LastChanceExceptionFilter(__in struct _EXCEPTION_POINTERS * a
// Handle CTRL events in windows, including console window close
static BOOL CtrlHandler(DWORD fdwCtrlType)
{
- cRoot::Get()->QueueExecuteConsoleCommand("stop");
+ cRoot::Stop();
LOGD("Terminate event raised from the Windows CtrlHandler");
- std::this_thread::sleep_for(std::chrono::seconds(10)); // Delay as much as possible to try to get the server to shut down cleanly - 10 seconds given by Windows
+ // Delay as much as possible to try to get the server to shut down cleanly - 10 seconds given by Windows
+ std::this_thread::sleep_for(std::chrono::seconds(10));
+
// Returning from main() automatically aborts this handler thread
return TRUE;
@@ -206,350 +128,186 @@ static BOOL CtrlHandler(DWORD fdwCtrlType)
////////////////////////////////////////////////////////////////////////////////
-// UniversalMain - Main startup logic for both standard running and as a service
+// ParseArguments - Read the startup arguments and store into a settings object
-static void UniversalMain(std::unique_ptr<cSettingsRepositoryInterface> a_OverridesRepo)
+static cMemorySettingsRepository ParseArguments(int argc, char ** argv)
{
- // Initialize logging subsystem:
- cLogger::InitiateMultithreading();
-
- // Initialize LibEvent:
- cNetworkSingleton::Get().Initialise();
-
- try
+ // Parse the comand line args:
+ TCLAP::CmdLine cmd("Cuberite");
+ TCLAP::ValueArg<int> slotsArg ("s", "max-players", "Maximum number of slots for the server to use, overrides setting in setting.ini", false, -1, "number", cmd);
+ TCLAP::ValueArg<AString> confArg ("c", "config-file", "Config file to use", false, "settings.ini", "string", cmd);
+ TCLAP::MultiArg<int> portsArg ("p", "port", "The port number the server should listen to", false, "port", cmd);
+ TCLAP::SwitchArg commLogArg ("", "log-comm", "Log server client communications to file", cmd);
+ TCLAP::SwitchArg commLogInArg ("", "log-comm-in", "Log inbound server client communications to file", cmd);
+ TCLAP::SwitchArg commLogOutArg ("", "log-comm-out", "Log outbound server client communications to file", cmd);
+ TCLAP::SwitchArg crashDumpFull ("", "crash-dump-full", "Crashdumps created by the server will contain full server memory", cmd);
+ TCLAP::SwitchArg crashDumpGlobals("", "crash-dump-globals", "Crashdumps created by the server will contain the global variables' values", cmd);
+ TCLAP::SwitchArg noBufArg ("", "no-output-buffering", "Disable output buffering", cmd);
+ TCLAP::SwitchArg noFileLogArg ("", "no-log-file", "Disable logging to file", cmd);
+ TCLAP::SwitchArg runAsServiceArg ("d", "service", "Run as a service on Windows, or daemon on UNIX like systems", cmd);
+ cmd.parse(argc, argv);
+
+ // Copy the parsed args' values into a settings repository:
+ cMemorySettingsRepository repo;
+ if (confArg.isSet())
{
- cRoot Root;
- Root.Start(std::move(a_OverridesRepo));
+ AString conf_file = confArg.getValue();
+ repo.AddValue("Server", "ConfigFile", conf_file);
}
- catch (const fmt::format_error & exc)
+ if (slotsArg.isSet())
{
- cRoot::m_TerminateEventRaised = true;
- FLOGERROR("Formatting exception: {0}", exc.what());
+ int slots = slotsArg.getValue();
+ repo.AddValue("Server", "MaxPlayers", static_cast<Int64>(slots));
}
- catch (const std::exception & exc)
+ if (portsArg.isSet())
{
- cRoot::m_TerminateEventRaised = true;
- LOGERROR("Standard exception: %s", exc.what());
+ for (auto port: portsArg.getValue())
+ {
+ repo.AddValue("Server", "Ports", std::to_string(port));
+ }
}
- catch (...)
+ if (noFileLogArg.getValue())
{
- cRoot::m_TerminateEventRaised = true;
- LOGERROR("Unknown exception!");
+ repo.AddValue("Server", "DisableLogFile", true);
}
-
- // Shutdown all of LibEvent:
- cNetworkSingleton::Get().Terminate();
-}
-
-
-
-
-
-#if defined(_WIN32) // Windows service support.
-////////////////////////////////////////////////////////////////////////////////
-// serviceWorkerThread: Keep the service alive
-
-static DWORD WINAPI serviceWorkerThread(LPVOID lpParam)
-{
- UNREFERENCED_PARAMETER(lpParam);
-
- while (!cRoot::m_TerminateEventRaised)
+ if (commLogArg.getValue())
{
- // Do the normal startup
- UniversalMain(std::make_unique<cMemorySettingsRepository>());
+ g_ShouldLogCommIn = true;
+ g_ShouldLogCommOut = true;
}
-
- return ERROR_SUCCESS;
-}
-
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-// serviceSetState: Set the internal status of the service
-
-static void serviceSetState(DWORD acceptedControls, DWORD newState, DWORD exitCode)
-{
- SERVICE_STATUS serviceStatus = {};
- serviceStatus.dwCheckPoint = 0;
- serviceStatus.dwControlsAccepted = acceptedControls;
- serviceStatus.dwCurrentState = newState;
- serviceStatus.dwServiceSpecificExitCode = 0;
- serviceStatus.dwServiceType = SERVICE_WIN32;
- serviceStatus.dwWaitHint = 0;
- serviceStatus.dwWin32ExitCode = exitCode;
-
- if (SetServiceStatus(g_StatusHandle, &serviceStatus) == FALSE)
+ else
{
- LOGERROR("SetServiceStatus() failed\n");
+ g_ShouldLogCommIn = commLogInArg.getValue();
+ g_ShouldLogCommOut = commLogOutArg.getValue();
}
-}
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-// serviceCtrlHandler: Handle stop events from the Service Control Manager
-
-static void WINAPI serviceCtrlHandler(DWORD CtrlCode)
-{
- switch (CtrlCode)
+ if (noBufArg.getValue())
{
- case SERVICE_CONTROL_STOP:
- {
- cRoot::Get()->QueueExecuteConsoleCommand("stop");
- serviceSetState(0, SERVICE_STOP_PENDING, 0);
- break;
- }
- default:
- {
- break;
- }
+ setvbuf(stdout, nullptr, _IONBF, 0);
}
-}
+ repo.SetReadOnly();
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-// serviceMain: Startup logic for running as a service
-
-static void WINAPI serviceMain(DWORD argc, TCHAR *argv[])
-{
- wchar_t applicationFilename[MAX_PATH];
- wchar_t applicationDirectory[MAX_PATH];
-
- GetModuleFileName(nullptr, applicationFilename, sizeof(applicationFilename)); // This binary's file path.
-
- // Strip off the filename, keep only the path:
- wcsncpy_s(applicationDirectory, sizeof(applicationDirectory), applicationFilename, (wcsrchr(applicationFilename, '\\') - applicationFilename));
- applicationDirectory[wcslen(applicationDirectory)] = '\0'; // Make sure new path is null terminated
-
- // Services are run by the SCM, and inherit its working directory - usually System32.
- // Set the working directory to the same location as the binary.
- SetCurrentDirectory(applicationDirectory);
-
- g_StatusHandle = RegisterServiceCtrlHandler(SERVICE_NAME, serviceCtrlHandler);
- if (g_StatusHandle == nullptr)
+ if (runAsServiceArg.getValue())
{
- OutputDebugStringA("RegisterServiceCtrlHandler() failed\n");
- serviceSetState(0, SERVICE_STOPPED, GetLastError());
- return;
+ g_RunAsService = true;
}
- serviceSetState(SERVICE_ACCEPT_STOP, SERVICE_RUNNING, 0);
-
- DWORD ThreadID;
- g_ServiceThread = CreateThread(nullptr, 0, serviceWorkerThread, nullptr, 0, &ThreadID);
- if (g_ServiceThread == nullptr)
+ // Apply the CrashDump flags for platforms that support them:
+ if (crashDumpGlobals.getValue())
{
- OutputDebugStringA("CreateThread() failed\n");
- serviceSetState(0, SERVICE_STOPPED, GetLastError());
- return;
+ g_MiniDumpWriter.AddDumpFlags(MiniDumpFlags::WithDataSegments);
+ }
+ if (crashDumpFull.getValue())
+ {
+ g_MiniDumpWriter.AddDumpFlags(MiniDumpFlags::WithFullMemory);
}
- WaitForSingleObject(g_ServiceThread, INFINITE); // Wait here for a stop signal.
-
- CloseHandle(g_ServiceThread);
- serviceSetState(0, SERVICE_STOPPED, 0);
+ return repo;
}
-#endif // Windows service support.
-static std::unique_ptr<cMemorySettingsRepository> ParseArguments(int argc, char ** argv)
+////////////////////////////////////////////////////////////////////////////////
+// UniversalMain - Main startup logic for both standard running and as a service
+
+static int UniversalMain(int argc, char * argv[], bool RunningAsService)
{
- try
+ // Initialize logging subsystem:
+ cLogger::InitiateMultithreading();
+
+ struct NetworkRAII
{
- // Parse the comand line args:
- TCLAP::CmdLine cmd("Cuberite");
- TCLAP::ValueArg<int> slotsArg ("s", "max-players", "Maximum number of slots for the server to use, overrides setting in setting.ini", false, -1, "number", cmd);
- TCLAP::ValueArg<AString> confArg ("c", "config-file", "Config file to use", false, "settings.ini", "string", cmd);
- TCLAP::MultiArg<int> portsArg ("p", "port", "The port number the server should listen to", false, "port", cmd);
- TCLAP::SwitchArg commLogArg ("", "log-comm", "Log server client communications to file", cmd);
- TCLAP::SwitchArg commLogInArg ("", "log-comm-in", "Log inbound server client communications to file", cmd);
- TCLAP::SwitchArg commLogOutArg ("", "log-comm-out", "Log outbound server client communications to file", cmd);
- TCLAP::SwitchArg crashDumpFull ("", "crash-dump-full", "Crashdumps created by the server will contain full server memory", cmd);
- TCLAP::SwitchArg crashDumpGlobals("", "crash-dump-globals", "Crashdumps created by the server will contain the global variables' values", cmd);
- TCLAP::SwitchArg noBufArg ("", "no-output-buffering", "Disable output buffering", cmd);
- TCLAP::SwitchArg noFileLogArg ("", "no-log-file", "Disable logging to file", cmd);
- TCLAP::SwitchArg runAsServiceArg ("d", "service", "Run as a service on Windows, or daemon on UNIX like systems", cmd);
- cmd.parse(argc, argv);
-
- // Copy the parsed args' values into a settings repository:
- auto repo = std::make_unique<cMemorySettingsRepository>();
- if (confArg.isSet())
+ NetworkRAII()
{
- AString conf_file = confArg.getValue();
- repo->AddValue("Server", "ConfigFile", conf_file);
+ // Initialize LibEvent:
+ cNetworkSingleton::Get().Initialise();
}
- if (slotsArg.isSet())
+
+ ~NetworkRAII()
{
- int slots = slotsArg.getValue();
- repo->AddValue("Server", "MaxPlayers", static_cast<Int64>(slots));
+ // Shutdown all of LibEvent:
+ cNetworkSingleton::Get().Terminate();
}
- if (portsArg.isSet())
+ };
+
+ try
+ {
+ // Make sure g_RunAsService is set correctly before checking it's value
+ auto Settings = ParseArguments(argc, argv);
+
+ // Attempt to run as a service
+ if (!RunningAsService && g_RunAsService)
{
- for (auto port: portsArg.getValue())
+ // This will either fork or call UniversalMain again:
+ if (cStartAsService::MakeIntoService<&UniversalMain>())
{
- repo->AddValue("Server", "Ports", std::to_string(port));
+ return EXIT_SUCCESS;
}
}
- if (noFileLogArg.getValue())
- {
- repo->AddValue("Server", "DisableLogFile", true);
- }
- if (commLogArg.getValue())
- {
- g_ShouldLogCommIn = true;
- g_ShouldLogCommOut = true;
- }
- else
- {
- g_ShouldLogCommIn = commLogInArg.getValue();
- g_ShouldLogCommOut = commLogOutArg.getValue();
- }
- if (noBufArg.getValue())
- {
- setvbuf(stdout, nullptr, _IONBF, 0);
- }
- repo->SetReadOnly();
- // Set the service flag directly to cRoot:
- if (runAsServiceArg.getValue())
+ while (true)
{
- cRoot::m_RunAsService = true;
- }
+ NetworkRAII LibEvent;
+ cRoot Root;
- // Apply the CrashDump flags for platforms that support them:
- #if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER) // 32-bit Windows app compiled in MSVC
- if (crashDumpGlobals.getValue())
+ if (!Root.Run(Settings))
{
- g_DumpFlags = static_cast<MINIDUMP_TYPE>(g_DumpFlags | MiniDumpWithDataSegs);
+ break;
}
- if (crashDumpFull.getValue())
- {
- g_DumpFlags = static_cast<MINIDUMP_TYPE>(g_DumpFlags | MiniDumpWithFullMemory);
- }
- #endif // 32-bit Windows app compiled in MSVC
+ }
- return repo;
+ return EXIT_SUCCESS;
}
- catch (const TCLAP::ArgException & exc)
+ catch (const fmt::format_error & Oops)
{
- fmt::print("Error reading command line {0} for arg {1}", exc.error(), exc.argId());
- return std::make_unique<cMemorySettingsRepository>();
+ std::cerr << "Formatting exception: " << Oops.what() << '\n';
+ }
+ catch (const TCLAP::ArgException & Oops)
+ {
+ std::cerr << fmt::sprintf("Error reading command line {} for argument {}\n", Oops.error(), Oops.argId());
+ }
+ catch (const std::exception & Oops)
+ {
+ std::cerr << "Standard exception: " << Oops.what() << '\n';
+ }
+ catch (...)
+ {
+ std::cerr << "Unknown exception!\n";
}
-}
+ return EXIT_FAILURE;
+}
-////////////////////////////////////////////////////////////////////////////////
-// main:
int main(int argc, char ** argv)
{
- // Magic code to produce dump-files on Windows if the server crashes:
- #if defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER) // 32-bit Windows app compiled in MSVC
- HINSTANCE hDbgHelp = LoadLibrary(L"DBGHELP.DLL");
- g_WriteMiniDump = (pMiniDumpWriteDump)GetProcAddress(hDbgHelp, "MiniDumpWriteDump");
- if (g_WriteMiniDump != nullptr)
- {
- _snwprintf_s(g_DumpFileName, ARRAYCOUNT(g_DumpFileName), _TRUNCATE, L"crash_mcs_%x.dmp", GetCurrentProcessId());
- SetUnhandledExceptionFilter(LastChanceExceptionFilter);
- }
- #endif // 32-bit Windows app compiled in MSVC
- // End of dump-file magic
-
-
- #if defined(_DEBUG) && defined(_MSC_VER)
- _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
-
- // _X: The simple built-in CRT leak finder - simply break when allocating the Nth block ({N} is listed in the leak output)
- // Only useful when the leak is in the same sequence all the time
- // _CrtSetBreakAlloc(85950);
-
- #endif // _DEBUG && _MSC_VER
-
- #ifndef _DEBUG
- std::signal(SIGSEGV, NonCtrlHandler);
- std::signal(SIGTERM, NonCtrlHandler);
- std::signal(SIGINT, NonCtrlHandler);
- std::signal(SIGABRT, NonCtrlHandler);
- #ifdef SIGABRT_COMPAT
- std::signal(SIGABRT_COMPAT, NonCtrlHandler);
- #endif // SIGABRT_COMPAT
- #endif
-
-
- #ifdef __unix__
- std::signal(SIGPIPE, SIG_IGN);
- #endif
-
- #ifdef _WIN32
- if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE))
- {
- LOGERROR("Could not install the Windows CTRL handler!");
- }
- #endif
-
- // Make sure m_RunAsService is set correctly before checking it's value
- ParseArguments(argc, argv);
-
- // Attempt to run as a service
- if (cRoot::m_RunAsService)
- {
- #if defined(_WIN32) // Windows service.
- SERVICE_TABLE_ENTRY ServiceTable[] =
- {
- { SERVICE_NAME, (LPSERVICE_MAIN_FUNCTION)serviceMain },
- { nullptr, nullptr }
- };
+#if !defined(NDEBUG) && defined(_MSC_VER)
+ _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
- if (StartServiceCtrlDispatcher(ServiceTable) == FALSE)
- {
- LOGERROR("Attempted, but failed, service startup.");
- return GetLastError();
- }
- #else // UNIX daemon.
- pid_t pid = fork();
+ // _X: The simple built-in CRT leak finder - simply break when allocating the Nth block ({N} is listed in the leak output)
+ // Only useful when the leak is in the same sequence all the time
+ // _CrtSetBreakAlloc(85950);
- // fork() returns a negative value on error.
- if (pid < 0)
- {
- LOGERROR("Could not fork process.");
- return EXIT_FAILURE;
- }
+#endif // _DEBUG && _MSC_VER
- // Check if we are the parent or child process. Parent stops here.
- if (pid > 0)
- {
- return EXIT_SUCCESS;
- }
+ std::signal(SIGSEGV, NonCtrlHandler);
+ std::signal(SIGTERM, NonCtrlHandler);
+ std::signal(SIGINT, NonCtrlHandler);
+ std::signal(SIGABRT, NonCtrlHandler);
+#ifdef SIGABRT_COMPAT
+ std::signal(SIGABRT_COMPAT, NonCtrlHandler);
+#endif
+#ifdef SIGPIPE
+ std::signal(SIGPIPE, SIG_IGN);
+#endif
- // Child process now goes quiet, running in the background.
- close(STDIN_FILENO);
- close(STDOUT_FILENO);
- close(STDERR_FILENO);
+#ifdef _WIN32
+ VERIFY(SetConsoleCtrlHandler(reinterpret_cast<PHANDLER_ROUTINE>(CtrlHandler), TRUE) == TRUE);
+#endif
- while (!cRoot::m_TerminateEventRaised)
- {
- UniversalMain(ParseArguments(argc, argv));
- }
- #endif
- }
- else
- {
- while (!cRoot::m_TerminateEventRaised)
- {
- // Not running as a service, do normal startup
- UniversalMain(ParseArguments(argc, argv));
- }
- }
- return EXIT_SUCCESS;
+ return UniversalMain(argc, argv, false);
}