Having a class Rules

src/Makefile.am

@@ -42,6 +42,7 @@ pkginclude_HEADERS = \
 	../headers/modsecurity/intervention.h \
 	../headers/modsecurity/modsecurity.h \
 	../headers/modsecurity/rule.h \
+	../headers/modsecurity/rules.h \
 	../headers/modsecurity/rule_message.h \
 	../headers/modsecurity/rules.h \
 	../headers/modsecurity/rules_set.h \
@@ -275,6 +276,7 @@ libmodsecurity_la_SOURCES = \
 	audit_log/writer/parallel.cc \
 	modsecurity.cc \
 	rules_set.cc \
+	rules_set_phases.cc \
 	rules_set_properties.cc \
 	debug_log/debug_log.cc \
 	debug_log/debug_log_writer.cc \

src/actions/audit_log.cc

@@ -21,7 +21,7 @@
 
 #include "modsecurity/transaction.h"
 #include "modsecurity/rule_message.h"
-#include "modsecurity/rules.h"
+#include "modsecurity/rules_set.h"
 
 namespace modsecurity {
 namespace actions {

src/parser/driver.cc

@@ -119,9 +119,9 @@ int Driver::addSecRule(Rule *rule) {
         return false;
     }
     for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-        std::vector<Rule *> rules = m_rulesSetPhases[i];
-        for (int j = 0; j < rules.size(); j++) {
-            if (rules[j]->m_ruleId == rule->m_ruleId) {
+        Rules *rules = m_rulesSetPhases[i];
+        for (int j = 0; j < rules->size(); j++) {
+            if (rules->at(j)->m_ruleId == rule->m_ruleId) {
                 m_parserError << "Rule id: " << std::to_string(rule->m_ruleId) \
                     << " is duplicated" << std::endl;
                 return false;

src/rules_set.cc

@@ -24,6 +24,7 @@
 #include "modsecurity/transaction.h"
 #include "src/parser/driver.h"
 #include "src/utils/https_client.h"
+#include "modsecurity/rules.h"
 
 using modsecurity::Parser::Driver;
 using modsecurity::Utils::HttpsClient;
@@ -110,10 +111,10 @@ int RulesSet::evaluate(int phase, Transaction *t) {
        return 0;
     }
 
-    std::vector<Rule *> rules = m_rulesSetPhases[phase];
+    std::vector<Rule *> *rules = m_rulesSetPhases[phase];
 
     ms_dbg_a(t, 9, "This phase consists of " \
-        + std::to_string(rules.size()) + " rule(s).");
+        + std::to_string(rules->size()) + " rule(s).");
 
     if (t->m_allowType == actions::disruptive::FromNowOnAllowType
         && phase != modsecurity::Phases::LoggingPhase) {
@@ -131,8 +132,8 @@ int RulesSet::evaluate(int phase, Transaction *t) {
     t->m_allowType = actions::disruptive::NoneAllowType;
     //}
 
-    for (int i = 0; i < rules.size(); i++) {
-        Rule *rule = rules[i];
+    for (int i = 0; i < rules->size(); i++) {
+        Rule *rule = rules->at(i);
         if (t->m_marker.empty() == false) {
             ms_dbg_a(t, 9, "Skipped rule id '" + std::to_string(rule->m_ruleId) \
                 + "' due to a SecMarker: " + t->m_marker);
@@ -256,7 +257,6 @@ void RulesSet::debug(int level, const std::string &id,
 }
 
 
-
 void RulesSet::dump() const {
     m_rulesSetPhases.dump();
 }

src/rules_set_phases.cc

@@ -0,0 +1,103 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2015 - 2020 Trustwave Holdings, Inc. (http://www.trustwave.com/)
+ *
+ * You may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * If any of the files related to licensing are missing or if you have any
+ * other questions related to licensing please contact Trustwave Holdings, Inc.
+ * directly using the email address security@modsecurity.org.
+ *
+ */
+
+#include <ctime>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "modsecurity/rules_set_phases.h"
+#include "modsecurity/rule.h"
+#include "modsecurity/rules.h"
+#include "modsecurity/modsecurity.h"
+
+
+
+namespace modsecurity {
+
+RulesSetPhases::~RulesSetPhases() {
+    /** Cleanup the rules */
+    for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+        Rules *rules = &m_rules[i];
+        while (rules->empty() == false) {
+            Rule *rule = rules->back();
+            rules->pop_back();
+            if (rule->refCountDecreaseAndCheck()) {
+                rule = NULL;
+            }
+        }
+    }
+}
+
+bool RulesSetPhases::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 RulesSetPhases::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 RulesSetPhases::dump() const {
+    for (int i = 0; i <= modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+        std::cout << "Phase: " << std::to_string(i);
+        std::cout << " (" << std::to_string(m_rules[i].size());
+        std::cout << " rules)" << std::endl;
+        for (int j = 0; j < m_rules[i].size(); j++) {
+            std::cout << "    Rule ID: " << std::to_string(m_rules[i][j]->m_ruleId);
+            std::cout << "--" << m_rules[i][j] << std::endl;
+        }
+    }
+}
+
+
+}  // namespace modsecurity
+