grpc 1.42.0 → 1.43.1

data/src/core/lib/security/security_connector/tls/tls_security_connector.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/status.h"
+
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
@@ -58,11 +60,8 @@ class TlsChannelSecurityConnector final
                   RefCountedPtr<grpc_auth_context>* auth_context,
                   grpc_closure* on_peer_checked) override;
 
-  void cancel_check_peer(grpc_closure* /*on_peer_checked*/,
-                         grpc_error_handle error) override {
-    // TODO(ZhenLian): call verifier->cancel() once the verifier is ready.
-    GRPC_ERROR_UNREF(error);
-  }
+  void cancel_check_peer(grpc_closure* on_peer_checked,
+                         grpc_error_handle error) override;
 
   int cmp(const grpc_security_connector* other_sc) const override;
 
@@ -108,43 +107,51 @@ class TlsChannelSecurityConnector final
     TlsChannelSecurityConnector* security_connector_ = nullptr;
   };
 
-  // Updates |client_handshaker_factory_| when the certificates that
-  // |certificate_watcher_| is watching get updated.
-  grpc_security_status UpdateHandshakerFactoryLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  // Use "new" to create a new instance, and no need to delete it later, since
+  // it will be self-destroyed in |OnVerifyDone|.
+  class ChannelPendingVerifierRequest {
+   public:
+    ChannelPendingVerifierRequest(
+        RefCountedPtr<TlsChannelSecurityConnector> security_connector,
+        grpc_closure* on_peer_checked, tsi_peer peer, const char* target_name);
 
-  // gRPC-provided callback executed by application, which servers to bring the
-  // control back to gRPC core.
-  static void ServerAuthorizationCheckDone(
-      grpc_tls_server_authorization_check_arg* arg);
+    ~ChannelPendingVerifierRequest();
 
-  // A util function to process server authorization check result.
-  static grpc_error_handle ProcessServerAuthorizationCheckResult(
-      grpc_tls_server_authorization_check_arg* arg);
+    void Start();
 
-  // A util function to create a server authorization check arg instance.
-  static grpc_tls_server_authorization_check_arg*
-  ServerAuthorizationCheckArgCreate(void* user_data);
+    grpc_tls_custom_verification_check_request* request() { return &request_; }
 
-  // A util function to destroy a server authorization check arg instance.
-  static void ServerAuthorizationCheckArgDestroy(
-      grpc_tls_server_authorization_check_arg* arg);
+   private:
+    void OnVerifyDone(bool run_callback_inline, absl::Status status);
+    // The request will keep a reference of the security connector to make sure
+    // it won't be destroyed while the request is still ongoing.
+    RefCountedPtr<TlsChannelSecurityConnector> security_connector_;
+    grpc_tls_custom_verification_check_request request_;
+    grpc_closure* on_peer_checked_;
+  };
+
+  // Updates |client_handshaker_factory_| when the certificates that
+  // |certificate_watcher_| is watching get updated.
+  grpc_security_status UpdateHandshakerFactoryLocked()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  Mutex mu_;
+  // We need a separate mutex for |pending_verifier_requests_|, otherwise there
+  // would be deadlock errors.
+  Mutex verifier_request_map_mu_;
   RefCountedPtr<grpc_tls_credentials_options> options_;
   grpc_tls_certificate_distributor::TlsCertificatesWatcherInterface*
       certificate_watcher_ = nullptr;
-  grpc_closure* on_peer_checked_ = nullptr;
   std::string target_name_;
   std::string overridden_target_name_;
-  grpc_tls_server_authorization_check_arg* check_arg_ = nullptr;
-
-  Mutex mu_;
   tsi_ssl_client_handshaker_factory* client_handshaker_factory_
       ABSL_GUARDED_BY(mu_) = nullptr;
   tsi_ssl_session_cache* ssl_session_cache_ ABSL_GUARDED_BY(mu_) = nullptr;
   absl::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
   absl::optional<PemKeyCertPairList> pem_key_cert_pair_list_
       ABSL_GUARDED_BY(mu_);
+  std::map<grpc_closure* /*on_peer_checked*/, ChannelPendingVerifierRequest*>
+      pending_verifier_requests_ ABSL_GUARDED_BY(verifier_request_map_mu_);
 };
 
 // Server security connector using TLS as transport security protocol.
@@ -170,10 +177,7 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
                   grpc_closure* on_peer_checked) override;
 
   void cancel_check_peer(grpc_closure* /*on_peer_checked*/,
-                         grpc_error_handle error) override {
-    // TODO(ZhenLian): call verifier->cancel() once the verifier is ready.
-    GRPC_ERROR_UNREF(error);
-  }
+                         grpc_error_handle error) override;
 
   int cmp(const grpc_security_connector* other) const override;
 
