Creates RuleUnconditional

Makes RuleScript child of RuleWithActions instead of Operator

src/operators/begins_with.cc

@@ -24,7 +24,7 @@ namespace modsecurity {
 namespace operators {
 
 
-bool BeginsWith::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool BeginsWith::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
     std::string p(m_string->evaluate(transaction));
 

src/operators/begins_with.h

@@ -32,7 +32,7 @@ class BeginsWith : public Operator {
     explicit BeginsWith(std::unique_ptr<RunTimeString> param)
         : Operator("BeginsWith", std::move(param)) { }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule, const std::string &str,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule, const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 };
 

src/operators/contains.cc

@@ -21,7 +21,7 @@
 namespace modsecurity {
 namespace operators {
 
-bool Contains::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool Contains::evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &input, std::shared_ptr<RuleMessage> ruleMessage) {
     std::string p(m_string->evaluate(transaction));
     size_t offset = input.find(p);

src/operators/contains.h

@@ -34,7 +34,7 @@ class Contains : public Operator {
     /** @ingroup ModSecurity_Operator */
     explicit Contains(std::unique_ptr<RunTimeString> param)
         : Operator("Contains", std::move(param)) { }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 };

src/operators/contains_word.cc

@@ -36,7 +36,7 @@ bool ContainsWord::acceptableChar(const std::string& a, size_t pos) {
     return true;
 }
 
-bool ContainsWord::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool ContainsWord::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
     std::string paramTarget(m_string->evaluate(transaction));
 

src/operators/contains_word.h

@@ -32,7 +32,7 @@ class ContainsWord : public Operator {
     explicit ContainsWord(std::unique_ptr<RunTimeString> param)
         : Operator("ContainsWord", std::move(param)) { }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/detect_sqli.cc

@@ -25,7 +25,7 @@ namespace modsecurity {
 namespace operators {
 
 
-bool DetectSQLi::evaluate(Transaction *t, RuleWithOperator *rule,
+bool DetectSQLi::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     char fingerprint[8];
     int issqli;

src/operators/detect_sqli.h

@@ -32,7 +32,7 @@ class DetectSQLi : public Operator {
             m_match_message.assign("detected SQLi using libinjection.");
         }
 
-    bool evaluate(Transaction *t, RuleWithOperator *rule,
+    bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 };

src/operators/detect_xss.cc

@@ -25,7 +25,7 @@ namespace modsecurity {
 namespace operators {
 
 
-bool DetectXSS::evaluate(Transaction *t, RuleWithOperator *rule,
+bool DetectXSS::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     int is_xss;
 

src/operators/detect_xss.h

@@ -31,7 +31,7 @@ class DetectXSS : public Operator {
             m_match_message.assign("detected XSS using libinjection.");
         }
 
-    bool evaluate(Transaction *t, RuleWithOperator *rule,
+    bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 };

src/operators/ends_with.cc

@@ -23,7 +23,7 @@ namespace modsecurity {
 namespace operators {
 
 
-bool EndsWith::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool EndsWith::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
     bool ret = false;
     std::string p(m_string->evaluate(transaction));

src/operators/ends_with.h

@@ -33,7 +33,7 @@ class EndsWith : public Operator {
         : Operator("EndsWith", std::move(param)) {
             m_couldContainsMacro = true;
         }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 };

src/operators/operator.cc

@@ -70,7 +70,7 @@ namespace operators {
 
 
 bool Operator::evaluateInternal(Transaction *transaction,
-    RuleWithOperator *rule, const std::string& a, std::shared_ptr<RuleMessage> rm) {
+    RuleWithActions *rule, const std::string& a, std::shared_ptr<RuleMessage> rm) {
     bool res = evaluate(transaction, rule, a, rm);
 
     if (m_negation) {
@@ -81,7 +81,7 @@ bool Operator::evaluateInternal(Transaction *transaction,
 }
 
 bool Operator::evaluateInternal(Transaction *transaction,
-    RuleWithOperator *rule, const std::string& a) {
+    RuleWithActions *rule, const std::string& a) {
     bool res = evaluate(transaction, rule, a);
 
     if (m_negation) {

src/operators/operator.h

@@ -111,24 +111,23 @@ class Operator {
         std::string key, std::string value);
 
     bool evaluateInternal(Transaction *t, const std::string& a);
-    bool evaluateInternal(Transaction *t, RuleWithOperator *rule,
+    bool evaluateInternal(Transaction *t, RuleWithActions *rule,
         const std::string& a);
-    bool evaluateInternal(Transaction *t, RuleWithOperator *rule,
+    bool evaluateInternal(Transaction *t, RuleWithActions *rule,
         const std::string& a, std::shared_ptr<RuleMessage> ruleMessage);
 
 
     virtual bool evaluate(Transaction *transaction, const std::string &str);
-    virtual bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    virtual bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str) {
         return evaluate(transaction, str);
     }
-    virtual bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    virtual bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
         return evaluate(transaction, str);
     }
 
-    static void logOffset(std::shared_ptr<RuleMessage> ruleMessage,
-        int offset, int len) {
+    static void logOffset(std::shared_ptr<RuleMessage> ruleMessage, int offset, int len) {
         if (ruleMessage) {
             ruleMessage->m_reference.append("o"
                 + std::to_string(offset) + ","

src/operators/pm.cc

@@ -81,7 +81,7 @@ void Pm::postOrderTraversal(acmp_btree_node_t *node) {
 }
 
 
-bool Pm::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool Pm::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &input, std::shared_ptr<RuleMessage> ruleMessage) {
     int rc;
     ACMPT pt;

src/operators/pm.h

@@ -41,7 +41,7 @@ class Pm : public Operator {
         m_p = acmp_create(0);
     }
     ~Pm();
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/rbl.cc

@@ -200,7 +200,7 @@ void Rbl::furtherInfo(struct sockaddr_in *sin, const std::string &ipStr,
 }
 
 
-bool Rbl::evaluate(Transaction *t, RuleWithOperator *rule,
+bool Rbl::evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& ipStr,
         std::shared_ptr<RuleMessage> ruleMessage) {
     struct addrinfo *info = NULL;

src/operators/rbl.h

@@ -76,7 +76,7 @@ class Rbl : public Operator {
                 m_provider = RblProvider::httpbl;
             }
         }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/rx.cc

@@ -36,7 +36,7 @@ bool Rx::init(const std::string &arg, std::string *error) {
 }
 
 
-bool Rx::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool Rx::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     std::list<SMatch> matches;
     Regex *re;

src/operators/rx.h

@@ -49,15 +49,7 @@ class Rx : public Operator {
         }
     }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input, NULL);
-    }
-    bool evaluate(Transaction *transaction,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input);
-    }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/validate_byte_range.cc

@@ -110,7 +110,7 @@ bool ValidateByteRange::init(const std::string &file,
 }
 
 
-bool ValidateByteRange::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool ValidateByteRange::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &input, std::shared_ptr<RuleMessage> ruleMessage) {
     bool ret = true;
 

src/operators/validate_byte_range.h

@@ -37,7 +37,7 @@ class ValidateByteRange : public Operator {
         }
     ~ValidateByteRange() override { }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
     bool getRange(const std::string &rangeRepresentation, std::string *error);

src/operators/validate_url_encoding.cc

@@ -68,7 +68,7 @@ int ValidateUrlEncoding::validate_url_encoding(const char *input,
 }
 
 
-bool ValidateUrlEncoding::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool ValidateUrlEncoding::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &input, std::shared_ptr<RuleMessage> ruleMessage) {
     size_t offset = 0;
     bool res = false;

src/operators/validate_url_encoding.h

@@ -31,7 +31,7 @@ class ValidateUrlEncoding : public Operator {
     ValidateUrlEncoding()
         : Operator("ValidateUrlEncoding") { }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/validate_utf8_encoding.cc

@@ -113,7 +113,7 @@ int ValidateUtf8Encoding::detect_utf8_character(
     return unicode_len;
 }
 
-bool ValidateUtf8Encoding::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool ValidateUtf8Encoding::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
     unsigned int i, bytes_left;
 

src/operators/validate_utf8_encoding.h

@@ -38,7 +38,7 @@ class ValidateUtf8Encoding : public Operator {
     ValidateUtf8Encoding()
         : Operator("ValidateUtf8Encoding") { }
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/verify_cc.cc

@@ -117,7 +117,7 @@ bool VerifyCC::init(const std::string &param2, std::string *error) {
 }
 
 
-bool VerifyCC::evaluate(Transaction *t, RuleWithOperator *rule,
+bool VerifyCC::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& i, std::shared_ptr<RuleMessage> ruleMessage) {
     int offset = 0;
     int target_length = i.length();

src/operators/verify_cc.h

@@ -35,7 +35,7 @@ class VerifyCC : public Operator {
         m_pce(NULL) { }
     ~VerifyCC();
 
-    bool evaluate(Transaction *t, RuleWithOperator *rule,
+    bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage)  override;
     bool init(const std::string &param, std::string *error) override;

src/operators/verify_cpf.cc

@@ -108,7 +108,7 @@ bool VerifyCPF::verify(const char *cpfnumber, int len) {
 }
 
 
-bool VerifyCPF::evaluate(Transaction *t, RuleWithOperator *rule,
+bool VerifyCPF::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     std::list<SMatch> matches;
     bool is_cpf = false;

src/operators/verify_cpf.h

@@ -46,15 +46,7 @@ class VerifyCPF : public Operator {
     bool operator=(const VerifyCPF &a) = delete;
     VerifyCPF(const VerifyCPF &a) = delete;
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input, NULL);
-    }
-    bool evaluate(Transaction *transaction,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input);
-    }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/verify_ssn.cc

@@ -110,7 +110,7 @@ invalid:
 }
 
 
-bool VerifySSN::evaluate(Transaction *t, RuleWithOperator *rule,
+bool VerifySSN::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     std::list<SMatch> matches;
     bool is_ssn = false;

src/operators/verify_ssn.h

@@ -46,15 +46,7 @@ class VerifySSN : public Operator {
     bool operator=(const VerifySSN &a) = delete;
     VerifySSN(const VerifySSN &a) = delete;
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input, NULL);
-    }
-    bool evaluate(Transaction *transaction,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input);
-    }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/verify_svnr.cc

@@ -77,7 +77,7 @@ bool VerifySVNR::verify(const char *svnrnumber, int len) {
 }
 
 
-bool VerifySVNR::evaluate(Transaction *t, RuleWithOperator *rule,
+bool VerifySVNR::evaluate(Transaction *t, RuleWithActions *rule,
     const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
     std::list<SMatch> matches;
     bool is_svnr = false;

src/operators/verify_svnr.h

@@ -32,15 +32,7 @@ class VerifySVNR : public Operator {
     bool operator=(const VerifySVNR &a) = delete;
     VerifySVNR(const VerifySVNR &a) = delete;
 
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input, NULL);
-    }
-    bool evaluate(Transaction *transaction,
-        const std::string &input) override {
-        return evaluate(transaction, NULL, input);
-    }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
         std::shared_ptr<RuleMessage> ruleMessage) override;
 

src/operators/within.cc

@@ -24,7 +24,7 @@ namespace modsecurity {
 namespace operators {
 
 
-bool Within::evaluate(Transaction *transaction, RuleWithOperator *rule,
+bool Within::evaluate(Transaction *transaction, RuleWithActions *rule,
     const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
     bool res = false;
     size_t pos = 0;

src/operators/within.h

@@ -33,7 +33,7 @@ class Within : public Operator {
         : Operator("Within", std::move(param)) {
             m_couldContainsMacro = true;
         }
-    bool evaluate(Transaction *transaction, RuleWithOperator *rule,
+    bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) override;
 };