Actions refactoring: now there is a clear definiation on the action name

Author: zimmerle

src/actions/accuracy.cc

@@ -27,14 +27,16 @@
 namespace modsecurity {
 namespace actions {
 
-Accuracy::Accuracy(std::string action)
-    : Action(action, ConfigurationKind),
-    m_accuracy_str(action) {
-    if (m_accuracy_str.at(0) == '\'') {
-        m_accuracy_str.erase(0, 1);
-        m_accuracy_str.pop_back();
+
+bool Accuracy::init(std::string *error) {
+    try {
+        m_accuracy = std::stoi(m_parser_payload);
+    }  catch (...) {
+        error->assign("Accuracy: The input \"" + m_parser_payload + "\" is " \
+            "not a number.");
+        return false;
     }
-    m_accuracy = std::stoi(m_accuracy_str);
+    return true;
 }
 
 
@@ -43,5 +45,6 @@ bool Accuracy::evaluate(Rule *rule, Transaction *transaction) {
     return true;
 }
 
+
 }  // namespace actions
 }  // namespace modsecurity

src/actions/accuracy.h

@@ -29,12 +29,14 @@ namespace actions {
 
 class Accuracy : public Action {
  public:
-    explicit Accuracy(std::string action);
+    explicit Accuracy(std::string action)
+        : Action(action, ConfigurationKind),
+        m_accuracy(0) { }
 
     bool evaluate(Rule *rule, Transaction *transaction) override;
+    bool init(std::string *error) override;
 
  private:
-    std::string m_accuracy_str;
     int m_accuracy;
 };
 

src/actions/action.cc

@@ -52,7 +52,7 @@ bool Action::evaluate(Rule *rule, Transaction *transaction) {
 }
 
 
-void Action::fill_intervention(ModSecurityIntervention *i) {
+void Action::fillIntervention(ModSecurityIntervention *i) {
 }
 
 Action *Action::instantiate(const std::string& name) {

src/actions/action.h

@@ -35,21 +35,43 @@ class Action {
  public:
     explicit Action(const std::string& _action)
         : action_kind(2),
-        action(_action),
-        name(_action),
+        m_name(""),
+        m_parser_payload(""),
         m_isNone(false),
         temporaryAction(false) {
-            name.erase(0, 2);
+            set_name_and_payload(_action);
         }
     explicit Action(const std::string& _action, int kind)
         : action_kind(kind),
-        action(_action),
-        name(_action),
+        m_name(""),
+        m_parser_payload(""),
         m_isNone(false),
         temporaryAction(false) {
-            name.erase(0, 2);
+            set_name_and_payload(_action);
         }
 
+    void set_name_and_payload(const std::string& data) {
+        size_t pos = data.find(":");
+        std::string t = "t:";
+
+        if (data.compare(0, t.length(), t) == 0) {
+            pos = data.find(":", 2);
+        }
+
+        if (pos == std::string::npos) {
+            m_name = data;
+            return;
+        }
+
+        m_name = std::string(data, 0, pos);
+        m_parser_payload = std::string(data, pos + 1, data.length());
+
+        if (m_parser_payload.at(0) == '\'' && m_parser_payload.size() > 2) {
+            m_parser_payload.erase(0, 1);
+            m_parser_payload.pop_back();
+        }
+    }
+
     virtual ~Action() { }
     /**
      *
@@ -83,9 +105,6 @@ class Action {
      RunTimeOnlyIfMatchKind,
     };
 
-    std::string action;
-    int action_kind;
-    std::string name;
 
     virtual std::string evaluate(std::string exp,
         Transaction *transaction);
@@ -94,14 +113,20 @@ class Action {
         RuleMessage *ruleMessage) {
         return evaluate(rule, transaction);
     }
+
     virtual bool init(std::string *error) { return true; }
+
     virtual bool isDisruptive() { return false; }
 
+    virtual void fillIntervention(ModSecurityIntervention *intervention);
+
     static Action *instantiate(const std::string& name);
 
-    virtual void fill_intervention(ModSecurityIntervention *intervention);
     bool temporaryAction;
+    std::string m_name;
+    std::string m_parser_payload;
     bool m_isNone;
+    int action_kind;
 };
 
 

src/actions/audit_log.cc

@@ -23,10 +23,12 @@
 namespace modsecurity {
 namespace actions {
 
+
 bool AuditLog::evaluate(Rule *rule, Transaction *transaction) {
     transaction->m_toBeSavedInAuditlogs = true;
     return true;
 }
 
+
 }  // namespace actions
 }  // namespace modsecurity

src/actions/audit_log.h

@@ -37,6 +37,7 @@ class AuditLog : public Action {
     bool evaluate(Rule *rule, Transaction *transaction) override;
 };
 
+
 }  // namespace actions
 }  // namespace modsecurity
 #endif

src/actions/block.cc

@@ -25,12 +25,6 @@
 namespace modsecurity {
 namespace actions {
 
-Block::Block(std::string action)
-    : Action(action) {
-    this->action = action;
-    this->action_kind = 2;
-}
-
 
 bool Block::evaluate(Rule *rule, Transaction *transaction) {
 #ifndef NO_LOGS
@@ -44,9 +38,11 @@ bool Block::evaluate(Rule *rule, Transaction *transaction) {
     return true;
 }
 
-void Block::fill_intervention(ModSecurityIntervention *i) {
+
+void Block::fillIntervention(ModSecurityIntervention *i) {
     i->disruptive = true;
 }
 
+
 }  // namespace actions
 }  // namespace modsecurity

src/actions/block.h

@@ -31,13 +31,14 @@ namespace actions {
 
 class Block : public Action {
  public:
-    explicit Block(std::string action);
+    explicit Block(std::string action) : Action(action) { }
 
     bool evaluate(Rule *rule, Transaction *transaction) override;
-    void fill_intervention(ModSecurityIntervention *i) override;
+    void fillIntervention(ModSecurityIntervention *i) override;
     bool isDisruptive() override { return true; }
 };
 
+
 }  // namespace actions
 }  // namespace modsecurity
 #endif

src/actions/capture.cc

@@ -31,6 +31,7 @@
 namespace modsecurity {
 namespace actions {
 
+
 bool Capture::evaluate(Rule *rule, Transaction *transaction) {
     if (transaction->m_matched.empty()) {
         return false;
@@ -46,5 +47,6 @@ bool Capture::evaluate(Rule *rule, Transaction *transaction) {
     return true;
 }
 
+
 }  // namespace actions
 }  // namespace modsecurity

src/actions/chain.cc

@@ -25,11 +25,11 @@ namespace modsecurity {
 namespace actions {
 
 
-
 bool Chain::evaluate(Rule *rule, Transaction *transaction) {
     rule->chained = true;
     return true;
 }
 
+
 }  // namespace actions
 }  // namespace modsecurity