@@ -205,6 +209,7 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
     void OnCertificatesChanged(
         absl::optional<absl::string_view> root_certs,
         absl::optional<PemKeyCertPairList> key_cert_pairs) override;
+
     void OnError(grpc_error_handle root_cert_error,
                  grpc_error_handle identity_cert_error) override;
 
@@ -212,32 +217,50 @@ class TlsServerSecurityConnector final : public grpc_server_security_connector {
     TlsServerSecurityConnector* security_connector_ = nullptr;
   };
 
+  // Use "new" to create a new instance, and no need to delete it later, since
+  // it will be self-destroyed in |OnVerifyDone|.
+  class ServerPendingVerifierRequest {
+   public:
+    ServerPendingVerifierRequest(
+        RefCountedPtr<TlsServerSecurityConnector> security_connector,
+        grpc_closure* on_peer_checked, tsi_peer peer);
+
+    ~ServerPendingVerifierRequest();
+
+    void Start();
+
+    grpc_tls_custom_verification_check_request* request() { return &request_; }
+
+   private:
+    void OnVerifyDone(bool run_callback_inline, absl::Status status);
+    // The request will keep a reference of the security connector to make sure
+    // it won't be destroyed while the request is still ongoing.
+    RefCountedPtr<TlsServerSecurityConnector> security_connector_;
+    grpc_tls_custom_verification_check_request request_;
+    grpc_closure* on_peer_checked_;
+  };
+
   // Updates |server_handshaker_factory_| when the certificates that
   // |certificate_watcher_| is watching get updated.
   grpc_security_status UpdateHandshakerFactoryLocked()
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  Mutex mu_;
+  // We need a separate mutex for |pending_verifier_requests_|, otherwise there
+  // would be deadlock errors.
+  Mutex verifier_request_map_mu_;
   RefCountedPtr<grpc_tls_credentials_options> options_;
   grpc_tls_certificate_distributor::TlsCertificatesWatcherInterface*
       certificate_watcher_ = nullptr;
-
-  Mutex mu_;
   tsi_ssl_server_handshaker_factory* server_handshaker_factory_
       ABSL_GUARDED_BY(mu_) = nullptr;
   absl::optional<absl::string_view> pem_root_certs_ ABSL_GUARDED_BY(mu_);
   absl::optional<PemKeyCertPairList> pem_key_cert_pair_list_
       ABSL_GUARDED_BY(mu_);
+  std::map<grpc_closure* /*on_peer_checked*/, ServerPendingVerifierRequest*>
+      pending_verifier_requests_ ABSL_GUARDED_BY(verifier_request_map_mu_);
 };
 
-// ---- Functions below are exposed for testing only -----------------------
-namespace internal {
-
-// TlsCheckHostName checks if |peer_name| matches the identity information
-// contained in |peer|. This is AKA hostname check.
-grpc_error_handle TlsCheckHostName(const char* peer_name, const tsi_peer* peer);
-
-}  // namespace internal
-
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_SECURITY_SECURITY_CONNECTOR_TLS_TLS_SECURITY_CONNECTOR_H

data/src/core/lib/security/transport/security_handshaker.cc

