Changes the check script to detect segfaults

src/operators/ip_match_f.h

@@ -29,7 +29,7 @@ class IpMatchF : public IpMatchFromFile {
     IpMatchF(std::string op, std::string param, bool negation)
         : IpMatchFromFile(op, param, negation) { }
     explicit IpMatchF(std::string param)
-        : IpMatchFromFile("IpMatchFromFile", param) { }
+        : IpMatchFromFile("IpMatchFromF", param) { }
 };
 
 }  // namespace operators

src/operators/ip_match_from_file.h

@@ -29,6 +29,8 @@ class IpMatchFromFile : public IpMatch {
         : IpMatch(op, param, negation) { }
     IpMatchFromFile(std::string op, std::string param)
         : IpMatch(op, param) { }
+    IpMatchFromFile(std::string param)
+        : IpMatch("IpMatchFromFile", param) { }
 
     bool init(const std::string& file, std::string *error) override;
 };

src/operators/no_match.h

@@ -31,6 +31,8 @@ class NoMatch : public Operator {
     /** @ingroup ModSecurity_Operator */
     NoMatch(std::string op, std::string param, bool negation)
         : Operator(op, param, negation) { }
+    NoMatch()
+        : Operator("NoMatch") { }
 
     bool evaluate(Transaction *transaction, const std::string &str) override;
 };

src/operators/operator.cc

@@ -21,6 +21,7 @@
 
 #include "modsecurity/transaction.h"
 
+#include "src/utils/string.h"
 #include "src/operators/begins_with.h"
 #include "src/operators/contains.h"
 #include "src/operators/contains_word.h"
@@ -113,105 +114,67 @@ bool Operator::evaluate(Transaction *transaction, const std::string& a) {
     if (transaction) {
         transaction->debug(2, "Operator: " + this->m_op + \
             " is not implemented or malfunctioning.");
-    } else {
-        std::cerr << "Operator: " + this->m_op + \
-            " is not implemented or malfunctioning.";
     }
 #endif
 
     return true;
 }
 
