mirror of https://github.com/Icinga/icinga2.git
308 lines
10 KiB
C++
308 lines
10 KiB
C++
/******************************************************************************
|
|
* Icinga 2 *
|
|
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU General Public License *
|
|
* as published by the Free Software Foundation; either version 2 *
|
|
* of the License, or (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the Free Software Foundation *
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
|
|
******************************************************************************/
|
|
|
|
#include "remote/configmoduleutility.hpp"
|
|
#include "base/application.hpp"
|
|
#include "base/exception.hpp"
|
|
#include "base/scriptglobal.hpp"
|
|
#include "base/utility.hpp"
|
|
#include "boost/foreach.hpp"
|
|
#include <boost/algorithm/string.hpp>
|
|
#include <boost/regex.hpp>
|
|
#include <algorithm>
|
|
#include <fstream>
|
|
|
|
using namespace icinga;
|
|
|
|
String ConfigModuleUtility::GetModuleDir(void)
|
|
{
|
|
return Application::GetLocalStateDir() + "/lib/icinga2/api/modules";
|
|
}
|
|
|
|
void ConfigModuleUtility::CreateModule(const String& name)
|
|
{
|
|
String path = GetModuleDir() + "/" + name;
|
|
|
|
if (Utility::PathExists(path))
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Module already exists."));
|
|
|
|
Utility::MkDirP(path, 0700);
|
|
WriteModuleConfig(name);
|
|
}
|
|
|
|
void ConfigModuleUtility::DeleteModule(const String& name)
|
|
{
|
|
String path = GetModuleDir() + "/" + name;
|
|
|
|
if (!Utility::PathExists(path))
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Module does not exist."));
|
|
|
|
Utility::RemoveDirRecursive(path);
|
|
Application::RequestRestart();
|
|
}
|
|
|
|
std::vector<String> ConfigModuleUtility::GetModules(void)
|
|
{
|
|
std::vector<String> modules;
|
|
Utility::Glob(GetModuleDir() + "/*", boost::bind(&ConfigModuleUtility::CollectDirNames, _1, boost::ref(modules)), GlobDirectory);
|
|
return modules;
|
|
}
|
|
|
|
void ConfigModuleUtility::CollectDirNames(const String& path, std::vector<String>& dirs)
|
|
{
|
|
String name = Utility::BaseName(path);
|
|
dirs.push_back(name);
|
|
}
|
|
|
|
String ConfigModuleUtility::CreateStage(const String& moduleName, const Dictionary::Ptr& files)
|
|
{
|
|
String stageName = Utility::NewUniqueID();
|
|
|
|
String path = GetModuleDir() + "/" + moduleName;
|
|
|
|
if (!Utility::PathExists(path))
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Module does not exist."));
|
|
|
|
path += "/" + stageName;
|
|
|
|
Utility::MkDirP(path, 0700);
|
|
WriteStageConfig(moduleName, stageName);
|
|
|
|
bool foundDotDot = false;
|
|
ObjectLock olock(files);
|
|
BOOST_FOREACH(const Dictionary::Pair& kv, files) {
|
|
if (ContainsDotDot(kv.first)) {
|
|
foundDotDot = true;
|
|
break;
|
|
}
|
|
|
|
String filePath = path + "/" + kv.first;
|
|
|
|
Log(LogInformation, "ConfigModuleUtility")
|
|
<< "Updating configuration file: " << filePath;
|
|
|
|
//pass the directory and generate a dir tree, if not existing already
|
|
Utility::MkDirP(Utility::DirName(filePath), 0750);
|
|
std::ofstream fp(filePath.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fp << kv.second;
|
|
fp.close();
|
|
}
|
|
|
|
if (foundDotDot) {
|
|
Utility::RemoveDirRecursive(path);
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Path must not contain '..'."));
|
|
}
|
|
|
|
return stageName;
|
|
}
|
|
|
|
void ConfigModuleUtility::WriteModuleConfig(const String& moduleName)
|
|
{
|
|
String stageName = GetActiveStage(moduleName);
|
|
|
|
String includePath = GetModuleDir() + "/" + moduleName + "/include.conf";
|
|
std::ofstream fpInclude(includePath.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fpInclude << "include \"*/include.conf\"\n";
|
|
fpInclude.close();
|
|
|
|
String activePath = GetModuleDir() + "/" + moduleName + "/active.conf";
|
|
std::ofstream fpActive(activePath.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fpActive << "if (!globals.contains(\"ActiveStages\")) {\n"
|
|
<< " globals.ActiveStages = {}\n"
|
|
<< "}\n"
|
|
<< "\n"
|
|
<< "if (globals.contains(\"ActiveStageOverride\")) {\n"
|
|
<< " var arr = ActiveStageOverride.split(\":\")\n"
|
|
<< " if (arr[0] == \"" << moduleName << "\") {\n"
|
|
<< " if (arr.len() < 2) {\n"
|
|
<< " log(LogCritical, \"Config\", \"Invalid value for ActiveStageOverride\")\n"
|
|
<< " } else {\n"
|
|
<< " ActiveStages[\"" << moduleName << "\"] = arr[1]\n"
|
|
<< " }\n"
|
|
<< " }\n"
|
|
<< "}\n"
|
|
<< "\n"
|
|
<< "if (!ActiveStages.contains(\"" << moduleName << "\")) {\n"
|
|
<< " ActiveStages[\"" << moduleName << "\"] = \"" << stageName << "\"\n"
|
|
<< "}\n";
|
|
fpActive.close();
|
|
}
|
|
|
|
void ConfigModuleUtility::WriteStageConfig(const String& moduleName, const String& stageName)
|
|
{
|
|
String path = GetModuleDir() + "/" + moduleName + "/" + stageName + "/include.conf";
|
|
std::ofstream fp(path.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fp << "include \"../active.conf\"\n"
|
|
<< "if (ActiveStages[\"" << moduleName << "\"] == \"" << stageName << "\") {\n"
|
|
<< " include_recursive \"conf.d\"\n"
|
|
<< " include_zones \"" << moduleName << "\", \"zones.d\"\n"
|
|
<< "}\n";
|
|
fp.close();
|
|
}
|
|
|
|
void ConfigModuleUtility::ActivateStage(const String& moduleName, const String& stageName)
|
|
{
|
|
String activeStagePath = GetModuleDir() + "/" + moduleName + "/active-stage";
|
|
std::ofstream fpActiveStage(activeStagePath.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fpActiveStage << stageName;
|
|
fpActiveStage.close();
|
|
|
|
WriteModuleConfig(moduleName);
|
|
}
|
|
|
|
void ConfigModuleUtility::TryActivateStageCallback(const ProcessResult& pr, const String& moduleName, const String& stageName)
|
|
{
|
|
String logFile = GetModuleDir() + "/" + moduleName + "/" + stageName + "/startup.log";
|
|
std::ofstream fpLog(logFile.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fpLog << pr.Output;
|
|
fpLog.close();
|
|
|
|
String statusFile = GetModuleDir() + "/" + moduleName + "/" + stageName + "/status";
|
|
std::ofstream fpStatus(statusFile.CStr(), std::ofstream::out | std::ostream::binary | std::ostream::trunc);
|
|
fpStatus << pr.ExitStatus;
|
|
fpStatus.close();
|
|
|
|
/* validation went fine, activate stage and reload */
|
|
if (pr.ExitStatus == 0) {
|
|
ActivateStage(moduleName, stageName);
|
|
Application::RequestRestart();
|
|
} else {
|
|
Log(LogCritical, "ConfigModuleUtility")
|
|
<< "Config validation failed for module '"
|
|
<< moduleName << "' and stage '" << stageName << "'.";
|
|
}
|
|
}
|
|
|
|
void ConfigModuleUtility::AsyncTryActivateStage(const String& moduleName, const String& stageName)
|
|
{
|
|
// prepare arguments
|
|
Array::Ptr args = new Array();
|
|
args->Add(Application::GetExePath("icinga2"));
|
|
args->Add("daemon");
|
|
args->Add("--validate");
|
|
args->Add("--define");
|
|
args->Add("ActiveStageOverride=" + moduleName + ":" + stageName);
|
|
|
|
Process::Ptr process = new Process(Process::PrepareCommand(args));
|
|
process->SetTimeout(300);
|
|
process->Run(boost::bind(&TryActivateStageCallback, _1, moduleName, stageName));
|
|
}
|
|
|
|
void ConfigModuleUtility::DeleteStage(const String& moduleName, const String& stageName)
|
|
{
|
|
String path = GetModuleDir() + "/" + moduleName + "/" + stageName;
|
|
|
|
if (!Utility::PathExists(path))
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Stage does not exist."));
|
|
|
|
if (GetActiveStage(moduleName) == stageName)
|
|
BOOST_THROW_EXCEPTION(std::invalid_argument("Active stage cannot be deleted."));
|
|
|
|
Utility::RemoveDirRecursive(path);
|
|
}
|
|
|
|
std::vector<String> ConfigModuleUtility::GetStages(const String& moduleName)
|
|
{
|
|
std::vector<String> stages;
|
|
Utility::Glob(GetModuleDir() + "/" + moduleName + "/*", boost::bind(&ConfigModuleUtility::CollectDirNames, _1, boost::ref(stages)), GlobDirectory);
|
|
return stages;
|
|
}
|
|
|
|
String ConfigModuleUtility::GetActiveStage(const String& moduleName)
|
|
{
|
|
String path = GetModuleDir() + "/" + moduleName + "/active-stage";
|
|
|
|
std::ifstream fp;
|
|
fp.open(path.CStr());
|
|
|
|
String stage;
|
|
std::getline(fp, stage.GetData());
|
|
stage.Trim();
|
|
|
|
fp.close();
|
|
|
|
if (fp.fail())
|
|
return "";
|
|
|
|
return stage;
|
|
}
|
|
|
|
|
|
std::vector<std::pair<String, bool> > ConfigModuleUtility::GetFiles(const String& moduleName, const String& stageName)
|
|
{
|
|
std::vector<std::pair<String, bool> > paths;
|
|
Utility::GlobRecursive(GetModuleDir() + "/" + moduleName + "/" + stageName, "*", boost::bind(&ConfigModuleUtility::CollectPaths, _1, boost::ref(paths)), GlobDirectory | GlobFile);
|
|
|
|
return paths;
|
|
}
|
|
|
|
void ConfigModuleUtility::CollectPaths(const String& path, std::vector<std::pair<String, bool> >& paths)
|
|
{
|
|
#ifndef _WIN32
|
|
struct stat statbuf;
|
|
int rc = lstat(path.CStr(), &statbuf);
|
|
if (rc < 0)
|
|
BOOST_THROW_EXCEPTION(posix_error()
|
|
<< boost::errinfo_api_function("lstat")
|
|
<< boost::errinfo_errno(errno)
|
|
<< boost::errinfo_file_name(path));
|
|
|
|
paths.push_back(std::make_pair(path, S_ISDIR(statbuf.st_mode)));
|
|
#else /* _WIN32 */
|
|
struct _stat statbuf;
|
|
int rc = _stat(path.CStr(), &statbuf);
|
|
if (rc < 0)
|
|
BOOST_THROW_EXCEPTION(posix_error()
|
|
<< boost::errinfo_api_function("_stat")
|
|
<< boost::errinfo_errno(errno)
|
|
<< boost::errinfo_file_name(path));
|
|
|
|
paths.push_back(std::make_pair(path, ((statbuf.st_mode & S_IFMT) == S_IFDIR)));
|
|
#endif /* _WIN32 */
|
|
}
|
|
|
|
bool ConfigModuleUtility::ContainsDotDot(const String& path)
|
|
{
|
|
std::vector<String> tokens;
|
|
boost::algorithm::split(tokens, path, boost::is_any_of("/\\"));
|
|
|
|
BOOST_FOREACH(const String& part, tokens) {
|
|
if (part == "..")
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ConfigModuleUtility::ValidateName(const String& name)
|
|
{
|
|
if (name.IsEmpty())
|
|
return false;
|
|
|
|
/* check for path injection */
|
|
if (ContainsDotDot(name))
|
|
return false;
|
|
|
|
boost::regex expr("^[^a-zA-Z0-9_\\-]*$", boost::regex::icase);
|
|
boost::smatch what;
|
|
return (!boost::regex_search(name.GetData(), what, expr));
|
|
}
|
|
|
|
|