Organizes methods for Rules and RulesPhases

headers/modsecurity/rules.h

@@ -39,6 +39,29 @@ namespace modsecurity {
 
 class Rules : public std::vector<Rule *> {
  public:
+    void dump() {
+        for (int j = 0; j < size(); j++) {
+            std::cout << "    Rule ID: " << std::to_string(at(j)->m_ruleId);
+            std::cout << "--" << at(j) << std::endl;
+        }
+    }
+
+    int append(Rules *from, const std::vector<int64_t> &ids, std::ostringstream *err) {
+        size_t j = 0;
+        for (; j < from->size(); j++) {
+            Rule *rule = from->at(j);
+            if (std::binary_search(ids.begin(), ids.end(), rule->m_ruleId)) {
+                if (err != NULL) {
+                    *err << "Rule id: " << std::to_string(rule->m_ruleId) \
+                         << " is duplicated" << std::endl;
+                }
+                return -1;
+            }
+            rule->refCountIncrease();
+        }
+        insert(end(), from->begin(), from->end());
+        return j;
+    }
 };
 
 

headers/modsecurity/rules_set_phases.h

@@ -35,7 +35,7 @@ class RulesSetPhases {
     ~RulesSetPhases() {
         /** Cleanup the rules */
         for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-            Rules *rules = &m_rules[i];
+            Rules *rules = &m_rulesAtPhase[i];
             while (rules->empty() == false) {
                 Rule *rule = rules->back();
                 rules->pop_back();
@@ -50,7 +50,7 @@ class RulesSetPhases {
         if (rule->m_phase >= modsecurity::Phases::NUMBER_OF_PHASES) {
             return false;
         }
-        m_rules[rule->m_phase].push_back(rule);
+        m_rulesAtPhase[rule->m_phase].push_back(rule);
 
         return true;
     }
@@ -60,9 +60,9 @@ class RulesSetPhases {
         std::vector<int64_t> v;
 
         for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-            v.reserve(m_rules[i].size());
+            v.reserve(m_rulesAtPhase[i].size());
-            for (size_t z = 0; z < m_rules[i].size(); z++) {
+            for (size_t z = 0; z < m_rulesAtPhase[i].size(); z++) {
-                Rule *rule_ckc = m_rules[i].at(z);
+                Rule *rule_ckc = m_rulesAtPhase[i].at(z);
                 if (rule_ckc->m_secMarker == true) {
                     continue;
                 }
@@ -72,41 +72,31 @@ class RulesSetPhases {
         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++) {
+            int res = m_rulesAtPhase[i].append(from->at(i), v, err);
-                Rule *rule = from->at(i)->at(j);
+            if (res < 0) {
-                if (std::binary_search(v.begin(), v.end(), rule->m_ruleId)) {
+                return res;
-                    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);
             }
+            amount_of_rules = amount_of_rules + res;
         }
 
         return amount_of_rules;
     }
 
     void dump() {
-        for (int i = 0; i <= modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+        for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
-            std::vector<Rule *> rules = m_rules[i];
+            Rules *rules = &m_rulesAtPhase[i];
             std::cout << "Phase: " << std::to_string(i);
-            std::cout << " (" << std::to_string(rules.size());
+            std::cout << " (" << std::to_string(rules->size());
             std::cout << " rules)" << std::endl;
-            for (int j = 0; j < rules.size(); j++) {
+            rules->dump();
-                std::cout << "    Rule ID: " << std::to_string(rules[j]->m_ruleId);
-                std::cout << "--" << rules[j] << std::endl;
-            }
         }
     }
 
-    Rules *operator[](int index) { return &m_rules[index]; }
+    Rules *operator[](int index) { return &m_rulesAtPhase[index]; }
-    Rules *at(int index) { return &m_rules[index]; }
+    Rules *at(int index) { return &m_rulesAtPhase[index]; }
 
-    Rules m_rules[8];
+ private:
+    Rules m_rulesAtPhase[8];
 };
 
 }  // namespace modsecurity

src/rules_set.cc

@@ -298,16 +298,7 @@ void RulesSet::debug(int level, const std::string &id,
 
 void RulesSet::dump() {
     std::cout << "Rules: " << std::endl;
-    for (int i = 0; i < modsecurity::Phases::NUMBER_OF_PHASES; i++) {
+    m_rulesSetPhases.dump();
-        std::vector<Rule *> *rules = m_rulesSetPhases[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->at(j)->m_ruleId);
-            std::cout << "--" << rules->at(j) << std::endl;
-        }
-    }
 }