-Operator *Operator::instantiate(std::string op_string) {
+Operator *Operator::instantiate(std::string op, std::string param) {
-    // Sanity check.
+    std::string op_ = utils::string::tolower(op);
-    if (op_string.size() <= 2) {
-        return NULL;
-    }
 
-    std::string op = op_string;
+    IF_MATCH(beginswith) { return new BeginsWith(param); }
-    op = op.substr(1, op_string.size() - 2);
+    IF_MATCH(contains) { return new Contains(param); }
-
+    IF_MATCH(containsword) { return new ContainsWord(param); }
-    // We assume no negation by default
+    IF_MATCH(detectsqli) { return new DetectSQLi(); }
-    bool negation = false;
+    IF_MATCH(detectxss) { return new DetectXSS(); }
-    // If there is a '!' in front substring and assign negation
+    IF_MATCH(endswith) { return new EndsWith(param); }
-    if (op.at(0) == '!') {
+    IF_MATCH(eq) { return new Eq(param); }
-       op = op.substr(1, op.size() - 1);
+    IF_MATCH(fuzzyhash) { return new FuzzyHash(param); }
-       negation = true;
+    IF_MATCH(geolookup) { return new GeoLookup(param); }
-    }
+    IF_MATCH(ge) { return new Ge(param); }
-
+    IF_MATCH(gsblookup) { return new GsbLookup(param); }
-    // Check to see if there is a parameter, if not param is an empty string
+    IF_MATCH(gt) { return new Gt(param); }
-    std::string param = "";
+    IF_MATCH(inspectfile) { return new InspectFile(param); }
-    if (op.find(" ") != std::string::npos) {
+    IF_MATCH(ipmatchf) { return new IpMatchF(param); }
-        param = op;
-        param.erase(0, param.find(" ") + 1);
-        op.erase(op.find(" "),
-            op.length() - op.find(" "));
-    }
-
-    for (std::basic_string<char>::iterator p = op.begin();
-        p != op.end(); ++p) {
-       *p = tolower(*p);
-    }
-    std::string op_ = op;
-    if (op_.length() > 2) {
-        op_.erase(0, 1);
-        if (op_.back() == ' ') {
-            op_.pop_back();
-        }
-    }
-
-    IF_MATCH(beginswith) { return new BeginsWith(op, param, negation); }
-    IF_MATCH(contains) { return new Contains(op, param, negation); }
-    IF_MATCH(containsword) { return new ContainsWord(op, param, negation); }
-    IF_MATCH(detectsqli) { return new DetectSQLi(op, param, negation); }
-    IF_MATCH(detectxss) { return new DetectXSS(op, param, negation); }
-    IF_MATCH(endswith) { return new EndsWith(op, param, negation); }
-    IF_MATCH(eq) { return new Eq(op, param, negation); }
-    IF_MATCH(fuzzyhash) { return new FuzzyHash(op, param, negation); }
-    IF_MATCH(geolookup) { return new GeoLookup(op, param, negation); }
-    IF_MATCH(ge) { return new Ge(op, param, negation); }
-    IF_MATCH(gsblookup) { return new GsbLookup(op, param, negation); }
-    IF_MATCH(gt) { return new Gt(op, param, negation); }
-    IF_MATCH(inspectfile) { return new InspectFile(op, param, negation); }
-    IF_MATCH(ipmatchf) { return new IpMatchF(op, param, negation); }
     IF_MATCH(ipmatchfromfile) {
-        return new IpMatchFromFile(op, param, negation);
+        return new IpMatchFromFile(param);
     }
-    IF_MATCH(ipmatch) { return new IpMatch(op, param, negation); }
+    IF_MATCH(ipmatch) { return new IpMatch(param); }
-    IF_MATCH(le) { return new Le(op, param, negation); }
+    IF_MATCH(le) { return new Le(param); }
-    IF_MATCH(lt) { return new Lt(op, param, negation); }
+    IF_MATCH(lt) { return new Lt(param); }
-    IF_MATCH(nomatch) { return new NoMatch(op, param, negation); }
+    IF_MATCH(nomatch) { return new NoMatch(); }
-    IF_MATCH(pmf) { return new PmF(op, param, negation); }
+    IF_MATCH(pmfromfile) { return new PmFromFile(param); }
-    IF_MATCH(pmfromfile) { return new PmFromFile(op, param, negation); }
+    IF_MATCH(pmf) { return new PmF(param); }
-    IF_MATCH(pm) { return new Pm(op, param, negation); }
+    IF_MATCH(pm) { return new Pm(param); }
-    IF_MATCH(rbl) { return new Rbl(op, param, negation); }
+    IF_MATCH(rbl) { return new Rbl(param); }
-    IF_MATCH(rsub) { return new Rsub(op, param, negation); }
+    IF_MATCH(rsub) { return new Rsub(param); }
-    IF_MATCH(rx) { return new Rx(op, param, negation); }
+    IF_MATCH(rx) { return new Rx(param); }
-    IF_MATCH(streq) { return new StrEq(op, param, negation); }
+    IF_MATCH(streq) { return new StrEq(param); }
-    IF_MATCH(strmatch) { return new StrMatch(op, param, negation); }
+    IF_MATCH(strmatch) { return new StrMatch(param); }
     IF_MATCH(validatebyterange) {
-        return new ValidateByteRange(op, param, negation);
+        return new ValidateByteRange(param);
     }
-    IF_MATCH(validatedtd) { return new ValidateDTD(op, param, negation); }
+    IF_MATCH(validatedtd) { return new ValidateDTD(param); }
-    IF_MATCH(validatehash) { return new ValidateHash(op, param, negation); }
+    IF_MATCH(validatehash) { return new ValidateHash(param); }
-    IF_MATCH(validateschema) { return new ValidateSchema(op, param, negation); }
+    IF_MATCH(validateschema) { return new ValidateSchema(param); }
     IF_MATCH(validateurlencoding) {
-        return new ValidateUrlEncoding(op, param, negation);
+        return new ValidateUrlEncoding();
     }
     IF_MATCH(validateutf8encoding) {
-        return new ValidateUtf8Encoding(op, param, negation);
+        return new ValidateUtf8Encoding();
     }
-    IF_MATCH(verifycc) { return new VerifyCC(op, param, negation); }
+    IF_MATCH(verifycc) { return new VerifyCC(param); }
-    IF_MATCH(verifycpf) { return new VerifyCPF(op, param, negation); }
+    IF_MATCH(verifycpf) { return new VerifyCPF(param); }
-    IF_MATCH(verifyssn) { return new VerifySSN(op, param, negation); }
+    IF_MATCH(verifyssn) { return new VerifySSN(param); }
-    IF_MATCH(within) { return new Within(op, param, negation); }
+    IF_MATCH(within) { return new Within(param); }
 
     IF_MATCH(unconditionalmatch) {
-        return new UnconditionalMatch(op, param, negation);
+        return new UnconditionalMatch();
     }
 
 
-    return new Operator(op, param, negation);
+    return new Operator(param);
 }
 
 }  // namespace operators

src/operators/operator.h

