grpc 1.35.0 → 1.36.0

data/src/core/lib/iomgr/ev_epollex_linux.cc

@@ -537,7 +537,7 @@ static void fd_notify_on_error(grpc_fd* fd, grpc_closure* closure) {
 
 static bool fd_has_pollset(grpc_fd* fd, grpc_pollset* pollset) {
   const int epfd = pollset->active_pollable->epfd;
-  grpc_core::MutexLock lock(&fd->pollable_mu);
+  grpc_core::MutexLockForGprMu lock(&fd->pollable_mu);
   for (size_t i = 0; i < fd->pollset_fds.size(); ++i) {
     if (fd->pollset_fds[i] == epfd) {
       return true;
@@ -548,7 +548,7 @@ static bool fd_has_pollset(grpc_fd* fd, grpc_pollset* pollset) {
 
 static void fd_add_pollset(grpc_fd* fd, grpc_pollset* pollset) {
   const int epfd = pollset->active_pollable->epfd;
-  grpc_core::MutexLock lock(&fd->pollable_mu);
+  grpc_core::MutexLockForGprMu lock(&fd->pollable_mu);
   fd->pollset_fds.push_back(epfd);
 }
 
@@ -684,7 +684,7 @@ static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
 static grpc_error* kick_one_worker(grpc_pollset_worker* specific_worker) {
   GPR_TIMER_SCOPE("kick_one_worker", 0);
   pollable* p = specific_worker->pollable_obj;
-  grpc_core::MutexLock lock(&p->mu);
+  grpc_core::MutexLockForGprMu lock(&p->mu);
   GPR_ASSERT(specific_worker != nullptr);
   if (specific_worker->kicked) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
@@ -1296,7 +1296,7 @@ static void pollset_add_fd(grpc_pollset* pollset, grpc_fd* fd) {
     return;
   }
 
-  grpc_core::MutexLock lock(&pollset->mu);
+  grpc_core::MutexLockForGprMu lock(&pollset->mu);
   grpc_error* error = pollset_add_fd_locked(pollset, fd);
 
   // If we are in PO_MULTI mode, we should update the pollsets of the FD.

data/src/core/lib/iomgr/iomgr_posix.cc

@@ -25,7 +25,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/iomgr_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"

data/src/core/lib/iomgr/iomgr_posix_cfstream.cc

@@ -40,7 +40,6 @@
 #include "src/core/lib/iomgr/ev_apple.h"
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
-#include "src/core/lib/iomgr/iomgr_posix.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"

data/src/core/lib/iomgr/sockaddr_utils.cc

@@ -183,7 +183,7 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
-      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2.
+      // Enclose sin6_scope_id with the format defined in RFC 6874 section 2.
       std::string host_with_scope =
           absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
       out = grpc_core::JoinHostPort(host_with_scope, port);

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -62,6 +62,7 @@ grpc_error* grpc_set_socket_zerocopy(int fd) {
   }
   return GRPC_ERROR_NONE;
 #else
+  (void)fd;
   return GRPC_OS_ERROR(ENOSYS, "setsockopt(SO_ZEROCOPY)");
 #endif
 }

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -38,7 +38,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/ev_posix.h"
-#include "src/core/lib/iomgr/iomgr_posix.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_mutator.h"

data/src/core/lib/iomgr/tcp_posix.cc

@@ -1241,11 +1241,11 @@ static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error* error) {
 
 #else  /* GRPC_LINUX_ERRQUEUE */
 static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
-    grpc_tcp* tcp, grpc_slice_buffer* buf) {
+    grpc_tcp* /*tcp*/, grpc_slice_buffer* /*buf*/) {
   return nullptr;
 }
 
-static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* tcp) {}
+static void ZerocopyDisableAndWaitForRemaining(grpc_tcp* /*tcp*/) {}
 
 static bool tcp_write_with_timestamps(grpc_tcp* /*tcp*/, struct msghdr* /*msg*/,
                                       size_t /*sending_length*/,
@@ -1391,8 +1391,8 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
 
 static void UnrefMaybePutZerocopySendRecord(grpc_tcp* tcp,
                                             TcpZerocopySendRecord* record,
-                                            uint32_t seq,
-                                            const char* /* tag */) {
+                                            uint32_t /*seq*/,
+                                            const char* /*tag*/) {
   if (record->Unref()) {
     tcp->tcp_zerocopy_send_ctx.PutSendRecord(record);
   }

data/src/core/lib/security/authorization/matchers.cc

@@ -0,0 +1,339 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/security/authorization/matchers.h"
+
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
+
+namespace grpc_core {
+
+//
+// StringMatcher
+//
+
+absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
+                                                    const std::string& matcher,
+                                                    bool case_sensitive) {
+  if (type == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(case_sensitive);
+    auto regex_matcher = absl::make_unique<RE2>(matcher, options);
+    if (!regex_matcher->ok()) {
+      return absl::InvalidArgumentError(
+          "Invalid regex string specified in matcher.");
+    }
+    return StringMatcher(std::move(regex_matcher), case_sensitive);
+  } else {
+    return StringMatcher(type, matcher, case_sensitive);
+  }
+}
+
+StringMatcher::StringMatcher(Type type, const std::string& matcher,
+                             bool case_sensitive)
+    : type_(type), string_matcher_(matcher), case_sensitive_(case_sensitive) {}
+
+StringMatcher::StringMatcher(std::unique_ptr<RE2> regex_matcher,
+                             bool case_sensitive)
+    : type_(Type::SAFE_REGEX),
+      regex_matcher_(std::move(regex_matcher)),
+      case_sensitive_(case_sensitive) {}
+
+StringMatcher::StringMatcher(const StringMatcher& other)
+    : type_(other.type_), case_sensitive_(other.case_sensitive_) {
+  if (type_ == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(other.case_sensitive_);
+    regex_matcher_ =
+        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+  } else {
+    string_matcher_ = other.string_matcher_;
+  }
+}
+
+StringMatcher& StringMatcher::operator=(const StringMatcher& other) {
+  type_ = other.type_;
+  if (type_ == Type::SAFE_REGEX) {
+    RE2::Options options;
+    options.set_case_sensitive(other.case_sensitive_);
+    regex_matcher_ =
+        absl::make_unique<RE2>(other.regex_matcher_->pattern(), options);
+  } else {
+    string_matcher_ = other.string_matcher_;
+  }
+  case_sensitive_ = other.case_sensitive_;
+  return *this;
+}
+
+StringMatcher::StringMatcher(StringMatcher&& other) noexcept
+    : type_(other.type_), case_sensitive_(other.case_sensitive_) {
+  if (type_ == Type::SAFE_REGEX) {
+    regex_matcher_ = std::move(other.regex_matcher_);
+  } else {
+    string_matcher_ = std::move(other.string_matcher_);
+  }
+}
+
+StringMatcher& StringMatcher::operator=(StringMatcher&& other) noexcept {
+  type_ = other.type_;
+  if (type_ == Type::SAFE_REGEX) {
+    regex_matcher_ = std::move(other.regex_matcher_);
+  } else {
+    string_matcher_ = std::move(other.string_matcher_);
+  }
+  case_sensitive_ = other.case_sensitive_;
+  return *this;
+}
+
+bool StringMatcher::operator==(const StringMatcher& other) const {
+  if (type_ != other.type_ || case_sensitive_ != other.case_sensitive_) {
+    return false;
+  }
+  if (type_ == Type::SAFE_REGEX) {
+    return regex_matcher_->pattern() == other.regex_matcher_->pattern();
+  } else {
+    return string_matcher_ == other.string_matcher_;
+  }
+}
+
+bool StringMatcher::Match(absl::string_view value) const {
+  switch (type_) {
+    case Type::EXACT:
+      return case_sensitive_ ? value == string_matcher_
+                             : absl::EqualsIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::PREFIX:
+      return case_sensitive_
+                 ? absl::StartsWith(value, string_matcher_)
+                 : absl::StartsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::SUFFIX:
+      return case_sensitive_ ? absl::EndsWith(value, string_matcher_)
+                             : absl::EndsWithIgnoreCase(value, string_matcher_);
+    case StringMatcher::Type::CONTAINS:
+      return case_sensitive_
+                 ? absl::StrContains(value, string_matcher_)
+                 : absl::StrContains(absl::AsciiStrToLower(value),
+                                     absl::AsciiStrToLower(string_matcher_));
+    case StringMatcher::Type::SAFE_REGEX:
+      return RE2::FullMatch(std::string(value), *regex_matcher_);
+    default:
+      return false;
+  }
+}
+
+std::string StringMatcher::ToString() const {
+  switch (type_) {
+    case Type::EXACT:
+      return absl::StrFormat("StringMatcher{exact=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::PREFIX:
+      return absl::StrFormat("StringMatcher{prefix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::SUFFIX:
+      return absl::StrFormat("StringMatcher{suffix=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::CONTAINS:
+      return absl::StrFormat("StringMatcher{contains=%s%s}", string_matcher_,
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    case Type::SAFE_REGEX:
+      return absl::StrFormat("StringMatcher{safe_regex=%s%s}",
+                             regex_matcher_->pattern(),
+                             case_sensitive_ ? "" : ", case_sensitive=false");
+    default:
+      return "";
+  }
+}
+
+//
+// HeaderMatcher
+//
+
+absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
+    const std::string& name, Type type, const std::string& matcher,
+    int64_t range_start, int64_t range_end, bool present_match,
+    bool invert_match) {
+  if (static_cast<int>(type) < 5) {
+    // Only for EXACT, PREFIX, SUFFIX, SAFE_REGEX and CONTAINS.
+    absl::StatusOr<StringMatcher> string_matcher =
+        StringMatcher::Create(static_cast<StringMatcher::Type>(type), matcher,
+                              /*case_sensitive=*/true);
+    if (!string_matcher.ok()) {
+      return string_matcher.status();
+    }
+    return HeaderMatcher(name, type, std::move(string_matcher.value()),
+                         invert_match);
+  } else if (type == Type::RANGE) {
+    if (range_start > range_end) {
+      return absl::InvalidArgumentError(
+          "Invalid range specifier specified: end cannot be smaller than "
+          "start.");
+    }
+    return HeaderMatcher(name, range_start, range_end, invert_match);
+  } else {
+    return HeaderMatcher(name, present_match, invert_match);
+  }
+}
+
+HeaderMatcher::HeaderMatcher(const std::string& name, Type type,
+                             StringMatcher string_matcher, bool invert_match)
+    : name_(name),
+      type_(type),
+      matcher_(std::move(string_matcher)),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(const std::string& name, int64_t range_start,
+                             int64_t range_end, bool invert_match)
+    : name_(name),
+      type_(Type::RANGE),
+      range_start_(range_start),
+      range_end_(range_end),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(const std::string& name, bool present_match,
+                             bool invert_match)
+    : name_(name),
+      type_(Type::PRESENT),
+      present_match_(present_match),
+      invert_match_(invert_match) {}
+
+HeaderMatcher::HeaderMatcher(const HeaderMatcher& other)
+    : name_(other.name_),
+      type_(other.type_),
+      invert_match_(other.invert_match_) {
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = other.matcher_;
+  }
+}
+
+HeaderMatcher& HeaderMatcher::operator=(const HeaderMatcher& other) {
+  name_ = other.name_;
+  type_ = other.type_;
+  invert_match_ = other.invert_match_;
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = other.matcher_;
+  }
+  return *this;
+}
+
+HeaderMatcher::HeaderMatcher(HeaderMatcher&& other) noexcept
+    : name_(std::move(other.name_)),
+      type_(other.type_),
+      invert_match_(other.invert_match_) {
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = std::move(other.matcher_);
+  }
+}
+
+HeaderMatcher& HeaderMatcher::operator=(HeaderMatcher&& other) noexcept {
+  name_ = std::move(other.name_);
+  type_ = other.type_;
+  invert_match_ = other.invert_match_;
+  switch (type_) {
+    case Type::RANGE:
+      range_start_ = other.range_start_;
+      range_end_ = other.range_end_;
+      break;
+    case Type::PRESENT:
+      present_match_ = other.present_match_;
+      break;
+    default:
+      matcher_ = std::move(other.matcher_);
+  }
+  return *this;
+}
+
+bool HeaderMatcher::operator==(const HeaderMatcher& other) const {
+  if (name_ != other.name_) return false;
+  if (type_ != other.type_) return false;
+  if (invert_match_ != other.invert_match_) return false;
+  switch (type_) {
+    case Type::RANGE:
+      return range_start_ == other.range_start_ &&
+             range_end_ == other.range_end_;
+    case Type::PRESENT:
+      return present_match_ == other.present_match_;
+    default:
+      return matcher_ == other.matcher_;
+  }
+}
+
+bool HeaderMatcher::Match(
+    const absl::optional<absl::string_view>& value) const {
+  bool match;
+  if (type_ == Type::PRESENT) {
+    match = value.has_value() == present_match_;
+  } else if (!value.has_value()) {
+    // All other types fail to match if field is not present.
+    match = false;
+  } else if (type_ == Type::RANGE) {
+    int64_t int_value;
+    match = absl::SimpleAtoi(value.value(), &int_value) &&
+            int_value >= range_start_ && int_value < range_end_;
+  } else {
+    match = matcher_.Match(value.value());
+  }
+  return match != invert_match_;
+}
+
+std::string HeaderMatcher::ToString() const {
+  switch (type_) {
+    case Type::RANGE:
+      return absl::StrFormat("HeaderMatcher{%s %srange=[%d, %d]}", name_,
+                             invert_match_ ? "not " : "", range_start_,
+                             range_end_);
+    case Type::PRESENT:
+      return absl::StrFormat("HeaderMatcher{%s %spresent=%s}", name_,
+                             invert_match_ ? "not " : "",
+                             present_match_ ? "true" : "false");
+    case Type::EXACT:
+    case Type::PREFIX:
+    case Type::SUFFIX:
+    case Type::SAFE_REGEX:
+    case Type::CONTAINS:
+      return absl::StrFormat("HeaderMatcher{%s %s%s}", name_,
+                             invert_match_ ? "not " : "", matcher_.ToString());
+    default:
+      return "";
+  }
+}
+
+}  // namespace grpc_core

data/src/core/lib/security/authorization/matchers.h

@@ -0,0 +1,158 @@
+// Copyright 2021 gRPC authors.
+//
+// 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.
+
+#ifndef GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MATCHERS_H
+#define GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MATCHERS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+#include <string>
+
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "re2/re2.h"
+
+namespace grpc_core {
+
+class StringMatcher {
+ public:
+  enum class Type {
+    EXACT,       // value stored in string_matcher_ field
+    PREFIX,      // value stored in string_matcher_ field
+    SUFFIX,      // value stored in string_matcher_ field
+    SAFE_REGEX,  // pattern stored in regex_matcher_ field
+    CONTAINS,    // value stored in string_matcher_ field
+  };
+
+  // Creates StringMatcher instance. Returns error status on failure.
+  static absl::StatusOr<StringMatcher> Create(Type type,
+                                              const std::string& matcher,
+                                              bool case_sensitive = true);
+
+  StringMatcher() = default;
+  StringMatcher(const StringMatcher& other);
+  StringMatcher& operator=(const StringMatcher& other);
+  StringMatcher(StringMatcher&& other) noexcept;
+  StringMatcher& operator=(StringMatcher&& other) noexcept;
+  bool operator==(const StringMatcher& other) const;
+
+  bool Match(absl::string_view value) const;
+
+  std::string ToString() const;
+
+  Type type() const { return type_; }
+
+  // Valid for EXACT, PREFIX, SUFFIX and CONTAINS
+  const std::string& string_matcher() const { return string_matcher_; }
+
+  // Valid for SAFE_REGEX
+  RE2* regex_matcher() const { return regex_matcher_.get(); }
+
+  bool case_sensitive() const { return case_sensitive_; }
+
+ private:
+  StringMatcher(Type type, const std::string& matcher, bool case_sensitive);
+  StringMatcher(std::unique_ptr<RE2> regex_matcher, bool case_sensitive);
+
+  Type type_ = Type::EXACT;
+  std::string string_matcher_;
+  std::unique_ptr<RE2> regex_matcher_;
+  bool case_sensitive_ = true;
+};
+
+class HeaderMatcher {
+ public:
+  enum class Type {
+    EXACT,       // value stored in StringMatcher field
+    PREFIX,      // value stored in StringMatcher field
+    SUFFIX,      // value stored in StringMatcher field
+    SAFE_REGEX,  // value stored in StringMatcher field
+    CONTAINS,    // value stored in StringMatcher field
+    RANGE,       // uses range_start and range_end fields
+    PRESENT,     // uses present_match field
+  };
+
+  // Make sure that the first five HeaderMatcher::Type enum values match up to
+  // the corresponding StringMatcher::Type enum values, so that it's safe to
+  // convert by casting when delegating to StringMatcher.
+  static_assert(static_cast<StringMatcher::Type>(Type::EXACT) ==
+                    StringMatcher::Type::EXACT,
+                "");
+  static_assert(static_cast<StringMatcher::Type>(Type::PREFIX) ==
+                    StringMatcher::Type::PREFIX,
+                "");
+  static_assert(static_cast<StringMatcher::Type>(Type::SUFFIX) ==
+                    StringMatcher::Type::SUFFIX,
+                "");
+  static_assert(static_cast<StringMatcher::Type>(Type::SAFE_REGEX) ==
+                    StringMatcher::Type::SAFE_REGEX,
+                "");
+  static_assert(static_cast<StringMatcher::Type>(Type::CONTAINS) ==
+                    StringMatcher::Type::CONTAINS,
+                "");
+
+  // Creates HeaderMatcher instance. Returns error status on failure.
+  static absl::StatusOr<HeaderMatcher> Create(
+      const std::string& name, Type type, const std::string& matcher,
+      int64_t range_start = 0, int64_t range_end = 0,
+      bool present_match = false, bool invert_match = false);
+
+  HeaderMatcher() = default;
+  HeaderMatcher(const HeaderMatcher& other);
+  HeaderMatcher& operator=(const HeaderMatcher& other);
+  HeaderMatcher(HeaderMatcher&& other) noexcept;
+  HeaderMatcher& operator=(HeaderMatcher&& other) noexcept;
+  bool operator==(const HeaderMatcher& other) const;
+
+  const std::string& name() const { return name_; }
+
+  Type type() const { return type_; }
+
+  // Valid for EXACT, PREFIX, SUFFIX and CONTAINS
+  const std::string& string_matcher() const {
+    return matcher_.string_matcher();
+  }
+
+  // Valid for SAFE_REGEX
+  RE2* regex_matcher() const { return matcher_.regex_matcher(); }
+
+  bool Match(const absl::optional<absl::string_view>& value) const;
+
+  std::string ToString() const;
+
+ private:
+  // For StringMatcher.
+  HeaderMatcher(const std::string& name, Type type, StringMatcher matcher,
+                bool invert_match);
+  // For RangeMatcher.
+  HeaderMatcher(const std::string& name, int64_t range_start, int64_t range_end,
+                bool invert_match);
+  // For PresentMatcher.
+  HeaderMatcher(const std::string& name, bool present_match, bool invert_match);
+
+  std::string name_;
+  Type type_ = Type::EXACT;
+  StringMatcher matcher_;
+  int64_t range_start_;
+  int64_t range_end_;
+  bool present_match_;
+  bool invert_match_ = false;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_SECURITY_AUTHORIZATION_MATCHERS_H */