Convert cachekey plugin to use Regex class (PCRE2) instead of PCRE (#12607)

Author: bryancall

plugins/cachekey/pattern.cc

@@ -18,7 +18,7 @@
 
 /**
  * @file pattern.cc
- * @brief PRCE related classes.
+ * @brief Regex related classes.
  * @see pattern.h
  */
 
@@ -41,16 +41,14 @@ replaceString(String &str, const String &from, const String &to)
 Pattern::Pattern() : _pattern(""), _replacement("") {}
 
 /**
- * @brief Initializes PCRE pattern by providing the subject and replacement strings.
- * @param pattern PCRE pattern, a string containing PCRE patterns, capturing groups.
- * @param replacement PCRE replacement, a string where $0 ... $9 will be replaced with the corresponding capturing groups
+ * @brief Initializes Regex pattern by providing the subject and replacement strings.
+ * @param pattern Regex pattern, a string containing regex patterns, capturing groups.
+ * @param replacement Regex replacement, a string where $0 ... $9 will be replaced with the corresponding capturing groups
  * @return true if successful, false if failure
  */
 bool
 Pattern::init(const String &pattern, const String &replacement, bool replace)
 {
-  pcreFree();
-
   _pattern.assign(pattern);
   _replacement.assign(replacement);
   _replace = replace;
@@ -59,17 +57,16 @@ Pattern::init(const String &pattern, const String &replacement, bool replace)
 
   if (!compile()) {
     CacheKeyDebug("failed to initialize pattern:'%s', replacement:'%s'", pattern.c_str(), replacement.c_str());
-    pcreFree();
     return false;
   }
 
   return true;
 }
 
 /**
- * @brief Initializes PCRE pattern by providing the pattern only or pattern+replacement in a single configuration string.
+ * @brief Initializes Regex pattern by providing the pattern only or pattern+replacement in a single configuration string.
  * @see init()
- * @param config PCRE pattern <pattern> or PCRE pattern + replacement in format /<pattern>/<replacement>/
+ * @param config Regex pattern <pattern> or Regex pattern + replacement in format /<pattern>/<replacement>/
  * @return true if successful, false if failure
  */
 bool
@@ -130,32 +127,7 @@ Pattern::init(const String &config)
 bool
 Pattern::empty() const
 {
-  return _pattern.empty() || nullptr == _re;
-}
-
-/**
- * @brief Frees PCRE library related resources.
- */
-void
-Pattern::pcreFree()
-{
-  if (_re) {
-    pcre_free(_re);
-    _re = nullptr;
-  }
-
-  if (_extra) {
-    pcre_free(_extra);
-    _extra = nullptr;
-  }
-}
-
-/**
- * @brief Destructor, frees PCRE related resources.
- */
-Pattern::~Pattern()
-{
-  pcreFree();
+  return _pattern.empty() || _re.empty();
 }
 
 /**
@@ -198,23 +170,23 @@ Pattern::process(const String &subject, StringVector &result)
 }
 
 /**
- * @brief PCRE matches a subject string against the regex pattern.
- * @param subject PCRE subject
+ * @brief Regex matches a subject string against the regex pattern.
+ * @param subject Regex subject
  * @return true - matched, false - did not.
  */
 bool
 Pattern::match(const String &subject)
 {
-  int matchCount;
   CacheKeyDebug("matching '%s' to '%s'", _pattern.c_str(), subject.c_str());
 
-  if (!_re) {
+  if (_re.empty()) {
     return false;
   }
 
-  matchCount = pcre_exec(_re, _extra, subject.c_str(), subject.length(), 0, PCRE_NOTEMPTY, nullptr, 0);
+  RegexMatches matches;
+  int          matchCount = _re.exec(subject, matches, RE_NOTEMPTY);
   if (matchCount < 0) {
-    if (matchCount != PCRE_ERROR_NOMATCH) {
+    if (matchCount != RE_ERROR_NOMATCH) {
       CacheKeyError("matching error %d", matchCount);
     }
     return false;
@@ -224,66 +196,60 @@ Pattern::match(const String &subject)
 }
 
 /**
- * @brief Return all PCRE capture groups that matched in the subject string
- * @param subject PCRE subject string
+ * @brief Return all Regex capture groups that matched in the subject string
+ * @param subject Regex subject string
  * @param result reference to vector of strings containing all capture groups
  */
 bool
 Pattern::capture(const String &subject, StringVector &result)
 {
-  int matchCount;
-  int ovector[OVECOUNT];
-
   CacheKeyDebug("capturing '%s' from '%s'", _pattern.c_str(), subject.c_str());
 
-  if (!_re) {
+  if (_re.empty()) {
     CacheKeyError("regular expression not initialized");
     return false;
   }
 
-  matchCount = pcre_exec(_re, nullptr, subject.c_str(), subject.length(), 0, PCRE_NOTEMPTY, ovector, OVECOUNT);
+  RegexMatches matches;
+  int          matchCount = _re.exec(subject, matches, RE_NOTEMPTY);
   if (matchCount < 0) {
-    if (matchCount != PCRE_ERROR_NOMATCH) {
+    if (matchCount != RE_ERROR_NOMATCH) {
       CacheKeyError("matching error %d", matchCount);
     }
     return false;
   }
 
   for (int i = 0; i < matchCount; i++) {
-    int start  = ovector[2 * i];
-    int length = ovector[2 * i + 1] - ovector[2 * i];
+    std::string_view capture = matches[i];
+    String           dst(capture.data(), capture.length());
 
-    String dst(subject, start, length);
-
-    CacheKeyDebug("capturing '%s' %d[%d,%d]", dst.c_str(), i, ovector[2 * i], ovector[2 * i + 1]);
+    CacheKeyDebug("capturing '%s' %d", dst.c_str(), i);
     result.push_back(dst);
   }
 
   return true;
 }
 
 /**
- * @brief Replaces all replacements found in the replacement string with what matched in the PCRE capturing groups.
- * @param subject PCRE subject string
+ * @brief Replaces all replacements found in the replacement string with what matched in the Regex capturing groups.
+ * @param subject Regex subject string
  * @param result reference to A string where the result of the replacement will be stored
  * @return true - success, false - nothing matched or failure.
  */
 bool
 Pattern::replace(const String &subject, String &result)
 {
-  int matchCount;
-  int ovector[OVECOUNT];
-
   CacheKeyDebug("replacing:'%s' in pattern:'%s', subject:'%s'", _replacement.c_str(), _pattern.c_str(), subject.c_str());
 
-  if (!_re || !_replace) {
+  if (_re.empty() || !_replace) {
     CacheKeyError("regular expression not initialized or not configured to replace");
     return false;
   }
 
-  matchCount = pcre_exec(_re, nullptr, subject.c_str(), subject.length(), 0, PCRE_NOTEMPTY, ovector, OVECOUNT);
+  RegexMatches matches;
+  int          matchCount = _re.exec(subject, matches, RE_NOTEMPTY);
   if (matchCount < 0) {
-    if (matchCount != PCRE_ERROR_NOMATCH) {
+    if (matchCount != RE_ERROR_NOMATCH) {
       CacheKeyError("matching error %d", matchCount);
     }
     return false;
@@ -299,18 +265,11 @@ Pattern::replace(const String &subject, String &result)
 
   int previous = 0;
   for (int i = 0; i < _tokenCount; i++) {
-    int replIndex = _tokens[i];
-    int start     = ovector[2 * replIndex];
-    int length    = ovector[2 * replIndex + 1] - ovector[2 * replIndex];
-
-    /* Handle the case when no match / a group capture result in an empty string */
-    if (start < 0) {
-      start  = 0;
-      length = 0;
-    }
+    int              replIndex = _tokens[i];
+    std::string_view capture   = matches[replIndex];
 
     String src(_replacement, _tokenOffset[i], 2);
-    String dst(subject, start, length);
+    String dst(capture.data(), capture.length());
 
     CacheKeyDebug("replacing '%s' with '%s'", src.c_str(), dst.c_str());
 
@@ -328,37 +287,20 @@ Pattern::replace(const String &subject, String &result)
 }
 
 /**
- * @brief PCRE compiles the regex, called only during initialization.
+ * @brief Compiles the regex, called only during initialization.
  * @return true if successful, false if not.
  */
 bool
 Pattern::compile()
 {
-  const char *errPtr;    /* PCRE error */
-  int         errOffset; /* PCRE error offset */
+  std::string error;
+  int         errOffset;
 
   CacheKeyDebug("compiling pattern:'%s', replace: %s, replacement:'%s'", _pattern.c_str(), _replace ? "true" : "false",
                 _replacement.c_str());
 
-  _re = pcre_compile(_pattern.c_str(), /* the pattern */
-                     0,                /* options */
-                     &errPtr,          /* for error message */
-                     &errOffset,       /* for error offset */
-                     nullptr);         /* use default character tables */
-
-  if (nullptr == _re) {
-    CacheKeyError("compile of regex '%s' at char %d: %s", _pattern.c_str(), errOffset, errPtr);
-
-    return false;
-  }
-
-  _extra = pcre_study(_re, 0, &errPtr);
-
-  if ((nullptr == _extra) && (nullptr != errPtr) && (0 != *errPtr)) {
-    CacheKeyError("failed to study regex '%s': %s", _pattern.c_str(), errPtr);
-
-    pcre_free(_re);
-    _re = nullptr;
+  if (!_re.compile(_pattern, error, errOffset)) {
+    CacheKeyError("compile of regex '%s' at char %d: %s", _pattern.c_str(), errOffset, error.c_str());
     return false;
   }
 
@@ -394,10 +336,6 @@ Pattern::compile()
     }
   }
 
-  if (!success) {
-    pcreFree();
-  }
-
   return success;
 }
 

plugins/cachekey/pattern.h

@@ -18,32 +18,26 @@
 
 /**
  * @file pattern.h
- * @brief PRCE related classes (header file).
+ * @brief Regex related classes (header file).
  */
 
 #pragma once
 
 #include "tscore/ink_defs.h"
-
-#ifdef HAVE_PCRE_PCRE_H
-#include <pcre/pcre.h>
-#else
-#include <pcre.h>
-#endif
+#include "tsutil/Regex.h"
 
 #include "common.h"
 
 /**
- * @brief PCRE matching, capturing and replacing
+ * @brief Regex matching, capturing and replacing
  */
 class Pattern
 {
 public:
-  static const int TOKENCOUNT = 10;             /**< @brief Capturing groups $0..$9 */
-  static const int OVECOUNT   = TOKENCOUNT * 3; /**< @brief pcre_exec() array count, handle 10 capture groups */
+  static const int TOKENCOUNT = 10; /**< @brief Capturing groups $0..$9 */
 
   Pattern();
-  virtual ~Pattern();
+  ~Pattern() = default;
 
   bool init(const String &pattern, const String &replacement, bool replace);
   bool init(const String &config);
@@ -55,13 +49,12 @@ class Pattern
 
 private:
   bool compile();
-  void pcreFree();
 
-  pcre       *_re    = nullptr; /**< @brief PCRE compiled info structure, computed during initialization */
-  pcre_extra *_extra = nullptr; /**< @brief PCRE study data block, computed during initialization */
+  Regex _re; /**< @brief Regex compiled object */
 
-  String _pattern;     /**< @brief PCRE pattern string, containing PCRE patterns and capturing groups. */
-  String _replacement; /**< @brief PCRE replacement string, containing $0..$9 to be replaced with content of the capturing groups */
+  String _pattern; /**< @brief Regex pattern string, containing regex patterns and capturing groups. */
+  String
+    _replacement; /**< @brief Regex replacement string, containing $0..$9 to be replaced with content of the capturing groups */
 
   bool _replace = false; /**< @brief true if a replacement is needed, false if not, this is to distinguish between an empty
                     replacement string and no replacement needed case */