Update extensions & release 1.0.0-rc (#281)

plugins/wasm-cpp/common/BUILD

@@ -1,3 +1,17 @@
+# Copyright (c) 2022 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# 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
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 cc_library(
     name = "common_util",
     hdrs = [
@@ -38,7 +52,7 @@ cc_library(
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/strings:str_format",
-        "@proxy_wasm_cpp_host//:lib",
+        "@proxy_wasm_cpp_host//:null_lib",
     ],
 )
 

plugins/wasm-cpp/common/http_util.cc

@@ -20,6 +20,8 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_split.h"
 
+#include "common/common_util.h"
+
 namespace Wasm::Common::Http {
 
 std::string_view stripPortFromHost(std::string_view request_host) {
@@ -188,7 +190,7 @@ std::vector<std::string> getAllOfHeader(std::string_view key) {
   std::vector<std::string> result;
   auto headers = getRequestHeaderPairs()->pairs();
   for (auto& header : headers) {
-    if (absl::EqualsIgnoreCase(header.first, key)) {
+    if (absl::EqualsIgnoreCase(Wasm::Common::stdToAbsl(header.first), Wasm::Common::stdToAbsl(key))) {
       result.push_back(std::string(header.second));
     }
   }
@@ -197,7 +199,7 @@ std::vector<std::string> getAllOfHeader(std::string_view key) {
 
 void forEachCookie(
     std::string_view cookie_header,
-    const std::function<bool(absl::string_view, absl::string_view)>&
+    const std::function<bool(std::string_view, std::string_view)>&
         cookie_consumer) {
   auto cookie_headers = getAllOfHeader(cookie_header);
 
@@ -223,7 +225,7 @@ void forEachCookie(
         v = v.substr(1, v.size() - 2);
       }
 
-      if (!cookie_consumer(k, v)) {
+      if (!cookie_consumer(Wasm::Common::abslToStd(k), Wasm::Common::abslToStd(v))) {
         return;
       }
     }
@@ -263,7 +265,7 @@ std::string buildOriginalUri(std::optional<uint32_t> max_path_length) {
   auto scheme = scheme_ptr->view();
   auto host_ptr = getRequestHeader(Header::Host);
   auto host = host_ptr->view();
-  return absl::StrCat(scheme, "://", host, final_path);
+  return absl::StrCat(Wasm::Common::stdToAbsl(scheme), "://", Wasm::Common::stdToAbsl(host),  Wasm::Common::stdToAbsl(final_path));
 }
 
 }  // namespace Wasm::Common::Http

plugins/wasm-cpp/common/regex.h

@@ -29,17 +29,20 @@ class CompiledGoogleReMatcher {
                           bool do_program_size_check = true)
       : regex_(regex, re2::RE2::Quiet) {
     if (!regex_.ok()) {
-      throw std::runtime_error(regex_.error());
+      error_ = regex_.error();
+      return;
     }
     if (do_program_size_check) {
       const auto regex_program_size =
           static_cast<uint32_t>(regex_.ProgramSize());
       if (regex_program_size > 100) {
-        throw std::runtime_error("too complex regex: " + regex);
+        error_ = "too complex regex: " + regex;
       }
     }
   }
 
+  const std::string& error() const { return error_; }
+
   bool match(std::string_view value) const {
     return re2::RE2::FullMatch(re2::StringPiece(value.data(), value.size()),
                                regex_);
@@ -56,6 +59,7 @@ class CompiledGoogleReMatcher {
 
  private:
   const re2::RE2 regex_;
+  std::string error_;
 };
 
 }  // namespace Wasm::Common::Regex

plugins/wasm-cpp/common/route_rule_matcher.h

@@ -126,6 +126,12 @@ class RouteRuleMatcher {
       LOG_DEBUG("no match config");
       return true;
     }
+    if (!config.second && global_auth_ && !global_auth_.value()) {
+      // No allow set, means no need to check auth if global_auth is false
+      LOG_DEBUG(
+          "no allow set found, and global auth is false, no need to auth");
+      return true;
+    }
     return checkPlugin(config.first.value(), config.second);
   }
 
@@ -220,8 +226,9 @@ class RouteRuleMatcher {
         break;
       }
     }
-    return is_matched ? std::make_pair(match_config, allow_set)
-                      : std::make_pair(std::nullopt, std::nullopt);
+    return is_matched || (global_auth_ && global_auth_.value())
+               ? std::make_pair(match_config, allow_set)
+               : std::make_pair(std::nullopt, std::nullopt);
   }
 
   void setEmptyGlobalConfig() { global_config_ = PluginConfig{}; }
@@ -288,6 +295,18 @@ class RouteRuleMatcher {
       has_rules = true;
       key_count--;
     }
+    auto auth_it = config.find("global_auth");
+    if (auth_it != config.end()) {
+      auto global_auth_value = JsonValueAs<bool>(auth_it.value());
+      if (global_auth_value.second !=
+              Wasm::Common::JsonParserResultDetail::OK ||
+          !global_auth_value.first) {
+        LOG_WARN(
+            "failed to parse 'global_auth' field in filter configuration.");
+        return false;
+      }
+      global_auth_ = global_auth_value.first.value();
+    }
     PluginConfig plugin_config;
     // has other config fields
     if (key_count > 0 && parsePluginConfig(config, plugin_config)) {
@@ -455,6 +474,7 @@ class RouteRuleMatcher {
   }
 
   bool invalid_config_ = false;
+  std::optional<bool> global_auth_ = std::nullopt;
   std::vector<RuleConfig> rule_config_;
   std::vector<AuthRuleConfig> auth_rule_config_;
   std::optional<PluginConfig> global_config_ = std::nullopt;