@@ -53,7 +53,7 @@ class Operator {
         m_param() { }
 
     virtual ~Operator() { }
-    static Operator *instantiate(std::string opName);
+    static Operator *instantiate(std::string opName, std::string param);
 
     virtual bool init(const std::string &arg, std::string *error) {
         return true;

src/operators/pm_f.h

@@ -30,6 +30,8 @@ class PmF : public PmFromFile {
     /** @ingroup ModSecurity_Operator */
     PmF(std::string op, std::string param, bool negation)
         : PmFromFile(op, param, negation) { }
+    explicit PmF(std::string param)
+        : PmFromFile("PmFromF", param) { }
 };
 
 

src/operators/pm_from_file.h

@@ -30,6 +30,8 @@ class PmFromFile : public Pm {
     /** @ingroup ModSecurity_Operator */
     PmFromFile(std::string op, std::string param, bool negation)
         : Pm(op, param, negation) { }
+    PmFromFile(std::string op, std::string param)
+        : Pm(op, param) { }
     explicit PmFromFile(std::string param)
         : Pm("PmFromFile", param) { }
     bool init(const std::string &file, std::string *error) override;

test/common/modsecurity_test.cc

@@ -141,7 +141,10 @@ void ModSecurityTest<T>::cmd_options(int argc, char **argv) {
         i++;
         m_automake_output = true;
     }
-
+    if (argc > i && strcmp(argv[i], "countall") == 0) {
+        i++;
+        m_count_all = true;
+    }
     if (const char* env_p = std::getenv("AUTOMAKE_TESTS")) {
         m_automake_output = true;
     }

test/common/modsecurity_test.h

@@ -33,7 +33,8 @@ template <class T> class ModSecurityTest :
  public:
     ModSecurityTest()
         : m_test_number(0),
-        m_automake_output(false) { }
+        m_automake_output(false),
+        m_count_all(false) { }
 
     std::string header();
     void cmd_options(int, char **);
@@ -45,6 +46,7 @@ template <class T> class ModSecurityTest :
     bool verbose = false;
     bool color = false;
     int m_test_number;
+    bool m_count_all;
     bool m_automake_output;
 };
 

test/regression/regression.cc

@@ -397,13 +397,13 @@ int main(int argc, char **argv) {
         << std::endl;
 #else
     test.cmd_options(argc, argv);
-    if (!test.m_automake_output) {
+    if (!test.m_automake_output && !test.m_count_all) {
         std::cout << test.header();
     }
 
     test.load_tests();
 
-    if (!test.m_automake_output) {
+    if (!test.m_automake_output && !test.m_count_all) {
         std::cout << std::setw(4) << std::right << "# ";
         std::cout << std::setw(50) << std::left << "File Name";
         std::cout << std::setw(70) << std::left << "Test Name";
@@ -423,6 +423,11 @@ int main(int argc, char **argv) {
     }
     keyList.sort();
 
+    if (test.m_count_all) {
+        std::cout << std::to_string(keyList.size()) << std::endl;
+        exit(0);
+    }
+
     ModSecurityTestResults<RegressionTestResult> res;
     for (std::string &a : keyList) {
         test_number++;

test/test-suite.sh

@@ -10,8 +10,14 @@ FILE=${@: -1}
 
 if [[ $FILE == *"test-cases/regression/"* ]]
 then
-      $VALGRIND $PARAM ./regression_tests ../$FILE
+    AMOUNT=$(./regression_tests countall ../$FILE)
-      echo $VALGRIND $PARAM ./regression_tests ../$FILE
+    for i in `seq 1 $AMOUNT`; do
+        $VALGRIND $PARAM ./regression_tests ../$FILE:$i
+        if [ $? -eq 139 ]; then
+            echo ":test-result: FAIL segfault: ../$FILE:$i"
+        fi
+        echo $VALGRIND $PARAM ./regression_tests ../$FILE:$i
+    done;
 else
       $VALGRIND $PARAM ./unit_tests ../$FILE
 fi

test/unit/unit.cc

@@ -144,10 +144,9 @@ void perform_unit_test(ModSecurityTest<UnitTest> *test, UnitTest *t,
     }
 
     if (t->type == "op") {
-        Operator *op = Operator::instantiate("\"@" + t->name + \
+        Operator *op = Operator::instantiate(t->name, t->param);
-                " " + t->param + "\"");
         op->init(t->filename, &error);
-        int ret = op->evaluate(NULL, t->input);
+        int ret = op->evaluate(NULL, NULL, t->input, NULL);
         t->obtained = ret;
         if (ret != t->ret) {
             res->push_back(t);