bsc::rule::Loader Class Reference

#include <Rule.hpp>

Public Member Functions
void	load_aliases (const std::string &path)
void	load_directory (const std::string &dir)
bool	save_rule (const Rule &rule, const std::string &dir) const
const std::vector< Rule > &	rules () const noexcept
std::optional< Rule >	find_match (const bsc::model::Connection &conn) const

Private Attributes
std::vector< Rule >	rules_
std::map< std::string, std::vector< std::string > >	aliases_

Detailed Description

Definition at line 37 of file Rule.hpp.

Member Function Documentation

find_match()

std::optional< Rule > bsc::rule::Loader::find_match ( const bsc::model::Connection & conn ) const

nodiscard

Definition at line 358 of file Rule.cpp.

                                                                         {
    for (const auto& r : rules_) if (r.matches(conn)) return r;
    return std::nullopt;
}

References rules_.

load_aliases()

void bsc::rule::Loader::load_aliases

(

const std::string &

path

)

Definition at line 292 of file Rule.cpp.

                                               {
    aliases_.clear();
    g_aliases.clear();
    if (path.empty()) return;
    std::ifstream in(path);
    if (!in) return;
    try {
        json j; in >> j;
        if (!j.is_object()) return;
        for (auto it = j.begin(); it != j.end(); ++it) {
            if (!it.value().is_array()) continue;
            std::vector<std::string> vals;
            for (const auto& item : it.value()) if (item.is_string()) vals.push_back(item.get<std::string>());
            aliases_[it.key()] = vals;
            g_aliases[it.key()] = std::move(vals);
        }
    } catch (...) {}
}

References aliases_.

Referenced by bsc::service::DaemonService::DaemonService().

load_directory()

void bsc::rule::Loader::load_directory

(

const std::string &

dir

)

Definition at line 311 of file Rule.cpp.

                                                {
    rules_.clear();
    std::error_code ec;
    if (!fs::exists(dir, ec)) return;
    for (const auto& entry : fs::directory_iterator(dir, ec)) {
        if (!entry.is_regular_file() || entry.path().extension() != ".json") continue;
        std::ifstream in(entry.path());
        if (!in) continue;
        json j; in >> j;
        Rule r;
        if (j.contains("created")) {
            if (j["created"].is_number_integer()) r.created = j["created"].get<std::int64_t>();
            else r.created = static_cast<std::int64_t>(std::chrono::duration_cast<std::chrono::seconds>(std::chrono::file_clock::to_sys(fs::last_write_time(entry.path())).time_since_epoch()).count());
        }
        r.name = j.value("name", entry.path().stem().string());
        r.description = j.value("description", "");
        r.enabled = j.value("enabled", true);
        r.precedence = j.value("precedence", false);
        r.nolog = j.value("nolog", false);
        r.action = j.value("action", "allow");
        r.duration = j.value("duration", "once");
        if (j.contains("operator")) r.op = parse_operator(j["operator"]);
        rules_.push_back(std::move(r));
    }
    std::sort(rules_.begin(), rules_.end(), [](const Rule& a, const Rule& b) {
        if (a.precedence != b.precedence) return a.precedence > b.precedence;
        if (a.created != b.created) return a.created < b.created;
        return a.name < b.name;
    });
}

References rules_.

Referenced by bsc::service::DaemonService::DaemonService().

rules()

const std::vector< Rule > & bsc::rule::Loader::rules ( ) const

inlinenodiscardnoexcept

Definition at line 42 of file Rule.hpp.

{ return rules_; }

References rules_.

save_rule()

bool bsc::rule::Loader::save_rule	(	const Rule &	rule,
		const std::string &	dir ) const

Definition at line 342 of file Rule.cpp.

                                                                   {
    std::error_code ec;
    fs::create_directories(dir, ec);
    if (ec) return false;
    auto safe_name = rule.name;
    for (char& c : safe_name) if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '-' || c == '_' || c == '.')) c = '_';
    const auto path = fs::path(dir) / (safe_name + ".json");
    json j{{"created", rule.created}, {"name", rule.name}, {"description", rule.description}, {"enabled", rule.enabled},
           {"precedence", rule.precedence}, {"nolog", rule.nolog}, {"action", rule.action}, {"duration", rule.duration},
           {"operator", to_json_op(rule.op)}};
    std::ofstream out(path);
    if (!out) return false;
    out << j.dump(2) << '\n';
    return true;
}

Member Data Documentation

aliases_

std::map<std::string, std::vector<std::string> > bsc::rule::Loader::aliases_

private

Definition at line 46 of file Rule.hpp.

Referenced by load_aliases().

rules_

std::vector<Rule> bsc::rule::Loader::rules_

private

Definition at line 45 of file Rule.hpp.

Referenced by find_match(), load_directory(), and rules().

---

The documentation for this class was generated from the following files:

• BastionGuard/thirdparty/bastionguard-secure-connection/daemon/include/bsc/rule/Rule.hpp
• BastionGuard/thirdparty/bastionguard-secure-connection/daemon/src/rule/Rule.cpp