grpc 1.57.0 → 1.58.0.pre1

data/src/core/lib/promise/seq.h

@@ -17,11 +17,14 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdlib.h>
+
 #include <type_traits>
 #include <utility>
 
 #include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/detail/seq_state.h"
 #include "src/core/lib/promise/poll.h"
 
 namespace grpc_core {
@@ -36,6 +39,11 @@ struct SeqTraits {
   static auto CallFactory(Next* next, T&& value) {
     return next->Make(std::forward<T>(value));
   }
+  static bool IsOk(const T&) { return true; }
+  template <typename R>
+  static R ReturnValue(T&&) {
+    abort();
+  }
   template <typename F, typename Elem>
   static auto CallSeqFactory(F& f, Elem&& elem, T&& value) {
     return f(std::forward<Elem>(elem), std::forward<T>(value));
@@ -47,8 +55,17 @@ struct SeqTraits {
   }
 };
 
-template <typename... Fs>
-using Seq = BasicSeq<SeqTraits, Fs...>;
+template <typename P, typename... Fs>
+class Seq {
+ public:
+  explicit Seq(P&& promise, Fs&&... factories)
+      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...) {}
+
+  auto operator()() { return state_.PollOnce(); }
+
+ private:
+  SeqState<SeqTraits, P, Fs...> state_;
+};
 
 template <typename I, typename F, typename Arg>
 struct SeqIterTraits {

data/src/core/lib/promise/sleep.h

@@ -18,11 +18,11 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <utility>
 
 #include "absl/status/status.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/promise/activity.h"
@@ -38,17 +38,12 @@ class Sleep final {
 
   Sleep(const Sleep&) = delete;
   Sleep& operator=(const Sleep&) = delete;
-  Sleep(Sleep&& other) noexcept : deadline_(other.deadline_) {
-    // Promises can be moved only until they're polled, and since we only create
-    // the closure when first polled we can assume it's nullptr here.
-    GPR_DEBUG_ASSERT(other.closure_ == nullptr);
-  };
+  Sleep(Sleep&& other) noexcept
+      : deadline_(other.deadline_),
+        closure_(std::exchange(other.closure_, nullptr)) {}
   Sleep& operator=(Sleep&& other) noexcept {
-    // Promises can be moved only until they're polled, and since we only create
-    // the closure when first polled we can assume it's nullptr here.
-    GPR_DEBUG_ASSERT(closure_ == nullptr);
-    GPR_DEBUG_ASSERT(other.closure_ == nullptr);
     deadline_ = other.deadline_;
+    std::swap(closure_, other.closure_);
     return *this;
   };
 

data/src/core/lib/promise/try_seq.h

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdlib.h>
+
 #include <type_traits>
 #include <utility>
 
@@ -26,6 +28,7 @@
 
 #include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/detail/seq_state.h"
 #include "src/core/lib/promise/detail/status.h"
 #include "src/core/lib/promise/poll.h"
 
@@ -41,6 +44,11 @@ struct TrySeqTraitsWithSfinae {
   static auto CallFactory(Next* next, T&& value) {
     return next->Make(std::forward<T>(value));
   }
+  static bool IsOk(const T&) { return true; }
+  template <typename R>
+  static R ReturnValue(T&&) {
+    abort();
+  }
   template <typename F, typename Elem>
   static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
       -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
@@ -60,6 +68,11 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
   static auto CallFactory(Next* next, absl::StatusOr<T>&& status) {
     return next->Make(std::move(*status));
   }
+  static bool IsOk(const absl::StatusOr<T>& status) { return status.ok(); }
+  template <typename R>
+  static R ReturnValue(absl::StatusOr<T>&& status) {
+    return StatusCast<R>(status.status());
+  }
   template <typename F, typename Elem>
   static auto CallSeqFactory(F& f, Elem&& elem, absl::StatusOr<T> value)
       -> decltype(f(std::forward<Elem>(elem), std::move(*value))) {
@@ -86,6 +99,11 @@ struct TrySeqTraitsWithSfinae<
   static auto CallFactory(Next* next, T&&) {
     return next->Make();
   }
+  static bool IsOk(const T& status) { return IsStatusOk(status); }
+  template <typename R>
+  static R ReturnValue(T&& status) {
+    return R(std::move(status));
+  }
   template <typename Result, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
     if (!IsStatusOk(prior)) return Result(std::move(prior));
@@ -100,6 +118,11 @@ struct TrySeqTraitsWithSfinae<absl::Status> {
   static auto CallFactory(Next* next, absl::Status&&) {
     return next->Make();
   }
+  static bool IsOk(const absl::Status& status) { return status.ok(); }
+  template <typename R>
+  static R ReturnValue(absl::Status&& status) {
+    return StatusCast<R>(std::move(status));
+  }
   template <typename Result, typename RunNext>
   static Poll<Result> CheckResultAndRunNext(absl::Status prior,
                                             RunNext run_next) {
@@ -111,8 +134,17 @@ struct TrySeqTraitsWithSfinae<absl::Status> {
 template <typename T>
 using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
 
-template <typename... Fs>
-using TrySeq = BasicSeq<TrySeqTraits, Fs...>;
+template <typename P, typename... Fs>
+class TrySeq {
+ public:
+  explicit TrySeq(P&& promise, Fs&&... factories)
+      : state_(std::forward<P>(promise), std::forward<Fs>(factories)...) {}
+
+  auto operator()() { return state_.PollOnce(); }
+
+ private:
+  SeqState<TrySeqTraits, P, Fs...> state_;
+};
 
 template <typename I, typename F, typename Arg>
 struct TrySeqIterTraits {

data/src/core/lib/resource_quota/api.cc

@@ -26,6 +26,7 @@
 #include "absl/strings/str_cat.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

data/src/core/lib/resource_quota/arena.cc

@@ -121,6 +121,7 @@ void Arena::ManagedNewObject::Link(std::atomic<ManagedNewObject*>* head) {
   }
 }
 
+#ifndef GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
 void* Arena::AllocPooled(size_t obj_size, size_t alloc_size,
                          std::atomic<FreePoolNode*>* head) {
   // ABA mitigation:
@@ -177,5 +178,6 @@ void Arena::FreePooled(void* p, std::atomic<FreePoolNode*>* head) {
       node->next, node, std::memory_order_acq_rel, std::memory_order_relaxed)) {
   }
 }
+#endif
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/arena.h

@@ -30,14 +30,10 @@
 #include <stddef.h>
 
 #include <atomic>
-#include <limits>
+#include <iosfwd>
 #include <memory>
-#include <new>
 #include <utility>
 
-#include "absl/meta/type_traits.h"
-#include "absl/utility/utility.h"
-
 #include <grpc/event_engine/memory_allocator.h>
 
 #include "src/core/lib/gpr/alloc.h"
@@ -45,13 +41,14 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 
-// #define GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
+#define GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
 // #define GRPC_ARENA_TRACE_POOLED_ALLOCATIONS
 
 namespace grpc_core {
 
 namespace arena_detail {
 
+#ifndef GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
 struct PoolAndSize {
   size_t alloc_size;
   size_t pool_index;
@@ -113,16 +110,29 @@ PoolAndSize ChoosePoolForAllocationSize(
     size_t n, absl::integer_sequence<size_t, kBucketSizes...>) {
   return ChoosePoolForAllocationSizeImpl<0, kBucketSizes...>::Fn(n);
 }
+#else
+template <typename T, typename A, typename B>
+struct IfArray {
+  using Result = A;
+};
+
+template <typename T, typename A, typename B>
+struct IfArray<T[], A, B> {
+  using Result = B;
+};
+#endif
 
 }  // namespace arena_detail
 
 class Arena {
+#ifndef GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
   // Selected pool sizes.
   // How to tune: see tools/codegen/core/optimize_arena_pool_sizes.py
   using PoolSizes = absl::integer_sequence<size_t, 80, 304, 528, 1024>;
   struct FreePoolNode {
     FreePoolNode* next;
   };
+#endif
 
  public:
   // Create an arena, with \a initial_size bytes in the first allocated buffer.
@@ -291,8 +301,30 @@ class Arena {
     bool delete_ = true;
   };
 
+  class ArrayPooledDeleter {
+   public:
+    ArrayPooledDeleter() = default;
+    explicit ArrayPooledDeleter(std::nullptr_t) : delete_(false) {}
+    template <typename T>
+    void operator()(T* p) {
+      // TODO(ctiller): promise based filter hijacks ownership of some pointers
+      // to make them appear as PoolPtr without really transferring ownership,
+      // by setting the arena to nullptr.
+      // This is a transitional hack and should be removed once promise based
+      // filter is removed.
+      if (delete_) delete[] p;
+    }
+
+    bool has_freelist() const { return delete_; }
+
+   private:
+    bool delete_ = true;
+  };
+
   template <typename T>
-  using PoolPtr = std::unique_ptr<T, PooledDeleter>;
+  using PoolPtr =
+      std::unique_ptr<T, typename arena_detail::IfArray<
+                             T, PooledDeleter, ArrayPooledDeleter>::Result>;
 
   // Make a unique_ptr to T that is allocated from the arena.
   // When the pointer is released, the memory may be reused for other
@@ -314,7 +346,7 @@ class Arena {
   //          arena size.
   template <typename T>
   PoolPtr<T[]> MakePooledArray(size_t n) {
-    return PoolPtr<T[]>(new T[n], PooledDeleter());
+    return PoolPtr<T[]>(new T[n], ArrayPooledDeleter());
   }
 
   // Like MakePooled, but with manual memory management.
@@ -372,9 +404,11 @@ class Arena {
 
   void* AllocZone(size_t size);
 
+#ifndef GRPC_ARENA_POOLED_ALLOCATIONS_USE_MALLOC
   void* AllocPooled(size_t obj_size, size_t alloc_size,
                     std::atomic<FreePoolNode*>* head);
   static void FreePooled(void* p, std::atomic<FreePoolNode*>* head);
+#endif
 
   void TracePoolAlloc(size_t size, void* ptr) {
     (void)size;

data/src/core/lib/resource_quota/memory_quota.cc

@@ -28,7 +28,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/mpscq.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/exec_ctx_wakeup_scheduler.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/lib/promise/map.h"

data/src/core/lib/resource_quota/resource_quota.h

@@ -23,6 +23,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"

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

@@ -19,8 +19,8 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
+#include <grpc/impl/channel_arg_names.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"

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

@@ -179,7 +179,7 @@ struct Rbac {
 
   std::string ToString() const;
 
-  // The authorization policy name or the HTTP RBAC filter name.
+  // The authorization policy name or empty string in xDS case.
   std::string name;
 
   Action action;

data/src/core/lib/security/credentials/external/aws_request_signer.cc

@@ -42,15 +42,23 @@ namespace grpc_core {
 
 namespace {
 
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+const char kSha256[] = "SHA256";
+#endif
 const char kAlgorithm[] = "AWS4-HMAC-SHA256";
 const char kDateFormat[] = "%a, %d %b %E4Y %H:%M:%S %Z";
 const char kXAmzDateFormat[] = "%Y%m%dT%H%M%SZ";
 
 void SHA256(const std::string& str, unsigned char out[SHA256_DIGEST_LENGTH]) {
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   SHA256_CTX sha256;
   SHA256_Init(&sha256);
   SHA256_Update(&sha256, str.c_str(), str.size());
   SHA256_Final(out, &sha256);
+#else
+  EVP_Q_digest(nullptr, kSha256, nullptr, str.c_str(), str.size(), out,
+               nullptr);
+#endif
 }
 
 std::string SHA256Hex(const std::string& str) {

data/src/core/lib/security/credentials/google_default/google_default_credentials.cc

@@ -32,6 +32,7 @@
 
 #include <grpc/grpc_security.h>  // IWYU pragma: keep
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/json.h>

data/src/core/lib/security/credentials/jwt/json_token.cc

@@ -115,8 +115,12 @@ grpc_auth_json_key grpc_auth_json_key_create_from_json(const Json& json) {
     gpr_log(GPR_ERROR, "Could not write into openssl BIO.");
     goto end;
   }
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   result.private_key =
       PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, const_cast<char*>(""));
+#else
+  result.private_key = PEM_read_bio_PrivateKey(bio, nullptr, nullptr, nullptr);
+#endif
   if (result.private_key == nullptr) {
     gpr_log(GPR_ERROR, "Could not deserialize private key.");
     goto end;
@@ -158,7 +162,11 @@ void grpc_auth_json_key_destruct(grpc_auth_json_key* json_key) {
     json_key->client_email = nullptr;
   }
   if (json_key->private_key != nullptr) {
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
     RSA_free(json_key->private_key);
+#else
+    EVP_PKEY_free(json_key->private_key);
+#endif
     json_key->private_key = nullptr;
   }
 }
@@ -237,7 +245,9 @@ char* compute_and_encode_signature(const grpc_auth_json_key* json_key,
                                    const char* to_sign) {
   const EVP_MD* md = openssl_digest_from_algorithm(signature_algorithm);
   EVP_MD_CTX* md_ctx = nullptr;
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   EVP_PKEY* key = EVP_PKEY_new();
+#endif
   size_t sig_len = 0;
   unsigned char* sig = nullptr;
   char* result = nullptr;
@@ -247,8 +257,13 @@ char* compute_and_encode_signature(const grpc_auth_json_key* json_key,
     gpr_log(GPR_ERROR, "Could not create MD_CTX");
     goto end;
   }
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   EVP_PKEY_set1_RSA(key, json_key->private_key);
   if (EVP_DigestSignInit(md_ctx, nullptr, md, nullptr, key) != 1) {
+#else
+  if (EVP_DigestSignInit(md_ctx, nullptr, md, nullptr, json_key->private_key) !=
+      1) {
+#endif
     gpr_log(GPR_ERROR, "DigestInit failed.");
     goto end;
   }
@@ -268,7 +283,9 @@ char* compute_and_encode_signature(const grpc_auth_json_key* json_key,
   result = grpc_base64_encode(sig, sig_len, 1, 0);
 
 end:
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   if (key != nullptr) EVP_PKEY_free(key);
+#endif
   if (md_ctx != nullptr) EVP_MD_CTX_destroy(md_ctx);
   if (sig != nullptr) gpr_free(sig);
   return result;

data/src/core/lib/security/credentials/jwt/json_token.h

@@ -38,7 +38,11 @@ struct grpc_auth_json_key {
   char* private_key_id;
   char* client_id;
   char* client_email;
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   RSA* private_key;
+#else
+  EVP_PKEY* private_key;
+#endif
 };
 // Returns 1 if the object is valid, 0 otherwise.
 int grpc_auth_json_key_is_valid(const grpc_auth_json_key* json_key);

data/src/core/lib/security/credentials/jwt/jwt_verifier.cc

@@ -37,6 +37,9 @@
 #include <openssl/pem.h>
 #include <openssl/rsa.h>
 #include <openssl/x509.h>
+#if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#include <openssl/param_build.h>
+#endif
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
@@ -523,7 +526,13 @@ static int RSA_set0_key(RSA* r, BIGNUM* n, BIGNUM* e, BIGNUM* d) {
 #endif  // OPENSSL_VERSION_NUMBER < 0x10100000L
 
 static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   RSA* rsa = nullptr;
+#else
+  EVP_PKEY_CTX* ctx = nullptr;
+  OSSL_PARAM* params = NULL;
+  OSSL_PARAM_BLD* bld = OSSL_PARAM_BLD_new();
+#endif
   EVP_PKEY* result = nullptr;
   BIGNUM* tmp_n = nullptr;
   BIGNUM* tmp_e = nullptr;
@@ -535,11 +544,13 @@ static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
     gpr_log(GPR_ERROR, "Unsupported key type %s.", kty);
     goto end;
   }
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   rsa = RSA_new();
   if (rsa == nullptr) {
     gpr_log(GPR_ERROR, "Could not create rsa key.");
     goto end;
   }
+#endif
   it = json.object().find("n");
   if (it == json.object().end()) {
     gpr_log(GPR_ERROR, "Missing RSA public key field.");
@@ -554,6 +565,7 @@ static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
   }
   tmp_e = bignum_from_base64(validate_string_field(it->second, "e"));
   if (tmp_e == nullptr) goto end;
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   if (!RSA_set0_key(rsa, tmp_n, tmp_e, nullptr)) {
     gpr_log(GPR_ERROR, "Cannot set RSA key from inputs.");
     goto end;
@@ -563,9 +575,38 @@ static EVP_PKEY* pkey_from_jwk(const Json& json, const char* kty) {
   tmp_e = nullptr;
   result = EVP_PKEY_new();
   EVP_PKEY_set1_RSA(result, rsa);  // uprefs rsa.
+#else
+
+  if (!OSSL_PARAM_BLD_push_BN(bld, "n", tmp_n) ||
+      !OSSL_PARAM_BLD_push_BN(bld, "e", tmp_e) ||
+      (params = OSSL_PARAM_BLD_to_param(bld)) == NULL) {
+    gpr_log(GPR_ERROR, "Could not create OSSL_PARAM");
+    goto end;
+  }
+
+  ctx = EVP_PKEY_CTX_new_from_name(nullptr, "RSA", nullptr);
+  if (ctx == nullptr) {
+    gpr_log(GPR_ERROR, "Could not create rsa key.");
+    goto end;
+  }
+  if (EVP_PKEY_fromdata_init(ctx) <= 0) {
+    gpr_log(GPR_ERROR, "Could not create rsa key.");
+    goto end;
+  }
+  if (EVP_PKEY_fromdata(ctx, &result, EVP_PKEY_KEYPAIR, params) <= 0) {
+    gpr_log(GPR_ERROR, "Cannot set RSA key from inputs.");
+    goto end;
+  }
+#endif
 
 end:
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   RSA_free(rsa);
+#else
+  EVP_PKEY_CTX_free(ctx);
+  OSSL_PARAM_free(params);
+  OSSL_PARAM_BLD_free(bld);
+#endif
   BN_free(tmp_n);
   BN_free(tmp_e);
   return result;
@@ -642,6 +683,7 @@ static int verify_jwt_signature(EVP_PKEY* key, const char* alg,
   if (EVP_DigestVerifyFinal(md_ctx, GRPC_SLICE_START_PTR(signature),
                             GRPC_SLICE_LENGTH(signature)) != 1) {
     gpr_log(GPR_ERROR, "JWT signature verification failed.");
+
     goto end;
   }
   result = 1;

data/src/core/lib/security/credentials/ssl/ssl_credentials.cc

@@ -28,6 +28,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

data/src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.cc

@@ -437,7 +437,11 @@ absl::StatusOr<bool> PrivateKeyAndCertificateMatch(
     return absl::InvalidArgumentError(
         "Conversion from PEM string to EVP_PKEY failed.");
   }
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
   bool result = EVP_PKEY_cmp(private_evp_pkey, public_evp_pkey) == 1;
+#else
+  bool result = EVP_PKEY_eq(private_evp_pkey, public_evp_pkey) == 1;
+#endif
   EVP_PKEY_free(private_evp_pkey);
   EVP_PKEY_free(public_evp_pkey);
   return result;

data/src/core/lib/security/credentials/tls/tls_credentials.cc

@@ -28,6 +28,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/security/credentials/xds/xds_credentials.cc

@@ -24,6 +24,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_args.h"

data/src/core/lib/security/security_connector/alts/alts_security_connector.cc

@@ -31,6 +31,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>

data/src/core/lib/security/security_connector/fake/fake_security_connector.cc

@@ -34,6 +34,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

data/src/core/lib/security/security_connector/ssl_utils.cc

@@ -30,6 +30,7 @@
 #include "absl/strings/str_split.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

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

@@ -18,6 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
 #include <string.h>
 
 #include <functional>
@@ -43,7 +44,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
-#include "src/core/lib/promise/detail/basic_seq.h"
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/seq.h"
 #include "src/core/lib/promise/try_seq.h"
@@ -196,10 +196,13 @@ ArenaPromise<ServerMetadataHandle> ClientAuthFilter::MakeCallPromise(
   if (host == nullptr) {
     return next_promise_factory(std::move(call_args));
   }
-  return TrySeq(args_.security_connector->CheckCallHost(
-                    host->as_string_view(), args_.auth_context.get()),
-                GetCallCredsMetadata(std::move(call_args)),
-                next_promise_factory);
+  return TrySeq(
+      args_.security_connector->CheckCallHost(host->as_string_view(),
+                                              args_.auth_context.get()),
+      [this, call_args = std::move(call_args)]() mutable {
+        return GetCallCredsMetadata(std::move(call_args));
+      },
+      next_promise_factory);
 }
 
 absl::StatusOr<ClientAuthFilter> ClientAuthFilter::Create(

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

@@ -36,6 +36,7 @@
 
 #include <grpc/grpc_security.h>
 #include <grpc/grpc_security_constants.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <algorithm>
 #include <atomic>
 #include <cstddef>