@@ -440,7 +440,7 @@ grpc_error_handle SecurityHandshaker::DoHandshakerNextLocked(
 void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFnScheduler(
     void* arg, grpc_error_handle error) {
   SecurityHandshaker* h = static_cast<SecurityHandshaker*>(arg);
-  grpc_core::ExecCtx::Run(
+  ExecCtx::Run(
       DEBUG_LOCATION,
       GRPC_CLOSURE_INIT(&h->on_handshake_data_received_from_peer_,
                         &SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn,
@@ -473,7 +473,7 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn(
 void SecurityHandshaker::OnHandshakeDataSentToPeerFnScheduler(
     void* arg, grpc_error_handle error) {
   SecurityHandshaker* h = static_cast<SecurityHandshaker*>(arg);
-  grpc_core::ExecCtx::Run(
+  ExecCtx::Run(
       DEBUG_LOCATION,
       GRPC_CLOSURE_INIT(&h->on_handshake_data_sent_to_peer_,
                         &SecurityHandshaker::OnHandshakeDataSentToPeerFn, h,

data/src/core/lib/slice/percent_encoding.cc

@@ -51,7 +51,7 @@ class UrlTable : public BitSet<256> {
   }
 };
 
-static GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
+GRPC_PCTENCODE_CONSTEXPR_VALUE UrlTable g_url_table;
 
 class CompatibleTable : public BitSet<256> {
  public:
@@ -63,7 +63,7 @@ class CompatibleTable : public BitSet<256> {
   }
 };
 
-static GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
+GRPC_PCTENCODE_CONSTEXPR_VALUE CompatibleTable g_compatible_table;
 
 // Map PercentEncodingType to a lookup table of legal symbols for that encoding.
 const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {
@@ -78,135 +78,79 @@ const BitSet<256>& LookupTableForPercentEncodingType(PercentEncodingType type) {
 }
 }  // namespace
 
-grpc_slice PercentEncodeSlice(const grpc_slice& slice,
-                              PercentEncodingType type) {
+Slice PercentEncodeSlice(Slice slice, PercentEncodingType type) {
   static const uint8_t hex[] = "0123456789ABCDEF";
 
   const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
 
   // first pass: count the number of bytes needed to output this string
   size_t output_length = 0;
-  const uint8_t* slice_start = GRPC_SLICE_START_PTR(slice);
-  const uint8_t* slice_end = GRPC_SLICE_END_PTR(slice);
-  const uint8_t* p;
   bool any_reserved_bytes = false;
-  for (p = slice_start; p < slice_end; p++) {
-    bool unres = lut.is_set(*p);
+  for (uint8_t c : slice) {
+    bool unres = lut.is_set(c);
     output_length += unres ? 1 : 3;
     any_reserved_bytes |= !unres;
   }
   // no unreserved bytes: return the string unmodified
   if (!any_reserved_bytes) {
-    return grpc_slice_ref_internal(slice);
+    return slice;
   }
   // second pass: actually encode
-  grpc_slice out = GRPC_SLICE_MALLOC(output_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(out);
-  for (p = slice_start; p < slice_end; p++) {
-    if (lut.is_set(*p)) {
-      *q++ = *p;
+  auto out = MutableSlice::CreateUninitialized(output_length);
+  uint8_t* q = out.begin();
+  for (uint8_t c : slice) {
+    if (lut.is_set(c)) {
+      *q++ = c;
     } else {
       *q++ = '%';
-      *q++ = hex[*p >> 4];
-      *q++ = hex[*p & 15];
+      *q++ = hex[c >> 4];
+      *q++ = hex[c & 15];
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(out));
-  return out;
+  GPR_ASSERT(q == out.end());
+  return Slice(std::move(out));
 }
 
-static bool valid_hex(const uint8_t* p, const uint8_t* end) {
+static bool ValidHex(const uint8_t* p, const uint8_t* end) {
   if (p >= end) return false;
   return (*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f') ||
          (*p >= 'A' && *p <= 'F');
 }
 
-static uint8_t dehex(uint8_t c) {
+static uint8_t DeHex(uint8_t c) {
   if (c >= '0' && c <= '9') return static_cast<uint8_t>(c - '0');
   if (c >= 'A' && c <= 'F') return static_cast<uint8_t>(c - 'A' + 10);
   if (c >= 'a' && c <= 'f') return static_cast<uint8_t>(c - 'a' + 10);
   GPR_UNREACHABLE_CODE(return 255);
 }
 
-absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
-                                              PercentEncodingType type) {
-  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
+Slice PermissivePercentDecodeSlice(Slice slice_in) {
   bool any_percent_encoded_stuff = false;
-  const BitSet<256>& lut = LookupTableForPercentEncodingType(type);
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(++p, in_end)) return {};
-      if (!valid_hex(++p, in_end)) return {};
-      p++;
-      out_length++;
+  for (uint8_t c : slice_in) {
+    if (c == '%') {
       any_percent_encoded_stuff = true;
-    } else if (lut.is_set(*p)) {
-      p++;
-      out_length++;
-    } else {
-      return {};
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    return grpc_slice_ref_internal(slice_in);
-  }
-  p = GRPC_SLICE_START_PTR(slice_in);
-  grpc_slice slice_out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(slice_out);
-  while (p != in_end) {
-    if (*p == '%') {
-      *q++ = static_cast<uint8_t>(dehex(p[1]) << 4) | (dehex(p[2]));
-      p += 3;
-    } else {
-      *q++ = *p++;
+      break;
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(slice_out));
-  return slice_out;
-}
+  if (!any_percent_encoded_stuff) return slice_in;
 
-grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in) {
-  const uint8_t* p = GRPC_SLICE_START_PTR(slice_in);
-  const uint8_t* in_end = GRPC_SLICE_END_PTR(slice_in);
-  size_t out_length = 0;
-  bool any_percent_encoded_stuff = false;
-  while (p != in_end) {
-    if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
-        p++;
-        out_length++;
-      } else {
-        p += 3;
-        out_length++;
-        any_percent_encoded_stuff = true;
-      }
-    } else {
-      p++;
-      out_length++;
-    }
-  }
-  if (!any_percent_encoded_stuff) {
-    return grpc_slice_ref_internal(slice_in);
-  }
-  p = GRPC_SLICE_START_PTR(slice_in);
-  grpc_slice out = GRPC_SLICE_MALLOC(out_length);
-  uint8_t* q = GRPC_SLICE_START_PTR(out);
-  while (p != in_end) {
+  MutableSlice out = slice_in.TakeMutable();
+  uint8_t* q = out.begin();
+  const uint8_t* p = out.begin();
+  const uint8_t* end = out.end();
+  while (p != end) {
     if (*p == '%') {
-      if (!valid_hex(p + 1, in_end) || !valid_hex(p + 2, in_end)) {
+      if (!ValidHex(p + 1, end) || !ValidHex(p + 2, end)) {
         *q++ = *p++;
       } else {
-        *q++ = static_cast<uint8_t>(dehex(p[1]) << 4) | (dehex(p[2]));
+        *q++ = static_cast<uint8_t>(DeHex(p[1]) << 4) | (DeHex(p[2]));
         p += 3;
       }
     } else {
       *q++ = *p++;
     }
   }
-  GPR_ASSERT(q == GRPC_SLICE_END_PTR(out));
-  return out;
+  return Slice(out.TakeSubSlice(0, q - out.begin()));
 }
 
 }  // namespace grpc_core

data/src/core/lib/slice/percent_encoding.h

@@ -34,32 +34,26 @@
 
 #include <grpc/slice.h>
 
+#include "src/core/lib/slice/slice.h"
+
 namespace grpc_core {
 
 enum class PercentEncodingType {
   // Flags [A-Za-z0-9-_.~] as unreserved bytes for the percent encoding routines
   URL,
   // Flags ascii7 non-control characters excluding '%' as unreserved bytes for
-  // the
-  // percent encoding routines
+  // the percent encoding routines
   Compatible
 };
 
 // Percent-encode a slice, returning the new slice (this cannot fail):
 // unreserved_bytes is a bitfield indicating which bytes are considered
 // unreserved and thus do not need percent encoding
-grpc_slice PercentEncodeSlice(const grpc_slice& slice,
-                              PercentEncodingType type);
-// Percent-decode a slice, strictly.
-// If the input is legal (contains no unreserved bytes, and legal % encodings),
-// returns the decoded slice.
-// If the input is not legal, returns {}.
-absl::optional<grpc_slice> PercentDecodeSlice(const grpc_slice& slice_in,
-                                              PercentEncodingType type);
+Slice PercentEncodeSlice(Slice slice, PercentEncodingType type);
 // Percent-decode a slice, permissively.
 // If a % triplet can not be decoded, pass it through verbatim.
 // This cannot fail.
-grpc_slice PermissivePercentDecodeSlice(const grpc_slice& slice_in);
+Slice PermissivePercentDecodeSlice(Slice slice_in);
 
 }  // namespace grpc_core
 

data/src/core/lib/slice/slice.cc

@@ -69,7 +69,7 @@ class NewSliceRefcount {
 
  private:
   grpc_slice_refcount base_;
-  RefCount refs_;
+  std::atomic<size_t> refs_{1};
   void (*user_destroy_)(void*);
   void* user_data_;
 };
@@ -130,7 +130,7 @@ class NewWithLenSliceRefcount {
 
  private:
   grpc_slice_refcount base_;
-  RefCount refs_;
+  std::atomic<size_t> refs_{1};
   void* user_data_;
   size_t user_length_;
   void (*user_destroy_)(void*, size_t);
@@ -139,7 +139,7 @@ class NewWithLenSliceRefcount {
 /** grpc_slice_from_moved_(string|buffer) ref count .*/
 class MovedStringSliceRefCount {
  public:
-  explicit MovedStringSliceRefCount(grpc_core::UniquePtr<char>&& str)
+  explicit MovedStringSliceRefCount(UniquePtr<char>&& str)
       : base_(grpc_slice_refcount::Type::REGULAR, &refs_, Destroy, this,
               &base_),
         str_(std::move(str)) {}
@@ -152,8 +152,8 @@ class MovedStringSliceRefCount {
   }
 
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
-  grpc_core::UniquePtr<char> str_;
+  std::atomic<size_t> refs_{1};
+  UniquePtr<char> str_;
 };
 
 // grpc_slice_from_cpp_string() ref count.
@@ -172,7 +172,7 @@ class MovedCppStringSliceRefCount {
   }
 
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
+  std::atomic<size_t> refs_{1};
   std::string str_;
 };
 
@@ -281,7 +281,7 @@ class MallocRefCount {
 
  private:
   grpc_slice_refcount base_;
-  grpc_core::RefCount refs_;
+  std::atomic<size_t> refs_{1};
 };
 
 }  // namespace