bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp} Namespace Reference

Classes
struct	CommandResult

Functions
bool	executableExists (const char *path) noexcept
std::string	firstExecutable (std::initializer_list< const char * > candidates)
CommandResult	runCommand (const std::vector< std::string > &arguments) noexcept
bool	startsWithPath (const std::filesystem::path &path, const std::filesystem::path &prefix) noexcept
bool	isSystemdUnitExtension (const std::string &extension)
std::optional< std::string >	systemdUnitName (const std::filesystem::path &path)
ServiceActionResult	resultFrom (const std::string &operation, const ServiceTarget &target, const std::vector< CommandResult > &results)

Function Documentation

executableExists()

bool bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::executableExists ( const char * path )

noexcept

Definition at line 21 of file SystemServiceControl.cpp.

{
    return path && ::access(path, X_OK) == 0;
}

References executableExists().

Referenced by executableExists(), and firstExecutable().

firstExecutable()

std::string bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::firstExecutable

(

std::initializer_list< const char * >

candidates

)

Definition at line 26 of file SystemServiceControl.cpp.

{
    for (const char* candidate : candidates) {
        if (executableExists(candidate))
            return candidate;
    }
    return {};
}

References executableExists(), and firstExecutable().

Referenced by firstExecutable().

isSystemdUnitExtension()

bool bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::isSystemdUnitExtension

(

const std::string &

extension

)

Definition at line 105 of file SystemServiceControl.cpp.

{
    return extension == ".service" || extension == ".socket" ||
           extension == ".timer" || extension == ".path" ||
           extension == ".mount" || extension == ".automount" ||
           extension == ".target";
}

References isSystemdUnitExtension().

Referenced by isSystemdUnitExtension(), and systemdUnitName().

resultFrom()

ServiceActionResult bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::resultFrom	(	const std::string &	operation,
		const ServiceTarget &	target,
		const std::vector< CommandResult > &	results )

Definition at line 130 of file SystemServiceControl.cpp.

{
    bool success = true;
    std::ostringstream message;
    message << operation << " " << target.name << " using " << toString(target.init);
    for (const auto& result : results) {
        if (result.exitCode != 0)
            success = false;
        if (!result.output.empty())
            message << ": " << result.output;
    }
    return {success, message.str()};
}

References bastionguard::rootguard::ServiceTarget::init, bastionguard::rootguard::ServiceTarget::name, resultFrom(), and bastionguard::rootguard::toString().

Referenced by resultFrom().

runCommand()

CommandResult bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::runCommand ( const std::vector< std::string > & arguments )

noexcept

Definition at line 35 of file SystemServiceControl.cpp.

{
    CommandResult result;
    if (arguments.empty())
        return result;
 
    int descriptors[2]{};
    if (::pipe(descriptors) != 0)
        return result;
 
    const pid_t child = ::fork();
    if (child < 0) {
        ::close(descriptors[0]);
        ::close(descriptors[1]);
        return result;
    }
 
    if (child == 0) {
        ::close(descriptors[0]);
        ::dup2(descriptors[1], STDOUT_FILENO);
        ::dup2(descriptors[1], STDERR_FILENO);
        ::close(descriptors[1]);
 
        std::vector<char*> argv;
        argv.reserve(arguments.size() + 1);
        for (const auto& argument : arguments)
            argv.push_back(const_cast<char*>(argument.c_str()));
        argv.push_back(nullptr);
        ::execv(argv.front(), argv.data());
        _exit(127);
    }
 
    ::close(descriptors[1]);
    std::array<char, 2048> buffer{};
    for (;;) {
        const ssize_t count = ::read(descriptors[0], buffer.data(), buffer.size());
        if (count > 0) {
            result.output.append(buffer.data(), static_cast<std::size_t>(count));
            continue;
        }
        if (count < 0 && errno == EINTR)
            continue;
        break;
    }
    ::close(descriptors[0]);
 
    int status = 0;
    while (::waitpid(child, &status, 0) < 0 && errno == EINTR) {
    }
    if (WIFEXITED(status))
        result.exitCode = WEXITSTATUS(status);
    else if (WIFSIGNALED(status))
        result.exitCode = 128 + WTERMSIG(status);
    return result;
}

References bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::CommandResult::exitCode, bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::CommandResult::output, and runCommand().

Referenced by runCommand().

startsWithPath()

bool bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::startsWithPath ( const std::filesystem::path & path, const std::filesystem::path & prefix )

noexcept

Definition at line 91 of file SystemServiceControl.cpp.

{
    const auto normalizedPath = path.lexically_normal();
    const auto normalizedPrefix = prefix.lexically_normal();
    auto pathIt = normalizedPath.begin();
    for (auto prefixIt = normalizedPrefix.begin();
         prefixIt != normalizedPrefix.end(); ++prefixIt, ++pathIt) {
        if (pathIt == normalizedPath.end() || *pathIt != *prefixIt)
            return false;
    }
    return true;
}

References startsWithPath().

Referenced by startsWithPath().

systemdUnitName()

std::optional< std::string > bastionguard::rootguard::anonymous_namespace{SystemServiceControl.cpp}::systemdUnitName

(

const std::filesystem::path &

path

)

Definition at line 113 of file SystemServiceControl.cpp.

{
    if (isSystemdUnitExtension(path.extension().string()))
        return path.filename().string();
 
    for (auto current = path.parent_path(); !current.empty() && current != current.root_path();
         current = current.parent_path()) {
        const std::string name = current.filename().string();
        if (name.size() > 2 && name.compare(name.size() - 2, 2, ".d") == 0) {
            const std::string unit = name.substr(0, name.size() - 2);
            if (isSystemdUnitExtension(std::filesystem::path(unit).extension().string()))
                return unit;
        }
    }
    return std::nullopt;
}

References isSystemdUnitExtension(), and systemdUnitName().

Referenced by systemdUnitName().