Merge pull request #3253 from eduar-hte/rule-message

Simplified handling of RuleMessage by removing usage of std::shared_ptr

build/win32/CMakeLists.txt

@@ -171,13 +171,13 @@ endfunction()
 
 # unit tests
 file(GLOB unitTestSources ${BASE_DIR}/test/unit/*.cc)
-add_executable(unit_tests ${unitTestSources})
+add_executable(unit_tests ${unitTestSources} ${BASE_DIR}/test/common/custom_debug_log.cc)
 setTestTargetProperties(unit_tests)
 target_compile_options(unit_tests PRIVATE /wd4805)
 
 # regression tests
 file(GLOB regressionTestsSources ${BASE_DIR}/test/regression/*.cc)
-add_executable(regression_tests ${regressionTestsSources})
+add_executable(regression_tests ${regressionTestsSources} ${BASE_DIR}/test/common/custom_debug_log.cc)
 setTestTargetProperties(regression_tests)
 
 macro(add_regression_test_capability compile_definition flag)

examples/reading_logs_via_rule_message/reading_logs_via_rule_message.h

@@ -160,13 +160,13 @@ class ReadingLogsViaRuleMessage {
         std::cout << std::endl;
         if (ruleMessage->m_isDisruptive) {
             std::cout << " * Disruptive action: ";
-            std::cout << modsecurity::RuleMessage::log(ruleMessage);
+            std::cout << modsecurity::RuleMessage::log(*ruleMessage);
             std::cout << std::endl;
             std::cout << " ** %d is meant to be informed by the webserver.";
             std::cout << std::endl;
         } else {
             std::cout << " * Match, but no disruptive action: ";
-            std::cout << modsecurity::RuleMessage::log(ruleMessage);
+            std::cout << modsecurity::RuleMessage::log(*ruleMessage);
             std::cout << std::endl;
         }
     }

examples/using_bodies_in_chunks/simple_request.cc

@@ -81,13 +81,13 @@ static void logCb(void *data, const void *ruleMessagev) {
     std::cout << std::endl;
     if (ruleMessage->m_isDisruptive) {
         std::cout << " * Disruptive action: ";
-        std::cout << modsecurity::RuleMessage::log(ruleMessage);
+        std::cout << modsecurity::RuleMessage::log(*ruleMessage);
         std::cout << std::endl;
         std::cout << " ** %d is meant to be informed by the webserver.";
         std::cout << std::endl;
     } else {
         std::cout << " * Match, but no disruptive action: ";
-        std::cout << modsecurity::RuleMessage::log(ruleMessage);
+        std::cout << modsecurity::RuleMessage::log(*ruleMessage);
         std::cout << std::endl;
     }
 }

headers/modsecurity/actions/action.h

@@ -89,7 +89,7 @@ class Action {
 
     virtual bool evaluate(RuleWithActions *rule, Transaction *transaction);
     virtual bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> ruleMessage) {
+        RuleMessage &ruleMessage) {
         return evaluate(rule, transaction);
     }
     virtual bool init(std::string *error) { return true; }

headers/modsecurity/modsecurity.h

@@ -292,7 +292,7 @@ class ModSecurity {
      */
     void setServerLogCb(ModSecLogCb cb, int properties);
 
-    void serverLog(void *data, std::shared_ptr<RuleMessage> rm);
+    void serverLog(void *data, const RuleMessage &rm);
 
     const std::string& getConnectorInformation() const;
 

headers/modsecurity/rule.h

@@ -78,8 +78,7 @@ class Rule {
 
     virtual bool evaluate(Transaction *transaction) = 0;
 
-    virtual bool evaluate(Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) = 0;
+    virtual bool evaluate(Transaction *transaction, RuleMessage &ruleMessage) = 0;
 
     const std::string& getFileName() const {
         return m_fileName;

headers/modsecurity/rule_marker.h

@@ -42,8 +42,7 @@ class RuleMarker : public Rule {
 
     RuleMarker &operator=(const RuleMarker &r) = delete;
    
-    virtual bool evaluate(Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override {
+    virtual bool evaluate(Transaction *transaction, RuleMessage &ruleMessage) override {
         return evaluate(transaction);
     }
 

headers/modsecurity/rule_message.h

@@ -13,14 +13,6 @@
  *
  */
 
-#ifdef __cplusplus
-#include <stack>
-#include <vector>
-#include <string>
-#include <list>
-#include <cstring>
-#endif
-
 #ifndef HEADERS_MODSECURITY_RULE_MESSAGE_H_
 #define HEADERS_MODSECURITY_RULE_MESSAGE_H_
 
@@ -31,8 +23,10 @@
 
 #ifdef __cplusplus
 
-namespace modsecurity {
+#include <string>
+#include <list>
 
+namespace modsecurity {
 
 
 class RuleMessage {
@@ -45,43 +39,51 @@ class RuleMessage {
     RuleMessage(const RuleWithActions &rule, const Transaction &trans) :
         m_rule(rule),
         m_transaction(trans)
-    { }
+    {
+        reset(true);
+    }
 
     RuleMessage(const RuleMessage &ruleMessage) = default;
     RuleMessage &operator=(const RuleMessage &ruleMessage) = delete;
 
-    void clean() {
-        m_data = "";
-        m_match = "";
+    void reset(const bool resetSaveMessage)
+    {
+        m_data.clear();
         m_isDisruptive = false;
-        m_reference = "";
+        m_match.clear();
+        m_message.clear();
+        m_noAuditLog = false;
+        m_reference.clear();
+        if (resetSaveMessage == true)
+            m_saveMessage = true;
         m_severity = 0;
+        m_tags.clear();
     }
 
-    std::string log() {
-        return log(this, 0);
+    std::string log() const {
+        return log(*this, 0);
     }
-    std::string log(int props) {
-        return log(this, props);
+    std::string log(int props) const {
+        return log(*this, props);
     }
-    std::string log(int props, int responseCode) {
-        return log(this, props, responseCode);
+    std::string log(int props, int responseCode) const {
+        return log(*this, props, responseCode);
     }
-    std::string errorLog() {
-        return log(this,
-		ClientLogMessageInfo | ErrorLogTailLogMessageInfo);
+    std::string errorLog() const {
+        return log(*this,
+                   ClientLogMessageInfo | ErrorLogTailLogMessageInfo);
     }
 
-    static std::string log(const RuleMessage *rm, int props, int code);
-    static std::string log(const RuleMessage *rm, int props) {
+    static std::string log(const RuleMessage &rm, int props, int code);
+    static std::string log(const RuleMessage &rm, int props) {
         return log(rm, props, -1);
     }
-    static std::string log(const RuleMessage *rm) {
+    static std::string log(const RuleMessage &rm) {
         return log(rm, 0);
     }
 
-    static std::string _details(const RuleMessage *rm);
-    static std::string _errorLogTail(const RuleMessage *rm);
+    static std::string _details(const RuleMessage &rm);
+    static std::string _errorLogTail(const RuleMessage &rm);
 
     int getPhase() const { return m_rule.getPhase() - 1; }
 

headers/modsecurity/rule_unconditional.h

@@ -36,7 +36,7 @@ class RuleUnconditional : public RuleWithActions {
  public:
     using RuleWithActions::RuleWithActions;
 
-    virtual bool evaluate(Transaction *transaction, std::shared_ptr<RuleMessage> ruleMessage) override;
+    virtual bool evaluate(Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 

headers/modsecurity/rule_with_actions.h

@@ -51,21 +51,21 @@ class RuleWithActions : public Rule {
 
     virtual bool evaluate(Transaction *transaction) override;
 
-    virtual bool evaluate(Transaction *transaction, std::shared_ptr<RuleMessage> ruleMessage) override;
+    virtual bool evaluate(Transaction *transaction, RuleMessage &ruleMessage) override;
 
     void executeActionsIndependentOfChainedRuleResult(
         Transaction *trasn,
         bool *containsDisruptive,
-        std::shared_ptr<RuleMessage> ruleMessage);
+        RuleMessage &ruleMessage);
 
     void executeActionsAfterFullMatch(
         Transaction *trasn,
         bool containsDisruptive,
-        std::shared_ptr<RuleMessage> ruleMessage);
+        RuleMessage &ruleMessage);
 
     void executeAction(Transaction *trans,
         bool containsBlock,
-        std::shared_ptr<RuleMessage> ruleMessage,
+        RuleMessage &ruleMessage,
         actions::Action *a,
         bool context);
 
@@ -74,7 +74,7 @@ class RuleWithActions : public Rule {
         const Transaction *trasn, const std::string &value, TransformationResults &ret);
 
     void performLogging(Transaction *trans,
-        std::shared_ptr<RuleMessage> ruleMessage,
+        RuleMessage &ruleMessage,
         bool lastLog = true,
         bool chainedParentNull = false) const;
 

headers/modsecurity/rule_with_operator.h

@@ -47,8 +47,7 @@ class RuleWithOperator : public RuleWithActions {
 
     ~RuleWithOperator() override;
 
-    bool evaluate(Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(Transaction *transaction, RuleMessage &ruleMessage) override;
 
     void getVariablesExceptions(Transaction &t,
         variables::Variables *exclusion, variables::Variables *addition);
@@ -56,7 +55,7 @@ class RuleWithOperator : public RuleWithActions {
         variables::Variables *eclusion, Transaction *trans);
 
     bool executeOperatorAt(Transaction *trasn, const std::string &key,
-        const std::string &value, std::shared_ptr<RuleMessage> rm);
+        const std::string &value, RuleMessage &ruleMessage);
 
     static void updateMatchedVars(Transaction *trasn, const std::string &key,
         const std::string &value);

headers/modsecurity/transaction.h

@@ -407,7 +407,7 @@ class Transaction : public TransactionAnchoredVariables, public TransactionSecMa
 #ifndef NO_LOGS
     void debug(int, const std::string &) const; // cppcheck-suppress functionStatic
 #endif
-    void serverLog(std::shared_ptr<RuleMessage> rm);
+    void serverLog(const RuleMessage &rm);
 
     int getRuleEngineState() const;
 

src/actions/audit_log.cc

@@ -27,11 +27,10 @@ namespace modsecurity {
 namespace actions {
 
 
-bool AuditLog::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
-    rm->m_noAuditLog = false;
+bool AuditLog::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
+    ruleMessage.m_noAuditLog = false;
     ms_dbg_a(transaction, 9, "Saving transaction to logs");
-    rm->m_saveMessage = true;
+    ruleMessage.m_saveMessage = true;
 
     return true;
 }

src/actions/audit_log.h

@@ -35,8 +35,7 @@ class AuditLog : public Action {
     explicit AuditLog(const std::string &action) 
         : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 

src/actions/block.cc

@@ -29,15 +29,14 @@ namespace modsecurity {
 namespace actions {
 
 
-bool Block::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+bool Block::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 8, "Marking request as disruptive.");
 
     for (auto &a : transaction->m_rules->m_defaultActions[rule->getPhase()]) {
         if (a->isDisruptive() == false) {
             continue;
         }
-        a->evaluate(rule, transaction, rm);
+        a->evaluate(rule, transaction, ruleMessage);
     }
 
     return true;

src/actions/block.h

@@ -35,8 +35,7 @@ class Block : public Action {
  public:
     explicit Block(const std::string &action) : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 

src/actions/data/status.cc

@@ -39,7 +39,7 @@ bool Status::init(std::string *error) {
 
 
 bool Status::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+    RuleMessage &ruleMessage) {
     transaction->m_it.status = m_status;
     return true;
 }

src/actions/data/status.h

@@ -37,8 +37,7 @@ class Status : public Action {
         : Action(action), m_status(0) { }
 
     bool init(std::string *error) override;
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 
     int m_status;
 };

src/actions/disruptive/deny.cc

@@ -29,7 +29,7 @@ namespace disruptive {
 
 
 bool Deny::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+    RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 8, "Running action deny");
 
     if (transaction->m_it.status == 200) {
@@ -38,9 +38,9 @@ bool Deny::evaluate(RuleWithActions *rule, Transaction *transaction,
 
     transaction->m_it.disruptive = true;
     intervention::freeLog(&transaction->m_it);
-    rm->m_isDisruptive = true;
+    ruleMessage.m_isDisruptive = true;
     transaction->m_it.log = strdup(
-        rm->log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
+        ruleMessage.log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
 
     return true;
 }

src/actions/disruptive/deny.h

@@ -33,8 +33,7 @@ class Deny : public Action {
  public:
     explicit Deny(const std::string &action) : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
     bool isDisruptive() override { return true; }
 };
 

src/actions/disruptive/drop.cc

@@ -33,7 +33,7 @@ namespace disruptive {
 
 
 bool Drop::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+    RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 8, "Running action drop " \
         "[executing deny instead of drop.]");
 
@@ -43,9 +43,9 @@ bool Drop::evaluate(RuleWithActions *rule, Transaction *transaction,
 
     transaction->m_it.disruptive = true;
     intervention::freeLog(&transaction->m_it);
-    rm->m_isDisruptive = true;
+    ruleMessage.m_isDisruptive = true;
     transaction->m_it.log = strdup(
-        rm->log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
+        ruleMessage.log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
 
     return true;
 }

src/actions/disruptive/drop.h

@@ -32,8 +32,7 @@ class Drop : public Action {
  public:
     explicit Drop(const std::string &action) : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
     bool isDisruptive() override { return true; }
 };
 

src/actions/disruptive/pass.cc

@@ -30,7 +30,7 @@ namespace disruptive {
 
 
 bool Pass::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+    RuleMessage &ruleMessage) {
     intervention::free(&transaction->m_it);
     intervention::reset(&transaction->m_it);
 

src/actions/disruptive/pass.h

@@ -31,8 +31,7 @@ class Pass : public Action {
  public:
     explicit Pass(const std::string &action) : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
     bool isDisruptive() override { return true; }
 };
 

src/actions/disruptive/redirect.cc

@@ -35,7 +35,7 @@ bool Redirect::init(std::string *error) {
 
 
 bool Redirect::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+    RuleMessage &ruleMessage) {
     std::string m_urlExpanded(m_string->evaluate(transaction));
     /* if it was changed before, lets keep it. */
     if (transaction->m_it.status == 200
@@ -47,9 +47,9 @@ bool Redirect::evaluate(RuleWithActions *rule, Transaction *transaction,
     transaction->m_it.url = strdup(m_urlExpanded.c_str());
     transaction->m_it.disruptive = true;
     intervention::freeLog(&transaction->m_it);
-    rm->m_isDisruptive = true;
+    ruleMessage.m_isDisruptive = true;
     transaction->m_it.log = strdup(
-        rm->log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
+        ruleMessage.log(RuleMessage::LogMessageInfo::ClientLogMessageInfo).c_str());
 
     return true;
 }

src/actions/disruptive/redirect.h

@@ -46,8 +46,7 @@ class Redirect : public Action {
             m_status(0),
             m_string(std::move(z)) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
     bool init(std::string *error) override;
     bool isDisruptive() override { return true; }
 

src/actions/log.cc

@@ -28,10 +28,9 @@ namespace modsecurity {
 namespace actions {
 
 
-bool Log::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+bool Log::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 9, "Saving transaction to logs");
-    rm->m_saveMessage = true;
+    ruleMessage.m_saveMessage = true;
     return true;
 }
 

src/actions/log.h

@@ -33,8 +33,7 @@ class Log : public Action {
     explicit Log(const std::string &action) 
         : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 }  // namespace actions

src/actions/log_data.cc

@@ -29,9 +29,8 @@ namespace modsecurity {
 namespace actions {
 
 
-bool LogData::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
-    rm->m_data = data(transaction);
+bool LogData::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
+    ruleMessage.m_data = data(transaction);
 
     return true;
 }

src/actions/log_data.h

@@ -39,8 +39,7 @@ class LogData : public Action {
         : Action("logdata"),
             m_string(std::move(z)) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-       std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 
     std::string data(Transaction *Transaction);
 

src/actions/msg.cc

@@ -46,10 +46,9 @@ namespace modsecurity {
 namespace actions {
 
 
-bool Msg::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
-    std::string msg = data(transaction);
-    rm->m_message = msg;
+bool Msg::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
+    const auto msg = data(transaction);
+    ruleMessage.m_message = msg;
     ms_dbg_a(transaction, 9, "Saving msg: " + msg);
 
     return true;

src/actions/msg.h

@@ -40,8 +40,7 @@ class Msg : public Action {
         : Action("msg"),
             m_string(std::move(z)) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 
     std::string data(Transaction *Transaction);
     std::unique_ptr<RunTimeString> m_string;

src/actions/no_audit_log.cc

@@ -26,10 +26,9 @@ namespace modsecurity {
 namespace actions {
 
 
-bool NoAuditLog::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
-    rm->m_noAuditLog = true;
-    rm->m_saveMessage = false;
+bool NoAuditLog::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
+    ruleMessage.m_noAuditLog = true;
+    ruleMessage.m_saveMessage = false;
 
     return true;
 }

src/actions/no_audit_log.h

@@ -35,8 +35,7 @@ class NoAuditLog : public Action {
     explicit NoAuditLog(const std::string &action) 
         : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 }  // namespace actions

src/actions/no_log.cc

@@ -29,9 +29,8 @@ namespace modsecurity {
 namespace actions {
 
 
-bool NoLog::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
-    rm->m_saveMessage = false;
+bool NoLog::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
+    ruleMessage.m_saveMessage = false;
     return true;
 }
 

src/actions/no_log.h

@@ -33,8 +33,7 @@ class NoLog : public Action {
     explicit NoLog(const std::string &action) 
         : Action(action) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 };
 
 }  // namespace actions

src/actions/severity.cc

@@ -71,13 +71,12 @@ bool Severity::init(std::string *error) {
 }
 
 
-bool Severity::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+bool Severity::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
     ms_dbg_a(transaction, 9, "This rule severity is: " + \
         std::to_string(this->m_severity) + " current transaction is: " + \
         std::to_string(transaction->m_highestSeverityAction));
 
-    rm->m_severity = m_severity;
+    ruleMessage.m_severity = m_severity;
 
     if (transaction->m_highestSeverityAction > this->m_severity) {
         transaction->m_highestSeverityAction = this->m_severity;

src/actions/severity.h

@@ -35,8 +35,7 @@ class Severity : public Action {
         : Action(action),
         m_severity(0) { }
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
     bool init(std::string *error) override;
 
     int m_severity;

src/actions/tag.cc

@@ -57,12 +57,11 @@ std::string Tag::getName(Transaction *transaction) {
 }
 
 
-bool Tag::evaluate(RuleWithActions *rule, Transaction *transaction,
-    std::shared_ptr<RuleMessage> rm) {
+bool Tag::evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) {
     std::string tag = getName(transaction);
     ms_dbg_a(transaction, 9, "Rule tag: " + tag);
 
-    rm->m_tags.push_back(tag);
+    ruleMessage.m_tags.push_back(tag);
 
     return true;
 }

src/actions/tag.h

@@ -38,8 +38,7 @@ class Tag : public Action {
 
     std::string getName(Transaction *transaction);
 
-    bool evaluate(RuleWithActions *rule, Transaction *transaction,
-        std::shared_ptr<RuleMessage> rm) override;
+    bool evaluate(RuleWithActions *rule, Transaction *transaction, RuleMessage &ruleMessage) override;
 
  protected:
     std::unique_ptr<RunTimeString> m_string;

src/modsecurity.cc

@@ -190,26 +190,22 @@ const std::string& ModSecurity::getConnectorInformation() const {
     return m_connector;
 }
 
-void ModSecurity::serverLog(void *data, std::shared_ptr<RuleMessage> rm) {
+void ModSecurity::serverLog(void *data, const RuleMessage &rm) {
     if (m_logCb == NULL) {
-        std::cerr << "Server log callback is not set -- " << rm->errorLog();
+        std::cerr << "Server log callback is not set -- " << rm.errorLog();
         std::cerr << std::endl;
         return;
     }
 
-    if (rm == NULL) {
-        return;
-    }
-
     if (m_logProperties & TextLogProperty) {
-        auto d = rm->log();
-        const void *a = static_cast<const void *>(d.c_str());
+        auto d = rm.log();
+        auto a = static_cast<const void *>(d.c_str());
         m_logCb(data, a);
         return;
     }
 
     if (m_logProperties & RuleMessageLogProperty) {
-        const void *a = static_cast<const void *>(rm.get());
+        auto a = static_cast<const void *>(&rm);
         m_logCb(data, a);
         return;
     }

src/operators/begins_with.cc

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

src/operators/begins_with.h

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

src/operators/contains.cc

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

src/operators/contains.h

@@ -36,7 +36,7 @@ class Contains : public Operator {
         : Operator("Contains", std::move(param)) { }
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 };
 
 }  // namespace operators

src/operators/contains_word.cc

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

src/operators/contains_word.h

@@ -34,7 +34,7 @@ class ContainsWord : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
  private:
     static bool acceptableChar(const std::string& a, size_t pos);

src/operators/detect_sqli.cc

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

src/operators/detect_sqli.h

@@ -34,7 +34,7 @@ class DetectSQLi : public Operator {
 
     bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 };
 
 }  // namespace operators

src/operators/detect_xss.cc

@@ -26,7 +26,7 @@ namespace operators {
 
 
 bool DetectXSS::evaluate(Transaction *t, RuleWithActions *rule,
-    const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string& input, RuleMessage &ruleMessage) {
     int is_xss;
 
     is_xss = libinjection_xss(input.c_str(), input.length());

src/operators/detect_xss.h

@@ -33,7 +33,7 @@ class DetectXSS : public Operator {
 
     bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 };
 
 }  // namespace operators

src/operators/ends_with.cc

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

src/operators/ends_with.h

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

src/operators/operator.cc

@@ -71,8 +71,8 @@ namespace operators {
 
 
 bool Operator::evaluateInternal(Transaction *transaction,
-    RuleWithActions *rule, const std::string& a, std::shared_ptr<RuleMessage> rm) {
-    bool res = evaluate(transaction, rule, a, rm);
+    RuleWithActions *rule, const std::string& a, RuleMessage &ruleMessage) {
+    bool res = evaluate(transaction, rule, a, ruleMessage);
 
     if (m_negation) {
         return !res;

src/operators/operator.h

@@ -115,7 +115,7 @@ class Operator {
     bool evaluateInternal(Transaction *t, RuleWithActions *rule,
         const std::string& a);
     bool evaluateInternal(Transaction *t, RuleWithActions *rule,
-        const std::string& a, std::shared_ptr<RuleMessage> ruleMessage);
+        const std::string& a, RuleMessage &ruleMessage);
 
 
     virtual bool evaluate(Transaction *transaction, const std::string &str);
@@ -124,16 +124,14 @@ class Operator {
         return evaluate(transaction, str);
     }
     virtual bool evaluate(Transaction *transaction, RuleWithActions *rule,
-        const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
+        const std::string &str, RuleMessage &ruleMessage) {
         return evaluate(transaction, str);
     }
 
-    static void logOffset(std::shared_ptr<RuleMessage> ruleMessage, int offset, int len) {
-        if (ruleMessage) {
-            ruleMessage->m_reference.append("o"
-                + std::to_string(offset) + ","
-                + std::to_string(len));
-        }
+    static void logOffset(RuleMessage &ruleMessage, int offset, int len) {
+        ruleMessage.m_reference.append("o"
+            + std::to_string(offset) + ","
+            + std::to_string(len));
     }
 
     std::string m_match_message;

src/operators/pm.cc

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

src/operators/pm.h

@@ -43,7 +43,7 @@ class Pm : public Operator {
     ~Pm();
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
 
     bool init(const std::string &file, std::string *error) override;

src/operators/rbl.cc

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

src/operators/rbl.h

@@ -83,7 +83,7 @@ class Rbl : public Operator {
         }
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     std::string mapIpToAddress(const std::string &ipStr, Transaction *trans) const;
 

src/operators/rx.cc

@@ -37,7 +37,7 @@ bool Rx::init(const std::string &arg, std::string *error) {
 
 
 bool Rx::evaluate(Transaction *transaction, RuleWithActions *rule,
-    const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string& input, RuleMessage &ruleMessage) {
     Regex *re;
 
     if (m_param.empty() && !m_string->m_containsMacro) {

src/operators/rx.h

@@ -51,7 +51,7 @@ class Rx : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     bool init(const std::string &arg, std::string *error) override;
 

src/operators/rx_global.cc

@@ -37,7 +37,7 @@ bool RxGlobal::init(const std::string &arg, std::string *error) {
 
 
 bool RxGlobal::evaluate(Transaction *transaction, RuleWithActions *rule,
-    const std::string& input, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string& input, RuleMessage &ruleMessage) {
     Regex *re;
 
     if (m_param.empty() && !m_string->m_containsMacro) {

src/operators/rx_global.h

@@ -51,7 +51,7 @@ class RxGlobal : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     bool init(const std::string &arg, std::string *error) override;
 

src/operators/validate_byte_range.cc

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

src/operators/validate_byte_range.h

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

src/operators/validate_url_encoding.cc

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

src/operators/validate_url_encoding.h

@@ -33,7 +33,7 @@ class ValidateUrlEncoding : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     static int validate_url_encoding(const char *input, uint64_t input_length,
         size_t *offset);

src/operators/validate_utf8_encoding.cc

@@ -122,7 +122,7 @@ int ValidateUtf8Encoding::detect_utf8_character(
 }
 
 bool ValidateUtf8Encoding::evaluate(Transaction *transaction, RuleWithActions *rule,
-    const std::string &str, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string &str, RuleMessage &ruleMessage) {
     unsigned int i, bytes_left;
 
     const char *str_c = str.c_str();

src/operators/validate_utf8_encoding.h

@@ -33,7 +33,7 @@ class ValidateUtf8Encoding : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string &str,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     static int detect_utf8_character(const unsigned char *p_read,
         unsigned int length);

src/operators/verify_cc.cc

@@ -135,7 +135,7 @@ bool VerifyCC::init(const std::string &param2, std::string *error) {
 
 
 bool VerifyCC::evaluate(Transaction *t, RuleWithActions *rule,
-    const std::string& i, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string& i, RuleMessage &ruleMessage) {
 #ifdef WITH_PCRE2
     PCRE2_SIZE offset = 0;
     size_t target_length = i.length();

src/operators/verify_cc.h

@@ -49,7 +49,7 @@ class VerifyCC : public Operator {
 
     bool evaluate(Transaction *t, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage)  override;
+        RuleMessage &ruleMessage)  override;
     bool init(const std::string &param, std::string *error) override;
  private:
 #if WITH_PCRE2

src/operators/verify_cpf.cc

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

src/operators/verify_cpf.h

@@ -48,7 +48,7 @@ class VerifyCPF : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     bool verify(const char *ssnumber, int len);
 

src/operators/verify_ssn.cc

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

src/operators/verify_ssn.h

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

src/operators/verify_svnr.cc

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

src/operators/verify_svnr.h

@@ -34,7 +34,7 @@ class VerifySVNR : public Operator {
 
     bool evaluate(Transaction *transaction, RuleWithActions *rule,
         const std::string& input,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+        RuleMessage &ruleMessage) override;
 
     bool verify(const char *ssnumber, int len);
 

src/operators/within.cc

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

src/operators/within.h

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

src/rule_message.cc

@@ -23,55 +23,55 @@
 namespace modsecurity {
 
 
-std::string RuleMessage::_details(const RuleMessage *rm) {
+std::string RuleMessage::_details(const RuleMessage &rm) {
     std::string msg;
 
-    msg.append(" [file \"" + rm->m_rule.getFileName() + "\"]");
-    msg.append(" [line \"" + std::to_string(rm->m_rule.getLineNumber()) + "\"]");
-    msg.append(" [id \"" + std::to_string(rm->m_rule.m_ruleId) + "\"]");
-    msg.append(" [rev \"" + utils::string::toHexIfNeeded(rm->m_rule.m_rev, true) + "\"]");
-    msg.append(" [msg \"" + rm->m_message + "\"]");
-    msg.append(" [data \"" + utils::string::toHexIfNeeded(utils::string::limitTo(200, rm->m_data), true) + "\"]");
+    msg.append(" [file \"" + rm.m_rule.getFileName() + "\"]");
+    msg.append(" [line \"" + std::to_string(rm.m_rule.getLineNumber()) + "\"]");
+    msg.append(" [id \"" + std::to_string(rm.m_rule.m_ruleId) + "\"]");
+    msg.append(" [rev \"" + utils::string::toHexIfNeeded(rm.m_rule.m_rev, true) + "\"]");
+    msg.append(" [msg \"" + rm.m_message + "\"]");
+    msg.append(" [data \"" + utils::string::toHexIfNeeded(utils::string::limitTo(200, rm.m_data), true) + "\"]");
     msg.append(" [severity \"" +
-        std::to_string(rm->m_severity) + "\"]");
-    msg.append(" [ver \"" + utils::string::toHexIfNeeded(rm->m_rule.m_ver, true) + "\"]");
-    msg.append(" [maturity \"" + std::to_string(rm->m_rule.m_maturity) + "\"]");
-    msg.append(" [accuracy \"" + std::to_string(rm->m_rule.m_accuracy) + "\"]");
+        std::to_string(rm.m_severity) + "\"]");
+    msg.append(" [ver \"" + utils::string::toHexIfNeeded(rm.m_rule.m_ver, true) + "\"]");
+    msg.append(" [maturity \"" + std::to_string(rm.m_rule.m_maturity) + "\"]");
+    msg.append(" [accuracy \"" + std::to_string(rm.m_rule.m_accuracy) + "\"]");
 
-    for (const auto &a : rm->m_tags) {
+    for (const auto &a : rm.m_tags) {
         msg.append(" [tag \"" + utils::string::toHexIfNeeded(a, true) + "\"]");
     }
 
-    msg.append(" [hostname \"" + rm->m_transaction.m_requestHostName \
+    msg.append(" [hostname \"" + rm.m_transaction.m_requestHostName \
         + "\"]");
-    msg.append(" [uri \"" + utils::string::limitTo(200, rm->m_transaction.m_uri_no_query_string_decoded) + "\"]");
-    msg.append(" [unique_id \"" + rm->m_transaction.m_id + "\"]");
-    msg.append(" [ref \"" + utils::string::limitTo(200, rm->m_reference) + "\"]");
+    msg.append(" [uri \"" + utils::string::limitTo(200, rm.m_transaction.m_uri_no_query_string_decoded) + "\"]");
+    msg.append(" [unique_id \"" + rm.m_transaction.m_id + "\"]");
+    msg.append(" [ref \"" + utils::string::limitTo(200, rm.m_reference) + "\"]");
 
     return msg;
 }
 
 
-std::string RuleMessage::_errorLogTail(const RuleMessage *rm) {
+std::string RuleMessage::_errorLogTail(const RuleMessage &rm) {
     std::string msg;
 
-    msg.append("[hostname \"" + rm->m_transaction.m_serverIpAddress + "\"]");
-    msg.append(" [uri \"" + utils::string::limitTo(200, rm->m_transaction.m_uri_no_query_string_decoded) + "\"]");
-    msg.append(" [unique_id \"" + rm->m_transaction.m_id + "\"]");
+    msg.append("[hostname \"" + rm.m_transaction.m_serverIpAddress + "\"]");
+    msg.append(" [uri \"" + utils::string::limitTo(200, rm.m_transaction.m_uri_no_query_string_decoded) + "\"]");
+    msg.append(" [unique_id \"" + rm.m_transaction.m_id + "\"]");
 
     return msg;
 }
 
 
-std::string RuleMessage::log(const RuleMessage *rm, int props, int code) {
+std::string RuleMessage::log(const RuleMessage &rm, int props, int code) {
     std::string msg("");
     msg.reserve(2048);
 
     if (props & ClientLogMessageInfo) {
-        msg.append("[client " + rm->m_transaction.m_clientIpAddress + "] ");
+        msg.append("[client " + rm.m_transaction.m_clientIpAddress + "] ");
     }
 
-    if (rm->m_isDisruptive) {
+    if (rm.m_isDisruptive) {
         msg.append("ModSecurity: Access denied with code ");
         if (code == -1) {
             msg.append("%d");
@@ -79,12 +79,12 @@ std::string RuleMessage::log(const RuleMessage *rm, int props, int code) {
             msg.append(std::to_string(code));
         }
         msg.append(" (phase ");
-        msg.append(std::to_string(rm->getPhase()) + "). ");
+        msg.append(std::to_string(rm.getPhase()) + "). ");
     } else {
         msg.append("ModSecurity: Warning. ");
     }
 
-    msg.append(rm->m_match);
+    msg.append(rm.m_match);
     msg.append(_details(rm));
 
     if (props & ErrorLogTailLogMessageInfo) {

src/rule_script.cc

@@ -23,7 +23,7 @@ bool RuleScript::init(std::string *err) {
 }
 
 bool RuleScript::evaluate(Transaction *trans,
-    std::shared_ptr<RuleMessage> ruleMessage) {
+    RuleMessage &ruleMessage) {
 
     ms_dbg_a(trans, 4, " Executing script: " + m_name + ".");
 

src/rule_script.h

@@ -59,8 +59,7 @@ class RuleScript : public RuleWithActions {
 
     bool init(std::string *err);
 
-    bool evaluate(Transaction *trans,
-        std::shared_ptr<RuleMessage> ruleMessage) override;
+    bool evaluate(Transaction *trans, RuleMessage &ruleMessage) override;
 
     std::string m_name;
     engine::Lua m_lua;

src/rule_unconditional.cc

@@ -20,7 +20,7 @@ namespace modsecurity {
 
 
 bool RuleUnconditional::evaluate(Transaction *trans,
-    std::shared_ptr<RuleMessage> ruleMessage) {
+    RuleMessage &ruleMessage) {
     RuleWithActions::evaluate(trans, ruleMessage);
 
     // FIXME: This needs to be romeved on the runtime exeption review.

src/rule_with_actions.cc

@@ -179,12 +179,13 @@ RuleWithActions::~RuleWithActions() {
 
 
 bool RuleWithActions::evaluate(Transaction *transaction) {
-    return evaluate(transaction, std::make_shared<RuleMessage>(*this, *transaction));
+    RuleMessage rm(*this, *transaction);
+    return evaluate(transaction, rm);
 }
 
 
 bool RuleWithActions::evaluate(Transaction *transaction,
-    std::shared_ptr<RuleMessage> ruleMessage) {
+    RuleMessage &ruleMessage) {
 
     /* Rule evaluate is pure virtual.
      *
@@ -199,7 +200,7 @@ bool RuleWithActions::evaluate(Transaction *transaction,
 
 
 void RuleWithActions::executeActionsIndependentOfChainedRuleResult(Transaction *trans,
-    bool *containsBlock, std::shared_ptr<RuleMessage> ruleMessage) {
+    bool *containsBlock, RuleMessage &ruleMessage) {
 
     for (actions::SetVar *a : m_actionsSetVar) {
         ms_dbg_a(trans, 4, "Running [independent] (non-disruptive) " \
@@ -243,7 +244,7 @@ void RuleWithActions::executeActionsIndependentOfChainedRuleResult(Transaction *
 
 
 void RuleWithActions::executeActionsAfterFullMatch(Transaction *trans,
-    bool containsBlock, std::shared_ptr<RuleMessage> ruleMessage) {
+    bool containsBlock, RuleMessage &ruleMessage) {
     bool disruptiveAlreadyExecuted = false;
 
     for (const auto &a : trans->m_rules->m_defaultActions[getPhase()]) { // cppcheck-suppress ctunullpointer
@@ -296,7 +297,7 @@ void RuleWithActions::executeActionsAfterFullMatch(Transaction *trans,
 
 
 void RuleWithActions::executeAction(Transaction *trans,
-    bool containsBlock, std::shared_ptr<RuleMessage> ruleMessage,
+    bool containsBlock, RuleMessage &ruleMessage,
     Action *a, bool defaultContext) {
     if (a->isDisruptive() == false && *a->m_name.get() != "block") {
         ms_dbg_a(trans, 9, "Running " \
@@ -492,12 +493,12 @@ std::vector<actions::Action *> RuleWithActions::getActionsByName(const std::stri
 }
 
 void RuleWithActions::performLogging(Transaction *trans,
-    std::shared_ptr<RuleMessage> ruleMessage,
+    RuleMessage &ruleMessage,
     bool lastLog,
     bool chainedParentNull) const {
 
     /* last rule in the chain. */
-    bool isItToBeLogged = ruleMessage->m_saveMessage;
+    bool isItToBeLogged = ruleMessage.m_saveMessage;
 
     /**
     *
@@ -512,31 +513,31 @@ void RuleWithActions::performLogging(Transaction *trans,
     **/
     if (lastLog) {
         if (chainedParentNull) {
-            isItToBeLogged = (ruleMessage->m_saveMessage && (m_chainedRuleParent == nullptr));
+            isItToBeLogged = (ruleMessage.m_saveMessage && (m_chainedRuleParent == nullptr));
             if (isItToBeLogged && !hasMultimatch()) {
                 /* warn */
-                trans->m_rulesMessages.push_back(*ruleMessage);
+                trans->m_rulesMessages.push_back(ruleMessage);
 
                 /* error */
-                if (!ruleMessage->m_isDisruptive) {
+                if (!ruleMessage.m_isDisruptive) {
                     trans->serverLog(ruleMessage);
                 }
             }
         } else if (hasBlockAction() && !hasMultimatch()) {
             /* warn */
-            trans->m_rulesMessages.push_back(*ruleMessage);
+            trans->m_rulesMessages.push_back(ruleMessage);
             /* error */
-            if (!ruleMessage->m_isDisruptive) {
+            if (!ruleMessage.m_isDisruptive) {
                 trans->serverLog(ruleMessage);
             }
         } else {
             if (isItToBeLogged && !hasMultimatch()
-                && !ruleMessage->m_message.empty()) {
+                && !ruleMessage.m_message.empty()) {
                 /* warn */
-                trans->m_rulesMessages.push_back(*ruleMessage);
+                trans->m_rulesMessages.push_back(ruleMessage);
 
                 /* error */
-                if (!ruleMessage->m_isDisruptive) {
+                if (!ruleMessage.m_isDisruptive) {
                     trans->serverLog(ruleMessage);
                 }
             }
@@ -544,16 +545,14 @@ void RuleWithActions::performLogging(Transaction *trans,
     } else {
         if (hasMultimatch() && isItToBeLogged) {
             /* warn */
-            trans->m_rulesMessages.push_back(*ruleMessage.get());
+            trans->m_rulesMessages.push_back(ruleMessage);
 
             /* error */
-            if (!ruleMessage->m_isDisruptive) {
+            if (!ruleMessage.m_isDisruptive) {
                 trans->serverLog(ruleMessage);
             }
 
-            RuleMessage *rm = new RuleMessage(*this, *trans);
-            rm->m_saveMessage = ruleMessage->m_saveMessage;
-            ruleMessage.reset(rm);
+            ruleMessage.reset(false);
         }
     }
 }

src/rule_with_operator.cc

@@ -102,7 +102,7 @@ void RuleWithOperator::cleanMatchedVars(Transaction *trans) {
 
 
 bool RuleWithOperator::executeOperatorAt(Transaction *trans, const std::string &key,
-    const std::string &value, std::shared_ptr<RuleMessage> ruleMessage) {
+    const std::string &value, RuleMessage &ruleMessage) {
 #if MSC_EXEC_CLOCK_ENABLED
     clock_t begin = clock();
     clock_t end;
@@ -202,7 +202,7 @@ inline void RuleWithOperator::getFinalVars(variables::Variables *vars,
 
 
 bool RuleWithOperator::evaluate(Transaction *trans,
-    std::shared_ptr<RuleMessage> ruleMessage) {
+    RuleMessage &ruleMessage) {
     bool globalRet = false;
     variables::Variables *variables = this->m_variables;
     bool recursiveGlobalRet;
@@ -301,13 +301,13 @@ bool RuleWithOperator::evaluate(Transaction *trans,
                 const bool ret = executeOperatorAt(trans, key, valueAfterTrans, ruleMessage);
 
                 if (ret == true) {
-                    ruleMessage->m_match = m_operator->resolveMatchMessage(trans,
+                    ruleMessage.m_match = m_operator->resolveMatchMessage(trans,
                         key, value);
                     for (const auto &i : v->getOrigin()) {
-                        ruleMessage->m_reference.append(i.toText());
+                        ruleMessage.m_reference.append(i.toText());
                     }
 
-                    ruleMessage->m_reference.append(*valueTemp.second);
+                    ruleMessage.m_reference.append(*valueTemp.second);
                     updateMatchedVars(trans, key, valueAfterTrans);
                     executeActionsIndependentOfChainedRuleResult(trans,
                         &containsBlock, ruleMessage);

src/transaction.cc

@@ -1529,7 +1529,7 @@ std::string Transaction::toOldAuditLogFormat(int parts,
     }
     if (parts & audit_log::AuditLog::HAuditLogPart) {
         audit_log << "--" << trailer << "-" << "H--" << std::endl;
-        for (auto a : m_rulesMessages) {
+        for (const auto &a : m_rulesMessages) {
             audit_log << a.log(0, m_httpCodeReturned) << std::endl;
         }
         audit_log << std::endl;
@@ -1750,7 +1750,7 @@ std::string Transaction::toJSON(int parts) {
 }
 
 
-void Transaction::serverLog(std::shared_ptr<RuleMessage> rm) {
+void Transaction::serverLog(const RuleMessage &rm) {
     m_ms->serverLog(m_logCbData, rm);
 }
 

test/Makefile.am

@@ -31,7 +31,8 @@ EXTRA_DIST = \
 noinst_PROGRAMS += unit_tests
 unit_tests_SOURCES = \
         unit/unit.cc \
-        unit/unit_test.cc
+        unit/unit_test.cc \
+        common/custom_debug_log.cc
 
 
 noinst_HEADERS = \
@@ -94,7 +95,7 @@ noinst_PROGRAMS += regression_tests
 regression_tests_SOURCES = \
         regression/regression.cc \
         regression/regression_test.cc \
-        regression/custom_debug_log.cc
+        common/custom_debug_log.cc
 
 regression_tests_LDADD = \
 	$(CURL_LDADD) \

test/common/custom_debug_log.cc

@@ -0,0 +1,51 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2015 - 2021 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 "custom_debug_log.h"
+
+#include <iostream>
+#include <string>
+
+#include "modsecurity/debug_log.h"
+#include "src/utils/regex.h"
+
+namespace modsecurity_test {
+
+    void CustomDebugLog::write(int level, const std::string &message) {
+        m_log << "[" << level << "] " << message << std::endl;
+    }
+
+    void CustomDebugLog::write(int level, const std::string &id,
+        const std::string &uri, const std::string &msg) {
+        std::string msgf = "[" + std::to_string(level) + "] " + msg;
+        msgf = "[" + id + "] [" + uri + "] " + msgf;
+        m_log << msgf << std::endl;
+    }
+
+    bool CustomDebugLog::contains(const std::string &pattern) const {
+        modsecurity::Utils::Regex re(pattern);
+        std::string s = m_log.str();
+        return modsecurity::Utils::regex_search(s, re);
+    }
+
+    std::string CustomDebugLog::log_messages() const {
+        return m_log.str();
+    }
+
+    int CustomDebugLog::getDebugLogLevel() {
+        return 9;
+    }
+
+} // namespace modsecurity_test

test/common/custom_debug_log.h

@@ -26,13 +26,12 @@ namespace modsecurity_test {
 class CustomDebugLog : public modsecurity::debug_log::DebugLog {
  public:
     CustomDebugLog *new_instance();
-    ~CustomDebugLog();
 
     void write(int level, const std::string& message) override;
     void write(int level, const std::string &id,
         const std::string &uri, const std::string &msg) override;
-    bool const contains(const std::string& pattern) const;
-    std::string const log_messages() const;
+    bool contains(const std::string& pattern) const;
+    std::string log_messages() const;
     std::string error_log_messages();
     int getDebugLogLevel() override;
 

test/common/modsecurity_test.cc

@@ -72,18 +72,11 @@ bool ModSecurityTest<T>::load_test_json(const std::string &file) {
     for ( int i = 0; i < num_tests; i++ ) {
         yajl_val obj = node->u.array.values[i];
 
-        T *u = T::from_yajl_node(obj);
+        auto u = std::unique_ptr<T>(T::from_yajl_node(obj));
         u->filename = file;
 
-        if (this->count(u->filename + ":" + u->name) == 0) {
-            auto vec = new std::vector<T *>;
-            vec->push_back(u);
-            std::string filename(u->filename + ":" + u->name);
-            this->insert({filename, vec});
-        } else {
-            auto vec = this->at(u->filename + ":" + u->name);
-            vec->push_back(u);
-        }
+        const auto key = u->filename + ":" + u->name;
+        (*this)[key].push_back(std::move(u));
     }
 
     yajl_tree_free(node);

test/common/modsecurity_test.h

@@ -29,7 +29,7 @@ extern std::string default_test_path;
 namespace modsecurity_test {
 
 template <class T> class ModSecurityTest :
-    public std::unordered_map<std::string, std::vector<T *> *> {
+    public std::unordered_map<std::string, std::vector<std::unique_ptr<T>>> {
  public:
     ModSecurityTest()
         : m_test_number(0),

test/common/modsecurity_test_context.h

@@ -0,0 +1,42 @@
+#ifndef TEST_COMMON_MODSECURITY_TEST_CONTEXT_H_
+#define TEST_COMMON_MODSECURITY_TEST_CONTEXT_H_
+
+#include "modsecurity/modsecurity.h"
+#include "modsecurity/rules_set.h"
+#include "modsecurity/transaction.h"
+#include "custom_debug_log.h"
+
+#include <sstream>
+
+namespace modsecurity_test {
+
+    class ModSecurityTestContext {
+    public:
+        explicit ModSecurityTestContext(const std::string &connector)
+            : m_modsec_rules(new CustomDebugLog) {
+            m_modsec.setConnectorInformation(connector);
+            m_modsec.setServerLogCb(logCb);
+        }
+        ~ModSecurityTestContext() = default;
+
+        modsecurity::Transaction create_transaction() {
+            return modsecurity::Transaction(&m_modsec,
+                                            &m_modsec_rules,
+                                            &m_server_log);
+        }
+
+        modsecurity::ModSecurity m_modsec;
+        modsecurity::RulesSet m_modsec_rules;
+        std::stringstream m_server_log;
+
+    private:
+        static void logCb(void *data, const void *msgv) {
+            auto msg = reinterpret_cast<const char *>(msgv);
+            auto ss = reinterpret_cast<std::stringstream *>(data);
+            *ss << msg << std::endl;
+        }
+    };
+
+} // namespace modsecurity_test
+
+#endif // TEST_COMMON_MODSECURITY_TEST_H_

test/regression/custom_debug_log.cc

@@ -1,55 +0,0 @@
-/*
- * ModSecurity, http://www.modsecurity.org/
- * Copyright (c) 2015 - 2021 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 "test/regression/custom_debug_log.h"
-
-#include <iostream>
-#include <string>
-
-#include "modsecurity/debug_log.h"
-#include "src/utils/regex.h"
-
-namespace modsecurity_test {
-
-CustomDebugLog::~CustomDebugLog() { }
-
-void CustomDebugLog::write(int level, const std::string& message) {
-    m_log << "[" << level << "] " << message << std::endl;
-}
-
-void CustomDebugLog::write(int level, const std::string &id,
-    const std::string &uri, const std::string &msg) {
-    std::string msgf = "[" + std::to_string(level) + "] " + msg;
-    msgf = "[" + id + "] [" + uri + "] " + msgf;
-    m_log << msgf << std::endl;
-}
-
-bool const CustomDebugLog::contains(const std::string& pattern) const {
-    modsecurity::Utils::Regex re(pattern);
-    std::string s = m_log.str();
-    return modsecurity::Utils::regex_search(s, re);
-}
-
-std::string const CustomDebugLog::log_messages() const {
-    return m_log.str();
-}
-
-
-int CustomDebugLog::getDebugLogLevel() {
-    return 9;
-}
-
-
-}  // namespace modsecurity_test

test/regression/regression.cc

@@ -33,7 +33,7 @@
 #include "test/common/colors.h"
 #include "test/regression/regression_test.h"
 #include "test/common/modsecurity_test_results.h"
-#include "test/regression/custom_debug_log.h"
+#include "test/common/modsecurity_test_context.h"
 #include "src/utils/regex.h"
 
 using modsecurity_test::CustomDebugLog;
@@ -97,40 +97,28 @@ void actions(ModSecurityTestResults<RegressionTest> *r,
         if (it.status != 0) {
             r->status = it.status;
         }
-        if (it.url != NULL) {
+        if (it.url != nullptr) {
             r->location.append(it.url);
 	    free(it.url);
-	    it.url = NULL;
+	    it.url = nullptr;
         }
-        if (it.log != NULL) {
+        if (it.log != nullptr) {
             *serverLog << it.log;
             free(it.log);
-            it.log = NULL;
+            it.log = nullptr;
         }
     }
 }
 
-void logCb(void *data, const void *msgv) {
-    const char *msg = reinterpret_cast<const char*>(msgv);
-    std::stringstream *ss = (std::stringstream *) data;
-    *ss << msg << std::endl;
-}
-
-
 void perform_unit_test(ModSecurityTest<RegressionTest> *test,
-    std::vector<RegressionTest *> *tests,
-    ModSecurityTestResults<RegressionTestResult> *res, int *count) {
-
-    for (RegressionTest *t : *tests) {
-        CustomDebugLog *debug_log = new CustomDebugLog();
-        modsecurity::ModSecurity *modsec = NULL;
-        modsecurity::RulesSet *modsec_rules = NULL;
-        modsecurity::Transaction *modsec_transaction = NULL;
+    std::vector<std::unique_ptr<RegressionTest>> &tests,
+    ModSecurityTestResults<RegressionTestResult> *res, int *count)
+{
+    for (auto &t : tests) {
         ModSecurityTestResults<RegressionTest> r;
-        std::stringstream serverLog;
         RegressionTestResult *testRes = new RegressionTestResult();
 
-        testRes->test = t;
+        testRes->test = t.get();
         r.status = 200;
         (*count)++;
 
@@ -169,11 +157,8 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
         unlink("./modsec-shared-collections-lock");
 #endif
 
-        modsec = new modsecurity::ModSecurity();
-        modsec->setConnectorInformation("ModSecurity-regression v0.0.1-alpha" \
+        modsecurity_test::ModSecurityTestContext context("ModSecurity-regression v0.0.1-alpha" \
             " (ModSecurity regression test utility)");
-        modsec->setServerLogCb(logCb);
-        modsec_rules = new modsecurity::RulesSet(debug_log);
 
         bool found = true;
         if (t->resource.empty() == false) {
@@ -196,15 +181,11 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
             }
             res->push_back(testRes);
 
-            delete modsec_transaction;
-            delete modsec_rules;
-            delete modsec;
-
             continue;
         }
 
-        modsec_rules->load("SecDebugLogLevel 9");
-        if (modsec_rules->load(t->rules.c_str(), filename) < 0) {
+        context.m_modsec_rules.load("SecDebugLogLevel 9");
+        if (context.m_modsec_rules.load(t->rules.c_str(), filename) < 0) {
             /* Parser error */
             if (t->parser_error.empty() == true) {
                 /*
@@ -219,21 +200,17 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
                 }
                 testRes->reason << KRED << "parse failed." << RESET \
                     << std::endl;
-                testRes->reason << modsec_rules->getParserError() \
+                testRes->reason << context.m_modsec_rules.getParserError() \
                     << std::endl;
                 testRes->passed = false;
                 res->push_back(testRes);
 
-                delete modsec_transaction;
-                delete modsec_rules;
-                delete modsec;
-
                 continue;
             }
 
             Regex re(t->parser_error);
             SMatch match;
-            std::string s = modsec_rules->getParserError();
+            const auto s = context.m_modsec_rules.getParserError();
 
             if (regex_search(s, &match, re)) {
                 if (test->m_automake_output) {
@@ -247,10 +224,6 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
                 testRes->passed = true;
                 res->push_back(testRes);
 
-                delete modsec_transaction;
-                delete modsec_rules;
-                delete modsec;
-
                 continue;
             } else {
                 /* Parser error was expected, but with a different content */
@@ -271,10 +244,6 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
                 testRes->passed = false;
                 res->push_back(testRes);
 
-                delete modsec_transaction;
-                delete modsec_rules;
-                delete modsec;
-
                 continue;
             }
         } else {
@@ -293,190 +262,136 @@ void perform_unit_test(ModSecurityTest<RegressionTest> *test,
                 testRes->passed = false;
                 res->push_back(testRes);
 
-                delete modsec_transaction;
-                delete modsec_rules;
-                delete modsec;
-
                 continue;
             }
         }
 
-        modsec_transaction = new modsecurity::Transaction(modsec, modsec_rules,
-            &serverLog);
+        auto modsec_transaction = context.create_transaction();
 
-        clearAuditLog(modsec_transaction->m_rules->m_auditLog->m_path1);
+        clearAuditLog(modsec_transaction.m_rules->m_auditLog->m_path1);
 
-        modsec_transaction->processConnection(t->clientIp.c_str(),
+        modsec_transaction.processConnection(t->clientIp.c_str(),
             t->clientPort, t->serverIp.c_str(), t->serverPort);
 
         if (t->hostname != "") {
-            modsec_transaction->setRequestHostName(t->hostname);
+            modsec_transaction.setRequestHostName(t->hostname);
         }
 
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-             goto end;
-        }
-#endif
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-        modsec_transaction->processURI(t->uri.c_str(), t->method.c_str(),
+        modsec_transaction.processURI(t->uri.c_str(), t->method.c_str(),
             t->httpVersion.c_str());
 
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-            goto end;
-        }
-#endif
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-        for (std::pair<std::string, std::string> headers :
-            t->request_headers) {
-            modsec_transaction->addRequestHeader(headers.first.c_str(),
-                headers.second.c_str());
+        for (const auto &[name, value] : t->request_headers) {
+            modsec_transaction.addRequestHeader(name.c_str(),
+                value.c_str());
         }
 
-        modsec_transaction->processRequestHeaders();
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-            goto end;
-        }
-#endif
+        modsec_transaction.processRequestHeaders();
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-        modsec_transaction->appendRequestBody(
+        modsec_transaction.appendRequestBody(
             (unsigned char *)t->request_body.c_str(),
             t->request_body.size());
-        modsec_transaction->processRequestBody();
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-            goto end;
-        }
-#endif
+        modsec_transaction.processRequestBody();
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-        for (std::pair<std::string, std::string> headers :
-            t->response_headers) {
-            modsec_transaction->addResponseHeader(headers.first.c_str(),
-                headers.second.c_str());
+        for (const auto &[name, value] : t->response_headers) {
+            modsec_transaction.addResponseHeader(name.c_str(),
+                value.c_str());
         }
 
-        modsec_transaction->processResponseHeaders(r.status,
+        modsec_transaction.processResponseHeaders(r.status,
             t->response_protocol);
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-            goto end;
-        }
-#endif
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-        modsec_transaction->appendResponseBody(
+        modsec_transaction.appendResponseBody(
             (unsigned char *)t->response_body.c_str(),
             t->response_body.size());
-        modsec_transaction->processResponseBody();
-        actions(&r, modsec_transaction, &serverLog);
-#if 0
-        if (r.status != 200) {
-            goto end;
-        }
-#endif
+        modsec_transaction.processResponseBody();
+        actions(&r, &modsec_transaction, &context.m_server_log);
 
-#if 0
-end:
-#endif
-        modsec_transaction->processLogging();
+        modsec_transaction.processLogging();
 
-        CustomDebugLog *d = reinterpret_cast<CustomDebugLog *>
-            (modsec_rules->m_debugLog);
+        const auto *d = static_cast<CustomDebugLog *>(context.m_modsec_rules.m_debugLog);
 
-        if (d != NULL) {
-            if (!d->contains(t->debug_log)) {
-                if (test->m_automake_output) {
-                    std::cout << ":test-result: FAIL " << filename \
-                        << ":" << t->name << ":" << *count << std::endl;
-                } else {
-                    std::cout << KRED << "failed!" << RESET << std::endl;
-                }
-                testRes->reason << "Debug log was not matching the " \
-                    << "expected results." << std::endl;
-                testRes->reason << KWHT << "Expecting: " << RESET \
-                    << t->debug_log + "";
-                testRes->passed = false;
-            } else if (r.status != t->http_code) {
-                if (test->m_automake_output) {
-                    std::cout << ":test-result: FAIL " << filename \
-                        << ":" << t->name << ":" << *count << std::endl;
-                } else {
-                    std::cout << KRED << "failed!" << RESET << std::endl;
-                }
-                testRes->reason << "HTTP code mismatch. expecting: " + \
-                    std::to_string(t->http_code) + \
-                    " got: " + std::to_string(r.status) + "\n";
-                testRes->passed = false;
-            } else if (!contains(serverLog.str(), t->error_log)) {
-                if (test->m_automake_output) {
-                    std::cout << ":test-result: FAIL " << filename \
-                        << ":" << t->name << std::endl;
-                } else {
-                    std::cout << KRED << "failed!" << RESET << std::endl;
-                }
-                testRes->reason << "Error log was not matching the " \
-                    << "expected results." << std::endl;
-                testRes->reason << KWHT << "Expecting: " << RESET \
-                    << t->error_log + "";
-                testRes->passed = false;
-            } else if (!t->audit_log.empty()
-                && !contains(getAuditLogContent(modsec_transaction->m_rules->m_auditLog->m_path1), t->audit_log)) {
-                if (test->m_automake_output) {
-                    std::cout << ":test-result: FAIL " << filename \
-                        << ":" << t->name << ":" << *count << std::endl;
-                } else {
-                    std::cout << KRED << "failed!" << RESET << std::endl;
-                }
-                testRes->reason << "Audit log was not matching the " \
-                    << "expected results." << std::endl;
-                testRes->reason << KWHT << "Expecting: " << RESET \
-                    << t->audit_log + "";
-                testRes->passed = false;
+        if (!d->contains(t->debug_log)) {
+            if (test->m_automake_output) {
+                std::cout << ":test-result: FAIL " << filename \
+                    << ":" << t->name << ":" << *count << std::endl;
             } else {
-                if (test->m_automake_output) {
-                    std::cout << ":test-result: PASS " << filename \
-                        << ":" << t->name << std::endl;
-                } else {
-                    std::cout << KGRN << "passed!" << RESET << std::endl;
-                }
-                testRes->passed = true;
-                goto after_debug_log;
+                std::cout << KRED << "failed!" << RESET << std::endl;
             }
-
-            if (testRes->passed == false) {
-                testRes->reason << std::endl;
-                testRes->reason << KWHT << "Debug log:" << RESET << std::endl;
-                testRes->reason << d->log_messages() << std::endl;
-                testRes->reason << KWHT << "Error log:" << RESET << std::endl;
-                testRes->reason << serverLog.str() << std::endl;
-                testRes->reason << KWHT << "Audit log:" << RESET << std::endl;
-                testRes->reason << getAuditLogContent(modsec_transaction->m_rules->m_auditLog->m_path1) << std::endl;
+            testRes->reason << "Debug log was not matching the " \
+                << "expected results." << std::endl;
+            testRes->reason << KWHT << "Expecting: " << RESET
+                << t->debug_log + "";
+            testRes->passed = false;
+        } else if (r.status != t->http_code) {
+            if (test->m_automake_output) {
+                std::cout << ":test-result: FAIL " << filename \
+                    << ":" << t->name << ":" << *count << std::endl;
+            } else {
+                std::cout << KRED << "failed!" << RESET << std::endl;
             }
+            testRes->reason << "HTTP code mismatch. expecting: " +
+                std::to_string(t->http_code) +
+                " got: " + std::to_string(r.status) + "\n";
+            testRes->passed = false;
+        } else if (!contains(context.m_server_log.str(), t->error_log)) {
+            if (test->m_automake_output) {
+                std::cout << ":test-result: FAIL " << filename \
+                    << ":" << t->name << std::endl;
+            } else {
+                std::cout << KRED << "failed!" << RESET << std::endl;
+            }
+            testRes->reason << "Error log was not matching the " \
+                << "expected results." << std::endl;
+            testRes->reason << KWHT << "Expecting: " << RESET \
+                << t->error_log + "";
+            testRes->passed = false;
+        } else if (!t->audit_log.empty() && !contains(getAuditLogContent(modsec_transaction.m_rules->m_auditLog->m_path1), t->audit_log)) {
+            if (test->m_automake_output) {
+                std::cout << ":test-result: FAIL " << filename \
+                    << ":" << t->name << ":" << *count << std::endl;
+            } else {
+                std::cout << KRED << "failed!" << RESET << std::endl;
+            }
+            testRes->reason << "Audit log was not matching the " \
+                << "expected results." << std::endl;
+            testRes->reason << KWHT << "Expecting: " << RESET \
+                << t->audit_log + "";
+            testRes->passed = false;
+        } else {
+            if (test->m_automake_output) {
+                std::cout << ":test-result: PASS " << filename \
+                    << ":" << t->name << std::endl;
+            } else  {
+                std::cout << KGRN << "passed!" << RESET << std::endl;
+            }
+            testRes->passed = true;
         }
 
-
-after_debug_log:
-        if (d != NULL) {
-            r.log_raw_debug_log = d->log_messages();
+        if (testRes->passed == false) {
+            testRes->reason << std::endl;
+            testRes->reason << KWHT << "Debug log:" << RESET << std::endl;
+            testRes->reason << d->log_messages() << std::endl;
+            testRes->reason << KWHT << "Error log:" << RESET << std::endl;
+            testRes->reason << context.m_server_log.str() << std::endl;
+            testRes->reason << KWHT << "Audit log:" << RESET << std::endl;
+            testRes->reason << getAuditLogContent(modsec_transaction.m_rules->m_auditLog->m_path1) << std::endl;
         }
 
-        delete modsec_transaction;
-        delete modsec_rules;
-        delete modsec;
-        /* delete debug_log; */
+        r.log_raw_debug_log = d->log_messages();
 
         res->push_back(testRes);
     }
 }
 
-
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
     ModSecurityTest<RegressionTest> test;
 
     std::string ver(MODSECURITY_VERSION);
@@ -541,8 +456,8 @@ int main(int argc, char **argv) {
     int counter = 0;
 
     std::list<std::string> keyList;
-    for (std::pair<std::string, std::vector<RegressionTest *> *> a : test) {
-        keyList.push_back(a.first);
+    for (const auto &[name, tests] : test) {
+        keyList.push_back(name);
     }
     keyList.sort();
 
@@ -556,7 +471,7 @@ int main(int argc, char **argv) {
         test_number++;
         if ((test.m_test_number == 0)
             || (test_number == test.m_test_number)) {
-            std::vector<RegressionTest *> *tests = test[a];
+            auto &tests = test[a];
             perform_unit_test(&test, tests, &res, &counter);
         }
     }
@@ -605,18 +520,10 @@ int main(int argc, char **argv) {
         }
 
         std::cout << KCYN << std::to_string(skipped) << " ";
-		std::cout << "skipped test(s). " << std::to_string(disabled) << " ";
+        std::cout << "skipped test(s). " << std::to_string(disabled) << " ";
         std::cout << "disabled test(s)." << RESET << std::endl;
     }
 
-    for (std::pair<std::string, std::vector<RegressionTest *> *> a : test) {
-        std::vector<RegressionTest *> *vec = a.second;
-        for (int i = 0; i < vec->size(); i++) {
-            delete vec->at(i);
-        }
-        delete vec;
-    }
-
     return failed;
 #endif
 }

test/unit/unit.cc

@@ -32,6 +32,7 @@
 
 #include "test/common/modsecurity_test.h"
 #include "test/common/modsecurity_test_results.h"
+#include "test/common/modsecurity_test_context.h"
 #include "test/common/colors.h"
 #include "test/unit/unit_test.h"
 #include "src/utils/string.h"
@@ -69,8 +70,10 @@ struct OperatorTest {
         return op;
     }
 
-    static UnitTestResult eval(ItemType &op, const UnitTest &t) {
-        return {op.evaluate(nullptr, nullptr, t.input, nullptr), {}};
+    static UnitTestResult eval(ItemType &op, const UnitTest &t, modsecurity::Transaction &transaction) {
+        modsecurity::RuleWithActions rule{nullptr, nullptr, "dummy.conf", -1};
+        modsecurity::RuleMessage ruleMessage{rule, transaction};
+        return {op.evaluate(&transaction, &rule, t.input, ruleMessage), {}};
     }
 
     static bool check(const UnitTestResult &result, const UnitTest &t) {
@@ -89,9 +92,9 @@ struct TransformationTest {
         return tfn;
     }
 
-    static UnitTestResult eval(const ItemType &tfn, const UnitTest &t) {
-        std::string ret = t.input;
-        tfn.transform(ret, nullptr);
+    static UnitTestResult eval(const ItemType &tfn, const UnitTest &t, modsecurity::Transaction &transaction) {
+        auto ret = t.input;
+        tfn.transform(ret, &transaction);
         return {1, ret};
     }
 
@@ -102,16 +105,16 @@ struct TransformationTest {
 
 
 template<typename TestType>
-UnitTestResult perform_unit_test_once(const UnitTest &t) {
+UnitTestResult perform_unit_test_once(const UnitTest &t, modsecurity::Transaction &transaction) {
     std::unique_ptr<typename TestType::ItemType> item(TestType::init(t));
     assert(item.get() != nullptr);
 
-    return TestType::eval(*item.get(), t);
+    return TestType::eval(*item.get(), t, transaction);
 }
 
 
 template<typename TestType>
-UnitTestResult perform_unit_test_multithreaded(const UnitTest &t) {
+UnitTestResult perform_unit_test_multithreaded(const UnitTest &t, modsecurity::Transaction &transaction) {
 
     constexpr auto NUM_THREADS = 50;
     constexpr auto ITERATIONS = 5'000;
@@ -126,10 +129,10 @@ UnitTestResult perform_unit_test_multithreaded(const UnitTest &t) {
     {
         auto &result = results[i];
         threads[i] = std::thread(
-            [&item, &t, &result]()
+            [&item, &t, &result, &transaction]()
             {
                 for (auto j = 0; j != ITERATIONS; ++j)
-                    result = TestType::eval(*item.get(), t);
+                    result = TestType::eval(*item.get(), t, transaction);
             });
     }
 
@@ -150,12 +153,12 @@ UnitTestResult perform_unit_test_multithreaded(const UnitTest &t) {
 
 template<typename TestType>
 void perform_unit_test_helper(const ModSecurityTest<UnitTest> &test, UnitTest &t,
-    ModSecurityTestResults<UnitTest> &res) {
+    ModSecurityTestResults<UnitTest> &res, modsecurity::Transaction &transaction) {
 
     if (!test.m_test_multithreaded)
-        t.result = perform_unit_test_once<TestType>(t);
+        t.result = perform_unit_test_once<TestType>(t, transaction);
     else
-        t.result = perform_unit_test_multithreaded<TestType>(t);
+        t.result = perform_unit_test_multithreaded<TestType>(t, transaction);
 
     if (TestType::check(t.result, t)) {
         res.push_back(&t);
@@ -172,6 +175,11 @@ void perform_unit_test(const ModSecurityTest<UnitTest> &test, UnitTest &t,
     ModSecurityTestResults<UnitTest> &res) {
     bool found = true;
 
+    modsecurity_test::ModSecurityTestContext context("ModSecurity-unit v0.0.1-alpha"
+                                                        " (ModSecurity unit test utility)");
+
+    auto transaction = context.create_transaction();
+
     if (test.m_automake_output) {
         std::cout << ":test-result: ";
     }
@@ -190,9 +198,9 @@ void perform_unit_test(const ModSecurityTest<UnitTest> &test, UnitTest &t,
     }
 
     if (t.type == "op") {
-        perform_unit_test_helper<OperatorTest>(test, t, res);
+        perform_unit_test_helper<OperatorTest>(test, t, res, transaction);
     } else if (t.type == "tfn") {
-        perform_unit_test_helper<TransformationTest>(test, t, res);
+        perform_unit_test_helper<TransformationTest>(test, t, res, transaction);
     } else {
         std::cerr << "Failed. Test type is unknown: << " << t.type;
         std::cerr << std::endl;
@@ -242,8 +250,8 @@ int main(int argc, char **argv) {
     }
 
     for (auto& [filename, tests] : test) {
-        total += tests->size();
-        for (auto t : *tests) {
+        total += tests.size();
+        for (auto &t : tests) {
             ModSecurityTestResults<UnitTest> r;
 
             if (!test.m_automake_output) {
@@ -303,12 +311,5 @@ int main(int argc, char **argv) {
         }
     }
 
-    for (auto a : test) {
-        auto vec = a.second;
-        for(auto t : *vec)
-            delete t;
-        delete vec;
-    }
-
     return failed;
 }