summaryrefslogtreecommitdiffstats
path: root/icinga-app/icinga.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'icinga-app/icinga.cpp')
-rw-r--r--icinga-app/icinga.cpp949
1 files changed, 949 insertions, 0 deletions
diff --git a/icinga-app/icinga.cpp b/icinga-app/icinga.cpp
new file mode 100644
index 0000000..05f4944
--- /dev/null
+++ b/icinga-app/icinga.cpp
@@ -0,0 +1,949 @@
+/* Icinga 2 | (c) 2012 Icinga GmbH | GPLv2+ */
+
+#include "cli/clicommand.hpp"
+#include "config/configcompilercontext.hpp"
+#include "config/configcompiler.hpp"
+#include "config/configitembuilder.hpp"
+#include "config/expression.hpp"
+#include "base/application.hpp"
+#include "base/configuration.hpp"
+#include "base/logger.hpp"
+#include "base/timer.hpp"
+#include "base/utility.hpp"
+#include "base/loader.hpp"
+#include "base/exception.hpp"
+#include "base/convert.hpp"
+#include "base/scriptglobal.hpp"
+#include "base/context.hpp"
+#include "base/console.hpp"
+#include "base/process.hpp"
+#include "config.h"
+#include <boost/program_options.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <thread>
+
+#ifndef _WIN32
+# include <sys/types.h>
+# include <pwd.h>
+# include <grp.h>
+#else
+# include <windows.h>
+# include <Lmcons.h>
+# include <Shellapi.h>
+# include <tchar.h>
+#endif /* _WIN32 */
+
+using namespace icinga;
+namespace po = boost::program_options;
+
+#ifdef _WIN32
+static SERVICE_STATUS l_SvcStatus;
+static SERVICE_STATUS_HANDLE l_SvcStatusHandle;
+static HANDLE l_Job;
+#endif /* _WIN32 */
+
+static std::vector<String> GetLogLevelCompletionSuggestions(const String& arg)
+{
+ std::vector<String> result;
+
+ String debugLevel = "debug";
+ if (debugLevel.Find(arg) == 0)
+ result.push_back(debugLevel);
+
+ String noticeLevel = "notice";
+ if (noticeLevel.Find(arg) == 0)
+ result.push_back(noticeLevel);
+
+ String informationLevel = "information";
+ if (informationLevel.Find(arg) == 0)
+ result.push_back(informationLevel);
+
+ String warningLevel = "warning";
+ if (warningLevel.Find(arg) == 0)
+ result.push_back(warningLevel);
+
+ String criticalLevel = "critical";
+ if (criticalLevel.Find(arg) == 0)
+ result.push_back(criticalLevel);
+
+ return result;
+}
+
+static std::vector<String> GlobalArgumentCompletion(const String& argument, const String& word)
+{
+ if (argument == "include")
+ return GetBashCompletionSuggestions("directory", word);
+ else if (argument == "log-level")
+ return GetLogLevelCompletionSuggestions(word);
+ else
+ return std::vector<String>();
+}
+
+static void HandleLegacyDefines()
+{
+#ifdef _WIN32
+ String dataPrefix = Utility::GetIcingaDataPath();
+#endif /* _WIN32 */
+
+ Value localStateDir = Configuration::LocalStateDir;
+
+ if (!localStateDir.IsEmpty()) {
+ Log(LogWarning, "icinga-app")
+ << "Please do not set the deprecated 'LocalStateDir' constant,"
+ << " use the 'DataDir', 'LogDir', 'CacheDir' and 'SpoolDir' constants instead!"
+ << " For compatibility reasons, these are now set based on the 'LocalStateDir' constant.";
+
+#ifdef _WIN32
+ Configuration::DataDir = localStateDir + "\\lib\\icinga2";
+ Configuration::LogDir = localStateDir + "\\log\\icinga2";
+ Configuration::CacheDir = localStateDir + "\\cache\\icinga2";
+ Configuration::SpoolDir = localStateDir + "\\spool\\icinga2";
+ } else {
+ Configuration::LocalStateDir = dataPrefix + "\\var";
+#else /* _WIN32 */
+ Configuration::DataDir = localStateDir + "/lib/icinga2";
+ Configuration::LogDir = localStateDir + "/log/icinga2";
+ Configuration::CacheDir = localStateDir + "/cache/icinga2";
+ Configuration::SpoolDir = localStateDir + "/spool/icinga2";
+ } else {
+ Configuration::LocalStateDir = ICINGA_LOCALSTATEDIR;
+#endif /* _WIN32 */
+ }
+
+ Value sysconfDir = Configuration::SysconfDir;
+ if (!sysconfDir.IsEmpty()) {
+ Log(LogWarning, "icinga-app")
+ << "Please do not set the deprecated 'Sysconfdir' constant, use the 'ConfigDir' constant instead! For compatibility reasons, their value is set based on the 'SysconfDir' constant.";
+
+#ifdef _WIN32
+ Configuration::ConfigDir = sysconfDir + "\\icinga2";
+ } else {
+ Configuration::SysconfDir = dataPrefix + "\\etc";
+#else /* _WIN32 */
+ Configuration::ConfigDir = sysconfDir + "/icinga2";
+ } else {
+ Configuration::SysconfDir = ICINGA_SYSCONFDIR;
+#endif /* _WIN32 */
+ }
+
+ Value runDir = Configuration::RunDir;
+ if (!runDir.IsEmpty()) {
+ Log(LogWarning, "icinga-app")
+ << "Please do not set the deprecated 'RunDir' constant, use the 'InitRunDir' constant instead! For compatibility reasons, their value is set based on the 'RunDir' constant.";
+
+#ifdef _WIN32
+ Configuration::InitRunDir = runDir + "\\icinga2";
+ } else {
+ Configuration::RunDir = dataPrefix + "\\var\\run";
+#else /* _WIN32 */
+ Configuration::InitRunDir = runDir + "/icinga2";
+ } else {
+ Configuration::RunDir = ICINGA_RUNDIR;
+#endif /* _WIN32 */
+ }
+}
+
+static int Main()
+{
+ int argc = Application::GetArgC();
+ char **argv = Application::GetArgV();
+
+ bool autocomplete = false;
+ int autoindex = 0;
+
+ if (argc >= 4 && strcmp(argv[1], "--autocomplete") == 0) {
+ autocomplete = true;
+
+ try {
+ autoindex = Convert::ToLong(argv[2]);
+ } catch (const std::invalid_argument&) {
+ Log(LogCritical, "icinga-app")
+ << "Invalid index for --autocomplete: " << argv[2];
+ return EXIT_FAILURE;
+ }
+
+ argc -= 3;
+ argv += 3;
+ }
+
+ /* Set thread title. */
+ Utility::SetThreadName("Main Thread", false);
+
+ /* Install exception handlers to make debugging easier. */
+ Application::InstallExceptionHandlers();
+
+#ifdef _WIN32
+ bool builtinPaths = true;
+
+ /* Programm install location, C:/Program Files/Icinga2 */
+ String binaryPrefix = Utility::GetIcingaInstallPath();
+ /* Returns the datapath for daemons, %PROGRAMDATA%/icinga2 */
+ String dataPrefix = Utility::GetIcingaDataPath();
+
+ if (!binaryPrefix.IsEmpty() && !dataPrefix.IsEmpty()) {
+ Configuration::ProgramData = dataPrefix;
+
+ Configuration::ConfigDir = dataPrefix + "\\etc\\icinga2";
+
+ Configuration::DataDir = dataPrefix + "\\var\\lib\\icinga2";
+ Configuration::LogDir = dataPrefix + "\\var\\log\\icinga2";
+ Configuration::CacheDir = dataPrefix + "\\var\\cache\\icinga2";
+ Configuration::SpoolDir = dataPrefix + "\\var\\spool\\icinga2";
+
+ Configuration::PrefixDir = binaryPrefix;
+
+ /* Internal constants. */
+ Configuration::PkgDataDir = binaryPrefix + "\\share\\icinga2";
+ Configuration::IncludeConfDir = binaryPrefix + "\\share\\icinga2\\include";
+
+ Configuration::InitRunDir = dataPrefix + "\\var\\run\\icinga2";
+ } else {
+ Log(LogWarning, "icinga-app", "Registry key could not be read. Falling back to built-in paths.");
+
+#endif /* _WIN32 */
+ Configuration::ConfigDir = ICINGA_CONFIGDIR;
+
+ Configuration::DataDir = ICINGA_DATADIR;
+ Configuration::LogDir = ICINGA_LOGDIR;
+ Configuration::CacheDir = ICINGA_CACHEDIR;
+ Configuration::SpoolDir = ICINGA_SPOOLDIR;
+
+ Configuration::PrefixDir = ICINGA_PREFIX;
+
+ /* Internal constants. */
+ Configuration::PkgDataDir = ICINGA_PKGDATADIR;
+ Configuration::IncludeConfDir = ICINGA_INCLUDECONFDIR;
+
+ Configuration::InitRunDir = ICINGA_INITRUNDIR;
+
+#ifdef _WIN32
+ }
+#endif /* _WIN32 */
+
+ Configuration::ZonesDir = Configuration::ConfigDir + "/zones.d";
+
+ String icingaUser = Utility::GetFromEnvironment("ICINGA2_USER");
+ if (icingaUser.IsEmpty())
+ icingaUser = ICINGA_USER;
+
+ String icingaGroup = Utility::GetFromEnvironment("ICINGA2_GROUP");
+ if (icingaGroup.IsEmpty())
+ icingaGroup = ICINGA_GROUP;
+
+ Configuration::RunAsUser = icingaUser;
+ Configuration::RunAsGroup = icingaGroup;
+
+ if (!autocomplete) {
+#ifdef RLIMIT_NOFILE
+ String rLimitFiles = Utility::GetFromEnvironment("ICINGA2_RLIMIT_FILES");
+ if (rLimitFiles.IsEmpty())
+ Configuration::RLimitFiles = Application::GetDefaultRLimitFiles();
+ else {
+ try {
+ Configuration::RLimitFiles = Convert::ToLong(rLimitFiles);
+ } catch (const std::invalid_argument& ex) {
+ std::cout
+ << "Error setting \"ICINGA2_RLIMIT_FILES\": " << ex.what() << '\n';
+ return EXIT_FAILURE;
+ }
+ }
+#endif /* RLIMIT_NOFILE */
+
+#ifdef RLIMIT_NPROC
+ String rLimitProcesses = Utility::GetFromEnvironment("ICINGA2_RLIMIT_PROCESSES");
+ if (rLimitProcesses.IsEmpty())
+ Configuration::RLimitProcesses = Application::GetDefaultRLimitProcesses();
+ else {
+ try {
+ Configuration::RLimitProcesses = Convert::ToLong(rLimitProcesses);
+ } catch (const std::invalid_argument& ex) {
+ std::cout
+ << "Error setting \"ICINGA2_RLIMIT_PROCESSES\": " << ex.what() << '\n';
+ return EXIT_FAILURE;
+ }
+ }
+#endif /* RLIMIT_NPROC */
+
+#ifdef RLIMIT_STACK
+ String rLimitStack = Utility::GetFromEnvironment("ICINGA2_RLIMIT_STACK");
+ if (rLimitStack.IsEmpty())
+ Configuration::RLimitStack = Application::GetDefaultRLimitStack();
+ else {
+ try {
+ Configuration::RLimitStack = Convert::ToLong(rLimitStack);
+ } catch (const std::invalid_argument& ex) {
+ std::cout
+ << "Error setting \"ICINGA2_RLIMIT_STACK\": " << ex.what() << '\n';
+ return EXIT_FAILURE;
+ }
+ }
+#endif /* RLIMIT_STACK */
+ }
+
+ /* Calculate additional global constants. */
+ ScriptGlobal::Set("System.PlatformKernel", Utility::GetPlatformKernel(), true);
+ ScriptGlobal::Set("System.PlatformKernelVersion", Utility::GetPlatformKernelVersion(), true);
+ ScriptGlobal::Set("System.PlatformName", Utility::GetPlatformName(), true);
+ ScriptGlobal::Set("System.PlatformVersion", Utility::GetPlatformVersion(), true);
+ ScriptGlobal::Set("System.PlatformArchitecture", Utility::GetPlatformArchitecture(), true);
+
+ ScriptGlobal::Set("System.BuildHostName", ICINGA_BUILD_HOST_NAME, true);
+ ScriptGlobal::Set("System.BuildCompilerName", ICINGA_BUILD_COMPILER_NAME, true);
+ ScriptGlobal::Set("System.BuildCompilerVersion", ICINGA_BUILD_COMPILER_VERSION, true);
+
+ if (!autocomplete)
+ Application::SetResourceLimits();
+
+ LogSeverity logLevel = Logger::GetConsoleLogSeverity();
+ Logger::SetConsoleLogSeverity(LogWarning);
+
+ po::options_description visibleDesc("Global options");
+
+ visibleDesc.add_options()
+ ("help,h", "show this help message")
+ ("version,V", "show version information")
+#ifndef _WIN32
+ ("color", "use VT100 color codes even when stdout is not a terminal")
+#endif /* _WIN32 */
+ ("define,D", po::value<std::vector<std::string> >(), "define a constant")
+ ("include,I", po::value<std::vector<std::string> >(), "add include search directory")
+ ("log-level,x", po::value<std::string>(), "specify the log level for the console log.\n"
+ "The valid value is either debug, notice, information (default), warning, or critical")
+ ("script-debugger,X", "whether to enable the script debugger");
+
+ po::options_description hiddenDesc("Hidden options");
+
+ hiddenDesc.add_options()
+ ("no-stack-rlimit", "used internally, do not specify manually")
+ ("arg", po::value<std::vector<std::string> >(), "positional argument");
+
+ po::positional_options_description positionalDesc;
+ positionalDesc.add("arg", -1);
+
+ String cmdname;
+ CLICommand::Ptr command;
+ po::variables_map vm;
+
+ try {
+ CLICommand::ParseCommand(argc, argv, visibleDesc, hiddenDesc, positionalDesc,
+ vm, cmdname, command, autocomplete);
+ } catch (const std::exception& ex) {
+ Log(LogCritical, "icinga-app")
+ << "Error while parsing command-line options: " << ex.what();
+ return EXIT_FAILURE;
+ }
+
+#ifdef _WIN32
+ char username[UNLEN + 1];
+ DWORD usernameLen = UNLEN + 1;
+ GetUserName(username, &usernameLen);
+
+ std::ifstream userFile;
+
+ /* The implicit string assignment is needed for Windows builds. */
+ String configDir = Configuration::ConfigDir;
+ userFile.open(configDir + "/user");
+
+ if (userFile && command && !Application::IsProcessElevated()) {
+ std::string userLine;
+ if (std::getline(userFile, userLine)) {
+ userFile.close();
+
+ std::vector<std::string> strs;
+ boost::split(strs, userLine, boost::is_any_of("\\"));
+
+ if (username != strs[1] && command->GetImpersonationLevel() == ImpersonationLevel::ImpersonateIcinga
+ || command->GetImpersonationLevel() == ImpersonationLevel::ImpersonateRoot) {
+ TCHAR szPath[MAX_PATH];
+
+ if (GetModuleFileName(nullptr, szPath, ARRAYSIZE(szPath))) {
+ SHELLEXECUTEINFO sei = { sizeof(sei) };
+ sei.lpVerb = _T("runas");
+ sei.lpFile = "cmd.exe";
+ sei.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NOASYNC | SEE_MASK_FLAG_NO_UI;
+ sei.nShow = SW_SHOW;
+
+ std::stringstream parameters;
+
+ parameters << "/C " << "\"" << szPath << "\"" << " ";
+
+ for (int i = 1; i < argc; i++) {
+ if (i != 1)
+ parameters << " ";
+ parameters << argv[i];
+ }
+
+ parameters << " & SET exitcode=%errorlevel%";
+ parameters << " & pause";
+ parameters << " & EXIT /B %exitcode%";
+
+ std::string str = parameters.str();
+ LPCSTR cstr = str.c_str();
+
+ sei.lpParameters = cstr;
+
+ if (!ShellExecuteEx(&sei)) {
+ DWORD dwError = GetLastError();
+ if (dwError == ERROR_CANCELLED)
+ Application::Exit(0);
+ } else {
+ WaitForSingleObject(sei.hProcess, INFINITE);
+
+ DWORD exitCode;
+ GetExitCodeProcess(sei.hProcess, &exitCode);
+
+ CloseHandle(sei.hProcess);
+
+ Application::Exit(exitCode);
+ }
+ }
+ }
+ } else {
+ userFile.close();
+ }
+ }
+#endif /* _WIN32 */
+
+#ifndef _WIN32
+ if (vm.count("color")) {
+ Console::SetType(std::cout, Console_VT100);
+ Console::SetType(std::cerr, Console_VT100);
+ }
+#endif /* _WIN32 */
+
+ if (vm.count("define")) {
+ for (const String& define : vm["define"].as<std::vector<std::string> >()) {
+ String key, value;
+ size_t pos = define.FindFirstOf('=');
+ if (pos != String::NPos) {
+ key = define.SubStr(0, pos);
+ value = define.SubStr(pos + 1);
+ } else {
+ key = define;
+ value = "1";
+ }
+
+ std::vector<String> keyTokens = key.Split(".");
+
+ std::unique_ptr<Expression> expr;
+ std::unique_ptr<VariableExpression> varExpr{new VariableExpression(keyTokens[0], {}, DebugInfo())};
+ expr = std::move(varExpr);
+
+ for (size_t i = 1; i < keyTokens.size(); i++) {
+ std::unique_ptr<IndexerExpression> indexerExpr{new IndexerExpression(std::move(expr), MakeLiteral(keyTokens[i]))};
+ indexerExpr->SetOverrideFrozen();
+ expr = std::move(indexerExpr);
+ }
+
+ std::unique_ptr<SetExpression> setExpr{new SetExpression(std::move(expr), OpSetLiteral, MakeLiteral(value))};
+ setExpr->SetOverrideFrozen();
+
+ ScriptFrame frame(true);
+ setExpr->Evaluate(frame);
+ }
+ }
+
+ Configuration::SetReadOnly(true);
+
+ /* Ensure that all defined constants work in the way we expect them. */
+ HandleLegacyDefines();
+
+ if (vm.count("script-debugger"))
+ Application::SetScriptDebuggerEnabled(true);
+
+ Configuration::StatePath = Configuration::DataDir + "/icinga2.state";
+ Configuration::ModAttrPath = Configuration::DataDir + "/modified-attributes.conf";
+ Configuration::ObjectsPath = Configuration::CacheDir + "/icinga2.debug";
+ Configuration::VarsPath = Configuration::CacheDir + "/icinga2.vars";
+ Configuration::PidPath = Configuration::InitRunDir + "/icinga2.pid";
+
+ ConfigCompiler::AddIncludeSearchDir(Configuration::IncludeConfDir);
+
+ if (!autocomplete && vm.count("include")) {
+ for (const String& includePath : vm["include"].as<std::vector<std::string> >()) {
+ ConfigCompiler::AddIncludeSearchDir(includePath);
+ }
+ }
+
+ if (!autocomplete) {
+ Logger::SetConsoleLogSeverity(logLevel);
+
+ if (vm.count("log-level")) {
+ String severity = vm["log-level"].as<std::string>();
+
+ LogSeverity logLevel = LogInformation;
+ try {
+ logLevel = Logger::StringToSeverity(severity);
+ } catch (std::exception&) {
+ /* Inform user and exit */
+ Log(LogCritical, "icinga-app", "Invalid log level set. Default is 'information'.");
+ return EXIT_FAILURE;
+ }
+
+ Logger::SetConsoleLogSeverity(logLevel);
+ }
+
+ if (!command || vm.count("help") || vm.count("version")) {
+ String appName;
+
+ try {
+ appName = Utility::BaseName(Application::GetArgV()[0]);
+ } catch (const std::bad_alloc&) {
+ Log(LogCritical, "icinga-app", "Allocation failed.");
+ return EXIT_FAILURE;
+ }
+
+ if (appName.GetLength() > 3 && appName.SubStr(0, 3) == "lt-")
+ appName = appName.SubStr(3, appName.GetLength() - 3);
+
+ std::cout << appName << " " << "- The Icinga 2 network monitoring daemon (version: "
+ << ConsoleColorTag(vm.count("version") ? Console_ForegroundRed : Console_Normal)
+ << Application::GetAppVersion()
+#ifdef I2_DEBUG
+ << "; debug"
+#endif /* I2_DEBUG */
+ << ConsoleColorTag(Console_Normal)
+ << ")" << std::endl << std::endl;
+
+ if ((!command || vm.count("help")) && !vm.count("version")) {
+ std::cout << "Usage:" << std::endl
+ << " " << Utility::BaseName(argv[0]) << " ";
+
+ if (cmdname.IsEmpty())
+ std::cout << "<command>";
+ else
+ std::cout << cmdname;
+
+ std::cout << " [<arguments>]" << std::endl;
+
+ if (command) {
+ std::cout << std::endl
+ << command->GetDescription() << std::endl;
+ }
+ }
+
+ if (vm.count("version")) {
+ std::cout << "Copyright (c) 2012-" << Utility::FormatDateTime("%Y", Utility::GetTime())
+ << " Icinga GmbH (https://icinga.com/)" << std::endl
+ << "License GPLv2+: GNU GPL version 2 or later <https://gnu.org/licenses/gpl2.html>" << std::endl
+ << "This is free software: you are free to change and redistribute it." << std::endl
+ << "There is NO WARRANTY, to the extent permitted by law.";
+ }
+
+ std::cout << std::endl;
+
+ if (vm.count("version")) {
+ std::cout << std::endl;
+
+ Application::DisplayInfoMessage(std::cout, true);
+
+ return EXIT_SUCCESS;
+ }
+ }
+
+ if (!command || vm.count("help")) {
+ if (!command)
+ CLICommand::ShowCommands(argc, argv, nullptr);
+
+ std::cout << visibleDesc << std::endl
+ << "Report bugs at <https://github.com/Icinga/icinga2>" << std::endl
+ << "Get support: <https://icinga.com/support/>" << std::endl
+ << "Documentation: <https://icinga.com/docs/>" << std::endl
+ << "Icinga home page: <https://icinga.com/>" << std::endl;
+ return EXIT_SUCCESS;
+ }
+ }
+
+ int rc = 1;
+
+ if (autocomplete) {
+ CLICommand::ShowCommands(argc, argv, &visibleDesc, &hiddenDesc,
+ &GlobalArgumentCompletion, true, autoindex);
+ rc = 0;
+ } else if (command) {
+ Logger::DisableTimestamp();
+#ifndef _WIN32
+ if (command->GetImpersonationLevel() == ImpersonateRoot) {
+ if (getuid() != 0) {
+ Log(LogCritical, "cli", "This command must be run as root.");
+ return 0;
+ }
+ } else if (command && command->GetImpersonationLevel() == ImpersonateIcinga) {
+ String group = Configuration::RunAsGroup;
+ String user = Configuration::RunAsUser;
+
+ errno = 0;
+ struct group *gr = getgrnam(group.CStr());
+
+ if (!gr) {
+ if (errno == 0) {
+ Log(LogCritical, "cli")
+ << "Invalid group specified: " << group;
+ return EXIT_FAILURE;
+ } else {
+ Log(LogCritical, "cli")
+ << "getgrnam() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (getgid() != gr->gr_gid) {
+ if (!vm.count("reload-internal") && setgroups(0, nullptr) < 0) {
+ Log(LogCritical, "cli")
+ << "setgroups() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ Log(LogCritical, "cli")
+ << "Please re-run this command as a privileged user or using the \"" << user << "\" account.";
+ return EXIT_FAILURE;
+ }
+
+ if (setgid(gr->gr_gid) < 0) {
+ Log(LogCritical, "cli")
+ << "setgid() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ return EXIT_FAILURE;
+ }
+ }
+
+ errno = 0;
+ struct passwd *pw = getpwnam(user.CStr());
+
+ if (!pw) {
+ if (errno == 0) {
+ Log(LogCritical, "cli")
+ << "Invalid user specified: " << user;
+ return EXIT_FAILURE;
+ } else {
+ Log(LogCritical, "cli")
+ << "getpwnam() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ return EXIT_FAILURE;
+ }
+ }
+
+ // also activate the additional groups the configured user is member of
+ if (getuid() != pw->pw_uid) {
+ if (!vm.count("reload-internal") && initgroups(user.CStr(), pw->pw_gid) < 0) {
+ Log(LogCritical, "cli")
+ << "initgroups() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ Log(LogCritical, "cli")
+ << "Please re-run this command as a privileged user or using the \"" << user << "\" account.";
+ return EXIT_FAILURE;
+ }
+
+ if (setuid(pw->pw_uid) < 0) {
+ Log(LogCritical, "cli")
+ << "setuid() failed with error code " << errno << ", \"" << Utility::FormatErrorNumber(errno) << "\"";
+ Log(LogCritical, "cli")
+ << "Please re-run this command as a privileged user or using the \"" << user << "\" account.";
+ return EXIT_FAILURE;
+ }
+ }
+ }
+#endif /* _WIN32 */
+
+ std::vector<std::string> args;
+ if (vm.count("arg"))
+ args = vm["arg"].as<std::vector<std::string> >();
+
+ if (static_cast<int>(args.size()) < command->GetMinArguments()) {
+ Log(LogCritical, "cli")
+ << "Too few arguments. Command needs at least " << command->GetMinArguments()
+ << " argument" << (command->GetMinArguments() != 1 ? "s" : "") << ".";
+ return EXIT_FAILURE;
+ }
+
+ if (command->GetMaxArguments() >= 0 && static_cast<int>(args.size()) > command->GetMaxArguments()) {
+ Log(LogCritical, "cli")
+ << "Too many arguments. At most " << command->GetMaxArguments()
+ << " argument" << (command->GetMaxArguments() != 1 ? "s" : "") << " may be specified.";
+ return EXIT_FAILURE;
+ }
+
+ rc = command->Run(vm, args);
+ }
+
+ return rc;
+}
+
+#ifdef _WIN32
+static int SetupService(bool install, int argc, char **argv)
+{
+ SC_HANDLE schSCManager = OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
+
+ if (!schSCManager) {
+ printf("OpenSCManager failed (%d)\n", GetLastError());
+ return 1;
+ }
+
+ TCHAR szPath[MAX_PATH];
+
+ if (!GetModuleFileName(nullptr, szPath, MAX_PATH)) {
+ printf("Cannot install service (%d)\n", GetLastError());
+ return 1;
+ }
+
+ String szArgs;
+ szArgs = Utility::EscapeShellArg(szPath) + " --scm";
+
+ std::string scmUser = "NT AUTHORITY\\NetworkService";
+ std::ifstream initf(Utility::GetIcingaDataPath() + "\\etc\\icinga2\\user");
+ if (initf.good()) {
+ std::getline(initf, scmUser);
+ }
+ initf.close();
+
+ for (int i = 0; i < argc; i++) {
+ if (!strcmp(argv[i], "--scm-user") && i + 1 < argc) {
+ scmUser = argv[i + 1];
+ i++;
+ } else
+ szArgs += " " + Utility::EscapeShellArg(argv[i]);
+ }
+
+ SC_HANDLE schService = OpenService(schSCManager, "icinga2", SERVICE_ALL_ACCESS);
+
+ if (schService) {
+ SERVICE_STATUS status;
+ ControlService(schService, SERVICE_CONTROL_STOP, &status);
+
+ double start = Utility::GetTime();
+ while (status.dwCurrentState != SERVICE_STOPPED) {
+ double end = Utility::GetTime();
+
+ if (end - start > 30) {
+ printf("Could not stop the service.\n");
+ break;
+ }
+
+ Utility::Sleep(5);
+
+ if (!QueryServiceStatus(schService, &status)) {
+ printf("QueryServiceStatus failed (%d)\n", GetLastError());
+ return 1;
+ }
+ }
+ } else if (install) {
+ schService = CreateService(
+ schSCManager,
+ "icinga2",
+ "Icinga 2",
+ SERVICE_ALL_ACCESS,
+ SERVICE_WIN32_OWN_PROCESS,
+ SERVICE_DEMAND_START,
+ SERVICE_ERROR_NORMAL,
+ szArgs.CStr(),
+ nullptr,
+ nullptr,
+ nullptr,
+ scmUser.c_str(),
+ nullptr);
+
+ if (!schService) {
+ printf("CreateService failed (%d)\n", GetLastError());
+ CloseServiceHandle(schSCManager);
+ return 1;
+ }
+ } else {
+ printf("Service isn't installed.\n");
+ CloseServiceHandle(schSCManager);
+ return 0;
+ }
+
+ if (!install) {
+ if (!DeleteService(schService)) {
+ printf("DeleteService failed (%d)\n", GetLastError());
+ CloseServiceHandle(schService);
+ CloseServiceHandle(schSCManager);
+ return 1;
+ }
+
+ printf("Service uninstalled successfully\n");
+ } else {
+ if (!ChangeServiceConfig(schService, SERVICE_NO_CHANGE, SERVICE_AUTO_START,
+ SERVICE_ERROR_NORMAL, szArgs.CStr(), nullptr, nullptr, nullptr, scmUser.c_str(), nullptr, nullptr)) {
+ printf("ChangeServiceConfig failed (%d)\n", GetLastError());
+ CloseServiceHandle(schService);
+ CloseServiceHandle(schSCManager);
+ return 1;
+ }
+
+ SERVICE_DESCRIPTION sdDescription = { "The Icinga 2 monitoring application" };
+ if(!ChangeServiceConfig2(schService, SERVICE_CONFIG_DESCRIPTION, &sdDescription)) {
+ printf("ChangeServiceConfig2 failed (%d)\n", GetLastError());
+ CloseServiceHandle(schService);
+ CloseServiceHandle(schSCManager);
+ return 1;
+ }
+
+ if (!StartService(schService, 0, nullptr)) {
+ printf("StartService failed (%d)\n", GetLastError());
+ CloseServiceHandle(schService);
+ CloseServiceHandle(schSCManager);
+ return 1;
+ }
+
+ std::cout << "Service successfully installed for user '" << scmUser << "'\n";
+
+ String userFilePath = Utility::GetIcingaDataPath() + "\\etc\\icinga2\\user";
+
+ std::ofstream fuser(userFilePath.CStr(), std::ios::out | std::ios::trunc);
+ if (fuser)
+ fuser << scmUser;
+ else
+ std::cout << "Could not write user to " << userFilePath << "\n";
+ }
+
+ CloseServiceHandle(schService);
+ CloseServiceHandle(schSCManager);
+
+ return 0;
+}
+
+static VOID ReportSvcStatus(DWORD dwCurrentState,
+ DWORD dwWin32ExitCode,
+ DWORD dwWaitHint)
+{
+ static DWORD dwCheckPoint = 1;
+
+ l_SvcStatus.dwCurrentState = dwCurrentState;
+ l_SvcStatus.dwWin32ExitCode = dwWin32ExitCode;
+ l_SvcStatus.dwWaitHint = dwWaitHint;
+
+ if (dwCurrentState == SERVICE_START_PENDING)
+ l_SvcStatus.dwControlsAccepted = 0;
+ else
+ l_SvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
+
+ if ((dwCurrentState == SERVICE_RUNNING) ||
+ (dwCurrentState == SERVICE_STOPPED))
+ l_SvcStatus.dwCheckPoint = 0;
+ else
+ l_SvcStatus.dwCheckPoint = dwCheckPoint++;
+
+ SetServiceStatus(l_SvcStatusHandle, &l_SvcStatus);
+}
+
+static VOID WINAPI ServiceControlHandler(DWORD dwCtrl)
+{
+ if (dwCtrl == SERVICE_CONTROL_STOP) {
+ ReportSvcStatus(SERVICE_STOP_PENDING, NO_ERROR, 0);
+ TerminateJobObject(l_Job, 0);
+ }
+}
+
+static VOID WINAPI ServiceMain(DWORD argc, LPSTR *argv)
+{
+ l_SvcStatusHandle = RegisterServiceCtrlHandler(
+ "icinga2",
+ ServiceControlHandler);
+
+ l_SvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+ l_SvcStatus.dwServiceSpecificExitCode = 0;
+
+ ReportSvcStatus(SERVICE_RUNNING, NO_ERROR, 0);
+ l_Job = CreateJobObject(nullptr, nullptr);
+
+ for (;;) {
+ LPSTR arg = argv[0];
+ String args;
+ int uargc = Application::GetArgC();
+ char **uargv = Application::GetArgV();
+
+ args += Utility::EscapeShellArg(Application::GetExePath(uargv[0]));
+
+ for (int i = 2; i < uargc && uargv[i]; i++) {
+ if (args != "")
+ args += " ";
+
+ args += Utility::EscapeShellArg(uargv[i]);
+ }
+
+ STARTUPINFO si = { sizeof(si) };
+ PROCESS_INFORMATION pi;
+
+ char *uargs = strdup(args.CStr());
+
+ BOOL res = CreateProcess(nullptr, uargs, nullptr, nullptr, FALSE, 0, nullptr, nullptr, &si, &pi);
+
+ free(uargs);
+
+ if (!res)
+ break;
+
+ CloseHandle(pi.hThread);
+
+ AssignProcessToJobObject(l_Job, pi.hProcess);
+
+ if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_OBJECT_0)
+ break;
+
+ DWORD exitStatus;
+
+ if (!GetExitCodeProcess(pi.hProcess, &exitStatus))
+ break;
+
+ if (exitStatus != 7)
+ break;
+ }
+
+ TerminateJobObject(l_Job, 0);
+
+ CloseHandle(l_Job);
+
+ ReportSvcStatus(SERVICE_STOPPED, NO_ERROR, 0);
+
+ Application::Exit(0);
+}
+#endif /* _WIN32 */
+
+/**
+* Entry point for the Icinga application.
+*
+* @params argc Number of command line arguments.
+* @params argv Command line arguments.
+* @returns The application's exit status.
+*/
+int main(int argc, char **argv)
+{
+#ifndef _WIN32
+ String keepFDs = Utility::GetFromEnvironment("ICINGA2_KEEP_FDS");
+ if (keepFDs.IsEmpty()) {
+#ifdef I2_DEBUG
+ Utility::CloseAllFDs({0, 1, 2}, [](int fd) {
+ std::cerr << "Closed FD " << fd << " which we inherited from our parent process." << std::endl;
+ });
+#else /* I2_DEBUG */
+ Utility::CloseAllFDs({0, 1, 2});
+#endif /* I2_DEBUG */
+ }
+#endif /* _WIN32 */
+
+ /* must be called before using any other libbase functions */
+ Application::InitializeBase();
+
+ /* Set command-line arguments. */
+ Application::SetArgC(argc);
+ Application::SetArgV(argv);
+
+#ifdef _WIN32
+ if (argc > 1 && strcmp(argv[1], "--scm-install") == 0) {
+ return SetupService(true, argc - 2, &argv[2]);
+ }
+
+ if (argc > 1 && strcmp(argv[1], "--scm-uninstall") == 0) {
+ return SetupService(false, argc - 2, &argv[2]);
+ }
+
+ if (argc > 1 && strcmp(argv[1], "--scm") == 0) {
+ SERVICE_TABLE_ENTRY dispatchTable[] = {
+ { "icinga2", ServiceMain },
+ { nullptr, nullptr }
+ };
+
+ StartServiceCtrlDispatcher(dispatchTable);
+ Application::Exit(EXIT_FAILURE);
+ }
+#endif /* _WIN32 */
+
+ int rc = Main();
+
+ Application::Exit(rc);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 18:32:13 +0000