Creates the RulesSetPhases clas

headers/modsecurity/rules_set.h

@@ -41,6 +41,87 @@ class Driver;
 }
 
 
+class RulesSetPhases {
+ public:
+
+    ~RulesSetPhases() {
+        /** Cleanup the rules */
+        for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+            std::vector<Rule *> rules = m_rules[i];
+            while (rules.empty() == false) {
+                Rule *rule = rules.back();
+                rules.pop_back();
+                if (rule->refCountDecreaseAndCheck()) {
+                    rule = NULL;
+                }
+            }
+        }
+    }
+
+    bool insert(Rule *rule) {
+        if (rule->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
+            return false;
+        }
+        m_rules[rule->m_phase].push_back(rule);
+
+        return true;
+    }
+
+    int append(RulesSetPhases *from, std::ostringstream *err) {
+        int amount_of_rules = 0;
+        std::vector<int64_t> v;
+
+        for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+            v.reserve(m_rules[i].size());
+            for (size_t z = 0; z < m_rules[i].size(); z++) {
+                Rule *rule_ckc = m_rules[i].at(z);
+                if (rule_ckc->m_secMarker == true) {
+                    continue;
+                }
+                v.push_back(rule_ckc->m_ruleId);
+            }
+        }
+        std::sort (v.begin(), v.end());
+
+        for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+            for (size_t j = 0; j < from->at(i).size(); j++) {
+                Rule *rule = from->at(i).at(j);
+                if (std::binary_search(v.begin(), v.end(), rule->m_ruleId)) {
+                    if (err != NULL) {
+                        *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                            << " is duplicated" << std::endl;
+                    }
+                    return -1;
+                }
+                amount_of_rules++;
+                rule->refCountIncrease();
+                m_rules[i].push_back(rule);
+            }
+        }
+
+        return amount_of_rules;
+    }
+
+    void dump() {
+        for (int i = 0; i <= modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+            std::vector<Rule *> rules = m_rules[i];
+            std::cout << "Phase: " << std::to_string(i);
+            std::cout << " (" << std::to_string(rules.size());
+            std::cout << " rules)" << std::endl;
+            for (int j = 0; j < rules.size(); j++) {
+                std::cout << "    Rule ID: " << std::to_string(rules[j]->m_ruleId);
+                std::cout << "--" << rules[j] << std::endl;
+            }
+        }
+    }
+
+    std::vector<modsecurity::Rule *> operator[](int index) const { return m_rules[index]; }
+    std::vector<modsecurity::Rule *> at(int index) const { return m_rules[index]; }
+
+    std::vector<modsecurity::Rule *> m_rules[8];
+};
+
+
 /** @ingroup ModSecurity_CPP_API */
 class RulesSet : public RulesSetProperties {
  public:
@@ -80,6 +161,7 @@ class RulesSet : public RulesSetProperties {
 
     int64_t unicode_codepage;
 
+    RulesSetPhases m_rulesSetPhases;
  private:
 #ifndef NO_LOGS
     uint8_t m_secmarker_skipped;