Code cosmetics

headers/modsecurity/transaction/collection.h

@@ -24,13 +24,15 @@ typedef struct Collection_t Collection;
 
 
 #ifdef __cplusplus
+#include <string>
+
 namespace ModSecurity {
 
 class Collection : public transaction::Variables {
  public:
      Collection(std::string name, std::string key)
        : m_name(name),
-       m_key(key) { };
+       m_key(key) { }
 
      std::string m_name;
      clock_t m_createTime;

headers/modsecurity/transaction/variables.h

@@ -61,7 +61,6 @@ class Variables :
         std::vector<const transaction::Variable *> *l);
     void resolveRegularExpression(const std::string& var,
         std::vector<const transaction::Variable *> *l);
-
 };
 
 }  // namespace transaction

src/actions/transformations/html_entity_decode.h

@@ -30,7 +30,8 @@ namespace actions {
 namespace transformations {
 
 
-class HtmlEntityDecodeInstantCache : public std::unordered_map<std::string, std::string> {
+class HtmlEntityDecodeInstantCache :
+    public std::unordered_map<std::string, std::string> {
  public:
     static HtmlEntityDecodeInstantCache& getInstance() {
         static HtmlEntityDecodeInstantCache instance;
@@ -44,7 +45,7 @@ class HtmlEntityDecodeInstantCache : public std::unordered_map<std::string, std:
         }
     }
  private:
-    HtmlEntityDecodeInstantCache() {};
+    HtmlEntityDecodeInstantCache() {}
 };
 
 

src/actions/transformations/lower_case.h

@@ -29,7 +29,8 @@ class Assay;
 namespace actions {
 namespace transformations {
 
-class LowerCaseInstantCache : public std::unordered_map<std::string, std::string> {
+class LowerCaseInstantCache :
+    public std::unordered_map<std::string, std::string> {
  public:
     static LowerCaseInstantCache& getInstance() {
         static LowerCaseInstantCache instance;
@@ -43,7 +44,7 @@ class LowerCaseInstantCache : public std::unordered_map<std::string, std::string
         }
     }
  private:
-    LowerCaseInstantCache() {};
+    LowerCaseInstantCache() {}
 };
 
 

src/actions/transformations/url_decode.h

@@ -29,7 +29,8 @@ class Assay;
 namespace actions {
 namespace transformations {
 
-class UrlDecodeInstantCache : public std::unordered_map<std::string, std::string> {
+class UrlDecodeInstantCache :
+    public std::unordered_map<std::string, std::string> {
  public:
     static UrlDecodeInstantCache& getInstance() {
         static UrlDecodeInstantCache instance;
@@ -43,7 +44,7 @@ class UrlDecodeInstantCache : public std::unordered_map<std::string, std::string
         }
     }
  private:
-    UrlDecodeInstantCache() {};
+    UrlDecodeInstantCache() {}
 };
 
 

src/collections.cc

@@ -132,9 +132,7 @@ void Collections::resolveSingleMatch(const std::string& var,
 
     try {
         this->at(collection)->resolveSingleMatch(var, l);
-    } catch (...) {
+    } catch (...) { }
-
-    }
 }
 
 void Collections::resolveMultiMatches(const std::string& var,
@@ -149,9 +147,7 @@ void Collections::resolveMultiMatches(const std::string& var,
     std::vector<const transaction::Variable *> *l) {
     try {
         this->at(collection)->resolveMultiMatches(var, l);
-    } catch (...) {
+    } catch (...) { }
-
-    }
 }
 
 void Collections::resolveRegularExpression(const std::string& var,
@@ -166,9 +162,7 @@ void Collections::resolveRegularExpression(const std::string& var,
 
     try {
         this->at(collection)->resolveRegularExpression(var, l);
-    } catch (...) {
+    } catch (...) { }
-
-    }
 }
 
 }  // namespace transaction

src/operators/detect_sqli.h

@@ -17,6 +17,7 @@
 #define SRC_OPERATORS_DETECT_SQLI_H_
 
 #include <string>
+#include <list>
 
 #include "operators/operator.h"
 

src/rule.cc

@@ -488,7 +488,6 @@ bool Rule::evaluate(Assay *assay) {
             delete e.back();
             e.pop_back();
         }
-        //delete e;
     }
     return ret;
 }

src/variables.cc

@@ -96,8 +96,7 @@ void Variables::resolveMultiMatches(const std::string& var,
         if (x.first.compare(0, keySize, var) != 0) {
             continue;
         }
-        const transaction::Variable *v = new transaction::Variable(x.first, x.second);
+        l->insert(l->begin(), new transaction::Variable(x.first, x.second));
-        l->insert(l->begin(), v);
     }
 }
 

src/variables/variable.cc

@@ -34,7 +34,6 @@ Variable::Variable(std::string name)
     m_collectionName(""),
     m_isExclusion(false),
     m_isCount(false) {
-
     if (m_name.at(0) == '\\') {
         m_type = RegularExpression;
     } else if (m_name.find(":") != std::string::npos) {
@@ -58,7 +57,6 @@ Variable::Variable(std::string name, VariableKind kind)
     m_kind(kind),
     m_isExclusion(false),
     m_isCount(false) {
-
     if (m_name.at(0) == '\\') {
         m_type = RegularExpression;
     } else if (m_name.find(":") != std::string::npos) {
@@ -75,25 +73,32 @@ Variable::Variable(std::string name, VariableKind kind)
 
 std::vector<const transaction::Variable *> *
     Variable::evaluate(Assay *assay) {
-    std::vector<const transaction::Variable *> *l = new std::vector<const transaction::Variable *>();
+    std::vector<const transaction::Variable *> *l = NULL;
+    l = new std::vector<const transaction::Variable *>();
     evaluate(assay, l);
 
     return l;
 }
 
-void Variable::evaluateInternal(Assay *assay, std::vector<const transaction::Variable *> *l) {
+void Variable::evaluateInternal(Assay *assay,
+    std::vector<const transaction::Variable *> *l) {
     if (m_collectionName.empty() == false) {
         if (m_kind == CollectionVarible && m_type == MultipleMatches) {
-            assay->m_collections.resolveMultiMatches(m_name, m_collectionName, l);
+            assay->m_collections.resolveMultiMatches(m_name,
-        } if (m_kind == CollectionVarible && m_type == RegularExpression) {
+                m_collectionName, l);
-            assay->m_collections.resolveRegularExpression(m_name, m_collectionName, l);
+        } else if (m_kind == CollectionVarible
+            && m_type == RegularExpression) {
+            assay->m_collections.resolveRegularExpression(m_name,
+                m_collectionName, l);
         } else {
-            assay->m_collections.resolveSingleMatch(m_name, m_collectionName, l);
+            assay->m_collections.resolveSingleMatch(m_name,
+                m_collectionName, l);
         }
     } else {
         if (m_kind == CollectionVarible && m_type == MultipleMatches) {
             assay->m_collections.resolveMultiMatches(m_name, l);
-        } if (m_kind == CollectionVarible && m_type == RegularExpression) {
+        } else if (m_kind == CollectionVarible
+            && m_type == RegularExpression) {
             assay->m_collections.resolveRegularExpression(m_name, l);
         } else {
             assay->m_collections.resolveSingleMatch(m_name, l);
@@ -102,7 +107,8 @@ void Variable::evaluateInternal(Assay *assay, std::vector<const transaction::Var
 }
 
 
-void Variable::evaluate(Assay *assay, std::vector<const transaction::Variable *> *l) {
+void Variable::evaluate(Assay *assay,
+    std::vector<const transaction::Variable *> *l) {
     evaluateInternal(assay, l);
 }
 

src/variables/variable.h

@@ -67,8 +67,10 @@ class Variable {
     static std::string to_s(std::vector<Variable *> *variables);
 
     virtual std::vector<const transaction::Variable *> *evaluate(Assay *assay);
-    virtual void evaluate(Assay *assay, std::vector<const transaction::Variable *> *l);
+    virtual void evaluate(Assay *assay,
-    virtual void evaluateInternal(Assay *assay, std::vector<const transaction::Variable *> *l);
+        std::vector<const transaction::Variable *> *l);
+    virtual void evaluateInternal(Assay *assay,
+        std::vector<const transaction::Variable *> *l);
 
 
     std::string m_name;