Rename parameter to raw_configuration

cmake/objects.cmake

@@ -1,6 +1,5 @@
 set(LIBDDWAF_SOURCE
     ${libddwaf_SOURCE_DIR}/src/clock.cpp
-    ${libddwaf_SOURCE_DIR}/src/parameter.cpp
     ${libddwaf_SOURCE_DIR}/src/interface.cpp
     ${libddwaf_SOURCE_DIR}/src/context.cpp
     ${libddwaf_SOURCE_DIR}/src/context_allocator.cpp
@@ -37,6 +36,7 @@ set(LIBDDWAF_SOURCE
     ${libddwaf_SOURCE_DIR}/src/configuration/common/expression_parser.cpp
     ${libddwaf_SOURCE_DIR}/src/configuration/common/matcher_parser.cpp
     ${libddwaf_SOURCE_DIR}/src/configuration/common/transformer_parser.cpp
+    ${libddwaf_SOURCE_DIR}/src/configuration/common/raw_configuration.cpp
     ${libddwaf_SOURCE_DIR}/src/configuration/common/reference_parser.cpp
     ${libddwaf_SOURCE_DIR}/src/configuration/actions_parser.cpp
     ${libddwaf_SOURCE_DIR}/src/configuration/data_parser.cpp

src/builder/waf_builder.hpp

@@ -28,7 +28,8 @@ class waf_builder {
     waf_builder &operator=(waf_builder &&) = delete;
     waf_builder &operator=(const waf_builder &) = delete;
 
-    bool add_or_update(const std::string &path, parameter::map &root, base_ruleset_info &info)
+    bool add_or_update(
+        const std::string &path, raw_configuration::map &root, base_ruleset_info &info)
     {
         return cfg_mgr_.add_or_update(path, root, info);
     }

src/configuration/actions_parser.cpp

@@ -15,8 +15,8 @@
 #include "configuration/common/common.hpp"
 #include "configuration/common/configuration.hpp"
 #include "configuration/common/configuration_collector.hpp"
+#include "configuration/common/raw_configuration.hpp"
 #include "log.hpp"
-#include "parameter.hpp"
 #include "uri_utils.hpp"
 
 namespace ddwaf {
@@ -85,12 +85,12 @@ void validate_and_add_redirect(auto &cfg, auto id, auto &type, auto &parameters)
 
 } // namespace
 
-void parse_actions(
-    const parameter::vector &actions_array, configuration_collector &cfg, base_section_info &info)
+void parse_actions(const raw_configuration::vector &actions_array, configuration_collector &cfg,
+    base_section_info &info)
 {
     for (unsigned i = 0; i < actions_array.size(); i++) {
         const auto &node_param = actions_array[i];
-        auto node = static_cast<parameter::map>(node_param);
+        auto node = static_cast<raw_configuration::map>(node_param);
 
         std::string id;
         try {

src/configuration/actions_parser.hpp

@@ -12,11 +12,11 @@
 #include "configuration/common/common.hpp"
 #include "configuration/common/configuration.hpp"
 #include "configuration/common/configuration_collector.hpp"
-#include "parameter.hpp"
+#include "configuration/common/raw_configuration.hpp"
 
 namespace ddwaf {
 
-void parse_actions(
-    const parameter::vector &actions_array, configuration_collector &cfg, base_section_info &info);
+void parse_actions(const raw_configuration::vector &actions_array, configuration_collector &cfg,
+    base_section_info &info);
 
 } // namespace ddwaf

src/configuration/common/common.hpp

@@ -8,15 +8,16 @@
 
 #include <string>
 
+#include "configuration/common/raw_configuration.hpp"
 #include "exception.hpp"
-#include "parameter.hpp"
 #include "ruleset_info.hpp"
 
 using base_section_info = ddwaf::base_ruleset_info::base_section_info;
 
 namespace ddwaf {
 
-template <typename T, typename Key = std::string> T at(const parameter::map &map, const Key &key)
+template <typename T, typename Key = std::string>
+T at(const raw_configuration::map &map, const Key &key)
 {
     try {
         return static_cast<T>(map.at(key));
@@ -28,7 +29,7 @@ template <typename T, typename Key = std::string> T at(const parameter::map &map
 }
 
 template <typename T, typename Key>
-T at(const parameter::map &map, const Key &key, const T &default_)
+T at(const raw_configuration::map &map, const Key &key, const T &default_)
 {
     try {
         auto it = map.find(key);
@@ -51,7 +52,7 @@ inline void add_addresses_to_info(const address_container &addresses, base_secti
     for (const auto &address : addresses.optional) { info.add_optional_address(address); }
 }
 
-inline unsigned parse_schema_version(parameter::map &ruleset)
+inline unsigned parse_schema_version(raw_configuration::map &ruleset)
 {
     auto version = at<std::string_view>(ruleset, "version", {});
     if (version.empty()) {

src/configuration/common/expression_parser.cpp

@@ -21,6 +21,7 @@
 #include "configuration/common/common.hpp"
 #include "configuration/common/expression_parser.hpp"
 #include "configuration/common/matcher_parser.hpp"
+#include "configuration/common/raw_configuration.hpp"
 #include "configuration/common/transformer_parser.hpp"
 #include "exception.hpp"
 #include "expression.hpp"
@@ -34,7 +35,6 @@
 #include "matcher/lower_than.hpp"
 #include "matcher/phrase_match.hpp"
 #include "matcher/regex_match.hpp"
-#include "parameter.hpp"
 #include "target_address.hpp"
 #include "transformer/base.hpp"
 #include "utils.hpp"
@@ -44,9 +44,9 @@ namespace ddwaf {
 namespace {
 
 template <typename T>
-std::vector<condition_parameter> parse_arguments(const parameter::map &params, data_source source,
-    const std::vector<transformer_id> &transformers, address_container &addresses,
-    const object_limits &limits)
+std::vector<condition_parameter> parse_arguments(const raw_configuration::map &params,
+    data_source source, const std::vector<transformer_id> &transformers,
+    address_container &addresses, const object_limits &limits)
 {
     const auto &specification = T::arguments();
     std::vector<condition_parameter> definitions;
@@ -57,7 +57,7 @@ std::vector<condition_parameter> parse_arguments(const parameter::map &params, d
         definitions.emplace_back();
         condition_parameter &def = definitions.back();
 
-        auto inputs = at<parameter::vector>(params, spec.name);
+        auto inputs = at<raw_configuration::vector>(params, spec.name);
         if (inputs.empty()) {
             if (!spec.optional) {
                 throw ddwaf::parsing_error("empty non-optional argument");
@@ -71,7 +71,7 @@ std::vector<condition_parameter> parse_arguments(const parameter::map &params, d
 
         auto &targets = def.targets;
         for (const auto &input_param : inputs) {
-            auto input = static_cast<parameter::map>(input_param);
+            auto input = static_cast<raw_configuration::map>(input_param);
             auto address = at<std::string>(input, "address");
 
             DDWAF_DEBUG("Found address {}", address);
@@ -100,7 +100,7 @@ std::vector<condition_parameter> parse_arguments(const parameter::map &params, d
                     .transformers = transformers,
                     .source = source});
             } else {
-                auto input_transformers = static_cast<parameter::vector>(it->second);
+                auto input_transformers = static_cast<raw_configuration::vector>(it->second);
                 if (input_transformers.size() > limits.max_transformers_per_address) {
                     throw ddwaf::parsing_error("number of transformers beyond allowed limit");
                 }
@@ -120,7 +120,7 @@ std::vector<condition_parameter> parse_arguments(const parameter::map &params, d
 }
 
 template <typename T, typename... Matchers>
-auto build_condition(std::string_view operator_name, const parameter::map &params,
+auto build_condition(std::string_view operator_name, const raw_configuration::map &params,
     data_source source, const std::vector<transformer_id> &transformers,
     address_container &addresses, const object_limits &limits)
 {
@@ -131,7 +131,7 @@ auto build_condition(std::string_view operator_name, const parameter::map &param
 
 template <typename Condition>
 auto build_versioned_condition(std::string_view operator_name, unsigned version,
-    const parameter::map &params, data_source source,
+    const raw_configuration::map &params, data_source source,
     const std::vector<transformer_id> &transformers, address_container &addresses,
     const object_limits &limits)
 {
@@ -145,16 +145,16 @@ auto build_versioned_condition(std::string_view operator_name, unsigned version,
 
 } // namespace
 
-std::shared_ptr<expression> parse_expression(const parameter::vector &conditions_array,
+std::shared_ptr<expression> parse_expression(const raw_configuration::vector &conditions_array,
     data_source source, const std::vector<transformer_id> &transformers,
     address_container &addresses, const object_limits &limits)
 {
     std::vector<std::unique_ptr<base_condition>> conditions;
     for (const auto &cond_param : conditions_array) {
-        auto root = static_cast<parameter::map>(cond_param);
+        auto root = static_cast<raw_configuration::map>(cond_param);
 
         auto operator_name = at<std::string_view>(root, "operator");
-        auto params = at<parameter::map>(root, "parameters");
+        auto params = at<raw_configuration::map>(root, "parameters");
 
         // Exploit Prevention Operators may have a single-digit version
         unsigned version = 0;
@@ -210,8 +210,9 @@ std::shared_ptr<expression> parse_expression(const parameter::vector &conditions
     return std::make_shared<expression>(std::move(conditions));
 }
 
-std::shared_ptr<expression> parse_simplified_expression(const parameter::vector &conditions_array,
-    address_container &addresses, const object_limits &limits)
+std::shared_ptr<expression> parse_simplified_expression(
+    const raw_configuration::vector &conditions_array, address_container &addresses,
+    const object_limits &limits)
 {
     return parse_expression(conditions_array, data_source::values, {}, addresses, limits);
 }

src/configuration/common/expression_parser.hpp

@@ -7,17 +7,18 @@
 #pragma once
 
 #include "configuration/common/common.hpp"
+#include "configuration/common/raw_configuration.hpp"
 #include "expression.hpp"
-#include "parameter.hpp"
 
 namespace ddwaf {
 
 // TODO: merge these and use default arguments
-std::shared_ptr<expression> parse_expression(const parameter::vector &conditions_array,
+std::shared_ptr<expression> parse_expression(const raw_configuration::vector &conditions_array,
     data_source source, const std::vector<transformer_id> &transformers,
     address_container &addresses, const object_limits &limits);
 
-std::shared_ptr<expression> parse_simplified_expression(const parameter::vector &conditions_array,
-    address_container &addresses, const object_limits &limits);
+std::shared_ptr<expression> parse_simplified_expression(
+    const raw_configuration::vector &conditions_array, address_container &addresses,
+    const object_limits &limits);
 
 } // namespace ddwaf

src/configuration/common/matcher_parser.cpp

@@ -18,6 +18,7 @@
 
 #include "configuration/common/common.hpp"
 #include "configuration/common/matcher_parser.hpp" // IWYU pragma: keep
+#include "configuration/common/raw_configuration.hpp"
 #include "ddwaf.h"
 #include "exception.hpp"
 #include "matcher/base.hpp"
@@ -30,18 +31,17 @@
 #include "matcher/lower_than.hpp"
 #include "matcher/phrase_match.hpp"
 #include "matcher/regex_match.hpp"
-#include "parameter.hpp"
 
 namespace ddwaf {
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::phrase_match>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
-    parameter::map options;
+    raw_configuration::map options;
 
-    auto list = at<parameter::vector>(params, "list");
-    options = at<parameter::map>(params, "options", options);
+    auto list = at<raw_configuration::vector>(params, "list");
+    options = at<raw_configuration::map>(params, "options", options);
     auto word_boundary = at<bool>(options, "enforce_word_boundary", false);
 
     std::vector<const char *> patterns;
@@ -65,12 +65,12 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::ph
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::regex_match>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
-    parameter::map options;
+    raw_configuration::map options;
 
     auto regex = at<std::string>(params, "regex");
-    options = at<parameter::map>(params, "options", options);
+    options = at<raw_configuration::map>(params, "options", options);
 
     auto case_sensitive = at<bool>(options, "case_sensitive", false);
     auto min_length = at<int64_t>(options, "min_length", 0);
@@ -84,21 +84,21 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::re
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::is_xss>(
-    const parameter::map & /*params*/)
+    const raw_configuration::map & /*params*/)
 {
     return {std::string{}, std::make_unique<matcher::is_xss>()};
 }
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::is_sqli>(
-    const parameter::map & /*params*/)
+    const raw_configuration::map & /*params*/)
 {
     return {std::string{}, std::make_unique<matcher::is_sqli>()};
 }
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::ip_match>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
     std::unique_ptr<matcher::base> matcher;
     std::string rule_data_id;
@@ -116,7 +116,7 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::ip
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::exact_match>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
     std::unique_ptr<matcher::base> matcher;
     std::string rule_data_id;
@@ -134,7 +134,7 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::ex
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::equals<>>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
     std::unique_ptr<matcher::base> matcher;
     auto value_type = at<std::string>(params, "type");
@@ -162,7 +162,7 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::eq
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::lower_than<>>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
     std::unique_ptr<matcher::base> matcher;
     auto value_type = at<std::string>(params, "type");
@@ -184,7 +184,7 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::lo
 
 template <>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher<matcher::greater_than<>>(
-    const parameter::map &params)
+    const raw_configuration::map &params)
 {
     std::unique_ptr<matcher::base> matcher;
 

src/configuration/common/matcher_parser.hpp

@@ -10,6 +10,7 @@
 #include <string>
 #include <utility>
 
+#include "configuration/common/raw_configuration.hpp"
 #include "matcher/base.hpp"
 #include "matcher/equals.hpp"
 #include "matcher/exact_match.hpp"
@@ -20,16 +21,16 @@
 #include "matcher/lower_than.hpp"
 #include "matcher/phrase_match.hpp"
 #include "matcher/regex_match.hpp"
-#include "parameter.hpp"
 
 namespace ddwaf {
 
 template <typename Matcher>
-std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher(const parameter::map &params);
+std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher(
+    const raw_configuration::map &params);
 
 template <typename Matcher, typename... Rest>
 std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher(
-    std::string_view name, const parameter::map &params)
+    std::string_view name, const raw_configuration::map &params)
 {
     if (Matcher::matcher_name == name) {
         return parse_matcher<Matcher>(params);
@@ -43,7 +44,7 @@ std::pair<std::string, std::unique_ptr<matcher::base>> parse_matcher(
 }
 
 inline std::pair<std::string, std::unique_ptr<matcher::base>> parse_any_matcher(
-    std::string_view name, const parameter::map &params)
+    std::string_view name, const raw_configuration::map &params)
 {
     return parse_matcher<matcher::equals<>, matcher::exact_match, matcher::greater_than<>,
         matcher::ip_match, matcher::is_sqli, matcher::is_xss, matcher::lower_than<>,