Implement RE2 fallback to libpcre

RE2 doesn't support certain features, like negative lookaround,
so when a regular expression cannot be compiled with RE2, it's
compiled with libpcre instead.

This has some runtime cost, as this fallback is implemented
with an extra heap object and virtual function calls.

When RE2 is not enabled, however, everything works as it did before.

Author: WGH-

src/regex/backend/backend.h

@@ -0,0 +1,43 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2019
+ *
+ * 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 [email protected].
+ *
+ */
+#ifndef SRC_REGEX_BACKEND_BACKEND_H_
+#define SRC_REGEX_BACKEND_BACKEND_H_
+
+#include <list>
+#include <string>
+
+#include "src/regex/regex_match.h"
+
+namespace modsecurity {
+namespace regex {
+namespace backend {
+
+class Backend {
+public:
+    virtual ~Backend() {}
+
+    virtual bool ok(std::string *error = nullptr) const = 0;
+
+    virtual std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const = 0;
+    virtual bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const = 0;
+
+    virtual const std::string& getPattern() const = 0;
+};
+
+}  // namespace backend
+}  // namespace regex
+}  // namespace modsecurity
+
+#endif  // SRC_REGEX_BACKEND_BACKEND_H_

src/regex/backend/pcre.h

@@ -22,6 +22,7 @@
 #include <string>
 #include <list>
 
+#include "src/regex/backend/backend.h"
 #include "src/regex/regex_match.h"
 
 #ifndef SRC_REGEX_BACKEND_PCRE_H_
@@ -33,7 +34,7 @@ namespace backend {
 
 #ifdef WITH_PCRE
 
-class Pcre {
+class Pcre : public Backend {
  public:
     explicit Pcre(const std::string& pattern_);
     ~Pcre();
@@ -42,10 +43,10 @@ class Pcre {
     Pcre(const Pcre&) = delete;
     Pcre& operator=(const Pcre&) = delete;
 
-    std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const;
-    bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const;
+    std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const override;
+    bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const override;
 
-    bool ok(std::string *error = nullptr) const {
+    bool ok(std::string *error = nullptr) const override {
         if (m_pc != NULL) {
             return true;
         }
@@ -56,7 +57,7 @@ class Pcre {
         return false;
     }
 
-    const std::string& getPattern() const {
+    const std::string& getPattern() const override {
         return pattern;
     };
  private:

src/regex/backend/re2.cc

@@ -29,6 +29,10 @@ namespace backend {
 static RE2::Options get_re2_options() {
     RE2::Options res;
 
+    // Re2 is usually used with fallback to libpcre,
+    // so disable unnecessary stderr noise
+    res.set_log_errors(false);
+
     res.set_dot_nl(true);
 
     return res;

src/regex/backend/re2.h

@@ -20,6 +20,7 @@
 #include <string>
 #include <list>
 
+#include "src/regex/backend/backend.h"
 #include "src/regex/regex_match.h"
 
 #ifndef SRC_REGEX_BACKEND_RE2_H_
@@ -31,18 +32,18 @@ namespace backend {
 
 #ifdef WITH_RE2
 
-class Re2 {
+class Re2 : public Backend {
  public:
     explicit Re2(const std::string& pattern_);
 
     // RE2 class is not copyable, so neither is this
     Re2(const Re2&) = delete;
     Re2& operator=(const Re2&) = delete;
 
-    std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const;
-    bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const;
+    std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const override;
+    bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const override;
 
-    bool ok(std::string *error = nullptr) const {
+    bool ok(std::string *error = nullptr) const override {
         if (re.ok()) {
             return true;
         }
@@ -52,7 +53,7 @@ class Re2 {
         return false;
     }
 
-    const std::string& getPattern() const {
+    const std::string& getPattern() const override {
         return re.pattern();
     };
  private:

src/regex/backend_fallback.h

@@ -0,0 +1,70 @@
+/*
+ * ModSecurity, http://www.modsecurity.org/
+ * Copyright (c) 2019
+ *
+ * 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 [email protected].
+ *
+ */
+#ifndef SRC_REGEX_BACKEND_FALLBACK_H_
+#define SRC_REGEX_BACKEND_FALLBACK_H_
+
+#include <memory>
+
+#include "src/regex/backend/backend.h"
+
+namespace modsecurity {
+namespace regex {
+
+template<typename T>
+static backend::Backend* compile_regex_fallback(const std::string& pattern) {
+    return new T(pattern);
+}
+
+template<typename T, typename T2, typename... Args>
+static backend::Backend* compile_regex_fallback(const std::string& pattern) {
+    T *regex = new T{pattern};
+    if (regex->ok()) {
+        return regex;
+    } else {
+        delete regex;
+        return compile_regex_fallback<T2, Args...>(pattern);
+    }
+}
+
+template<typename... Args>
+class BackendFallback : public backend::Backend {
+public:
+    BackendFallback(const std::string& pattern)
+        : backend(compile_regex_fallback<Args...>(pattern))
+    {}
+
+    virtual bool ok(std::string *error = nullptr) const override {
+        return backend->ok(error);
+    }
+
+    std::vector<RegexMatch> searchAll(const std::string& s, bool overlapping = false) const override {
+        return backend->searchAll(s, overlapping);
+    }
+
+    bool search(const std::string &s, RegexMatch *m = nullptr, ssize_t max_groups = -1) const override {
+        return backend->search(s, m, max_groups);
+    }
+
+    const std::string& getPattern() const override {
+        return backend->getPattern();
+    }
+private:
+    std::unique_ptr<backend::Backend> backend;
+};
+
+}  // namespace regex
+}  // namespace modsecurity
+
+#endif // SRC_REGEX_BACKEND_FALLBACK_H_

src/regex/regex.h

@@ -20,9 +20,11 @@
 #include <string>
 #include <list>
 
+#include "src/regex/backend/backend.h"
 #include "src/regex/backend/pcre.h"
 #include "src/regex/backend/re2.h"
 #include "src/regex/regex_match.h"
+#include "src/regex/backend_fallback.h"
 
 #ifndef SRC_REGEX_REGEX_H_
 #define SRC_REGEX_REGEX_H_
@@ -31,12 +33,16 @@
 namespace modsecurity {
 namespace regex {
 
-#ifdef WITH_PCRE
-using selectedBackend = backend::Pcre;
-#elif WITH_RE2
-using selectedBackend = backend::Re2;
+#if defined(WITH_PCRE) && defined(WITH_RE2)
+    using selectedBackend = BackendFallback<
+        backend::Re2, backend::Pcre
+    >;
+#elif defined(WITH_RE2)
+    using selectedBackend = backend::Re2;
+#elif defined(WITH_PCRE)
+    using selectedBackend = backend::Pcre;
 #else
-#error "no regex backend selected"
+#error "No regexp backend available. Enable either libpcre or re2."
 #endif
 
 class Regex : public selectedBackend {