bsc::rule::Operator Struct Reference

#include <Rule.hpp>

Public Member Functions
bool	matches (const bsc::model::Connection &conn) const

Public Attributes
OperatorType	type {OperatorType::Unknown}
std::string	operand
std::string	data
bool	sensitive {false}
std::vector< Operator >	list

Detailed Description

Definition at line 13 of file Rule.hpp.

Member Function Documentation

matches()

bool bsc::rule::Operator::matches ( const bsc::model::Connection & conn ) const

nodiscard

Definition at line 230 of file Rule.cpp.

                                                           {
    const auto op = normalize_operand(operand);
    if (op == "true") return true;
    if (type == OperatorType::List || op == "list") {
        if (list.empty()) return true;
        for (const auto& child : list) if (!child.matches(conn)) return false;
        return true;
    }
    const auto values = field_values(conn, op);
    auto str_matches = [&](const std::string& value) -> bool {
        switch (type) {
            case OperatorType::Simple:
                return sensitive ? value == data : to_lower(value) == to_lower(data);
            case OperatorType::Regexp:
                try {
                    return std::regex_search(value, std::regex(data, sensitive ? std::regex::ECMAScript : (std::regex::ECMAScript | std::regex::icase)));
                } catch (...) { return false; }
            case OperatorType::Network:
                if (const auto it = g_aliases.find(data); it != g_aliases.end()) { for (const auto& cidr : it->second) if (ip_in_cidr(value, cidr)) return true; return false; }
                return ip_in_cidr(value, data);
            case OperatorType::Range: {
                const auto range = parse_range(data);
                if (!range) return false;
                unsigned long long n = 0;
                auto [p, ec] = std::from_chars(value.data(), value.data() + value.size(), n);
                return ec == std::errc{} && n >= range->first && n <= range->second;
            }
            case OperatorType::Lists: {
                namespace fs = std::filesystem;
                std::error_code ec;
                if (!fs::exists(data, ec)) return false;
                const auto is_domain_regex = op == "lists.domains_regexp";
                const auto is_nets = op == "lists.nets";
                auto match_file = [&](const fs::path& p) {
                    std::ifstream in(p);
                    std::string line;
                    while (std::getline(in, line)) {
                        line = trim(line);
                        if (line.empty() || line[0] == '#') continue;
                        if (is_nets) { if (ip_in_cidr(value, line)) return true; continue; }
                        if (is_domain_regex) { try { if (std::regex_search(value, std::regex(line, sensitive ? std::regex::ECMAScript : (std::regex::ECMAScript | std::regex::icase)))) return true; } catch (...) {} continue; }
                        auto cmp = sensitive ? line : to_lower(line);
                        auto vv = sensitive ? value : to_lower(value);
                        if (op == "lists.domains" && vv.size() >= cmp.size()) { if (vv == cmp || (vv.size() > cmp.size() && vv.ends_with('.' + cmp))) return true; }
                        else if (cmp == vv) return true;
                    }
                    return false;
                };
                if (fs::is_regular_file(data, ec)) return match_file(data);
                for (const auto& entry : fs::directory_iterator(data, ec)) if (entry.is_regular_file() && match_file(entry.path())) return true;
                return false;
            }
            default:
                return false;
        }
    };
    for (const auto& value : values) if (str_matches(value)) return true;
    return false;
}

References data, bsc::rule::List, list, bsc::rule::Lists, bsc::rule::Network, operand, bsc::rule::Range, bsc::rule::Regexp, sensitive, bsc::rule::Simple, and type.

Referenced by bsc::rule::Rule::matches().

Member Data Documentation

data

std::string bsc::rule::Operator::data

Definition at line 16 of file Rule.hpp.

Referenced by matches(), bsc::ui::anonymous_namespace{UIClient.cpp}::operator_from_json(), bsc::rule::anonymous_namespace{Rule.cpp}::parse_operator(), bsc::service::DaemonService::persist_learned_rule(), and bsc::rule::anonymous_namespace{Rule.cpp}::to_json_op().

list

std::vector<Operator> bsc::rule::Operator::list

Definition at line 18 of file Rule.hpp.

Referenced by matches(), bsc::ui::anonymous_namespace{UIClient.cpp}::operator_from_json(), bsc::rule::anonymous_namespace{Rule.cpp}::parse_operator(), bsc::service::DaemonService::persist_learned_rule(), and bsc::rule::anonymous_namespace{Rule.cpp}::to_json_op().

operand

std::string bsc::rule::Operator::operand

Definition at line 15 of file Rule.hpp.

Referenced by matches(), bsc::ui::anonymous_namespace{UIClient.cpp}::operator_from_json(), bsc::rule::anonymous_namespace{Rule.cpp}::parse_operator(), bsc::service::DaemonService::persist_learned_rule(), and bsc::rule::anonymous_namespace{Rule.cpp}::to_json_op().

sensitive

bool bsc::rule::Operator::sensitive {false}

Definition at line 17 of file Rule.hpp.

Referenced by matches(), bsc::ui::anonymous_namespace{UIClient.cpp}::operator_from_json(), bsc::rule::anonymous_namespace{Rule.cpp}::parse_operator(), and bsc::rule::anonymous_namespace{Rule.cpp}::to_json_op().

type

OperatorType bsc::rule::Operator::type {OperatorType::Unknown}

Definition at line 14 of file Rule.hpp.

Referenced by matches(), bsc::ui::anonymous_namespace{UIClient.cpp}::operator_from_json(), bsc::rule::anonymous_namespace{Rule.cpp}::parse_operator(), bsc::service::DaemonService::persist_learned_rule(), and bsc::rule::anonymous_namespace{Rule.cpp}::to_json_op().

---

The documentation for this struct 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