grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/transport/handshaker_factory.h

@@ -21,8 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 
 // A handshaker factory is used to create handshakers.
@@ -38,7 +37,7 @@ class HandshakeManager;
 
 class HandshakerFactory {
  public:
-  virtual void AddHandshakers(const grpc_channel_args* args,
+  virtual void AddHandshakers(const ChannelArgs& args,
                               grpc_pollset_set* interested_parties,
                               HandshakeManager* handshake_mgr) = 0;
   virtual ~HandshakerFactory() = default;

data/src/core/lib/transport/handshaker_registry.cc

@@ -22,6 +22,7 @@
 
 #include <stddef.h>
 
+#include <algorithm>
 #include <utility>
 
 namespace grpc_core {
@@ -43,7 +44,7 @@ HandshakerRegistry HandshakerRegistry::Builder::Build() {
 }
 
 void HandshakerRegistry::AddHandshakers(HandshakerType handshaker_type,
-                                        const grpc_channel_args* args,
+                                        const ChannelArgs& args,
                                         grpc_pollset_set* interested_parties,
                                         HandshakeManager* handshake_mgr) const {
   for (const auto& factory : factories_[handshaker_type]) {

data/src/core/lib/transport/handshaker_registry.h

@@ -24,8 +24,7 @@
 #include <memory>
 #include <vector>
 
-#include <grpc/impl/codegen/grpc_types.h>
-
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/transport/handshaker_factory.h"
 
@@ -55,8 +54,7 @@ class HandshakerRegistry {
         factories_[NUM_HANDSHAKER_TYPES];
   };
 
-  void AddHandshakers(HandshakerType handshaker_type,
-                      const grpc_channel_args* args,
+  void AddHandshakers(HandshakerType handshaker_type, const ChannelArgs& args,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr) const;
 

data/src/core/lib/transport/http_connect_handshaker.cc

@@ -30,8 +30,8 @@
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -118,8 +118,7 @@ void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
   args_->endpoint = nullptr;
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
-  grpc_channel_args_destroy(args_->args);
-  args_->args = nullptr;
+  args_->args = ChannelArgs();
 }
 
 // If the handshake failed or we're shutting down, clean up and invoke the
@@ -297,10 +296,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
                                         HandshakerArgs* args) {
   // Check for HTTP CONNECT channel arg.
   // If not found, invoke on_handshake_done without doing anything.
-  const grpc_arg* arg =
-      grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_SERVER);
-  char* server_name = grpc_channel_arg_get_string(arg);
-  if (server_name == nullptr) {
+  absl::optional<absl::string_view> server_name =
+      args->args.GetString(GRPC_ARG_HTTP_CONNECT_SERVER);
+  if (!server_name.has_value()) {
     // Set shutdown to true so that subsequent calls to
     // http_connect_handshaker_shutdown() do nothing.
     {
@@ -311,14 +309,15 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
     return;
   }
   // Get headers from channel args.
-  arg = grpc_channel_args_find(args->args, GRPC_ARG_HTTP_CONNECT_HEADERS);
-  char* arg_header_string = grpc_channel_arg_get_string(arg);
+  absl::optional<absl::string_view> arg_header_string =
+      args->args.GetString(GRPC_ARG_HTTP_CONNECT_HEADERS);
   grpc_http_header* headers = nullptr;
   size_t num_headers = 0;
   char** header_strings = nullptr;
   size_t num_header_strings = 0;
-  if (arg_header_string != nullptr) {
-    gpr_string_split(arg_header_string, "\n", &header_strings,
+  if (arg_header_string.has_value()) {
+    std::string buffer(*arg_header_string);
+    gpr_string_split(buffer.c_str(), "\n", &header_strings,
                      &num_header_strings);
     headers = static_cast<grpc_http_header*>(
         gpr_malloc(sizeof(grpc_http_header) * num_header_strings));
@@ -342,8 +341,9 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   on_handshake_done_ = on_handshake_done;
   // Log connection via proxy.
   std::string proxy_name(grpc_endpoint_get_peer(args->endpoint));
-  gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s", server_name,
-          proxy_name.c_str());
+  std::string server_name_string(*server_name);
+  gpr_log(GPR_INFO, "Connecting to server %s via HTTP proxy %s",
+          server_name_string.c_str(), proxy_name.c_str());
   // Construct HTTP CONNECT request.
   grpc_http_request request;
   request.method = const_cast<char*>("CONNECT");
@@ -352,8 +352,8 @@ void HttpConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   request.hdr_count = num_headers;
   request.body_length = 0;
   request.body = nullptr;
-  grpc_slice request_slice =
-      grpc_httpcli_format_connect_request(&request, server_name, server_name);
+  grpc_slice request_slice = grpc_httpcli_format_connect_request(
+      &request, server_name_string.c_str(), server_name_string.c_str());
   grpc_slice_buffer_add(&write_buffer_, request_slice);
   // Clean up.
   gpr_free(headers);
@@ -382,7 +382,7 @@ HttpConnectHandshaker::HttpConnectHandshaker() {
 
 class HttpConnectHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* /*args*/,
+  void AddHandshakers(const ChannelArgs& /*args*/,
                       grpc_pollset_set* /*interested_parties*/,
                       HandshakeManager* handshake_mgr) override {
     handshake_mgr->Add(MakeRefCounted<HttpConnectHandshaker>());

data/src/core/lib/transport/metadata_batch.cc

@@ -284,4 +284,9 @@ const std::string& GrpcStatusContext::DisplayValue(const std::string& x) {
   return x;
 }
 
+std::string WaitForReady::DisplayValue(ValueType x) {
+  return absl::StrCat(x.value ? "true" : "false",
+                      x.explicitly_set ? " (explicit)" : "");
+}
+
 }  // namespace grpc_core

data/src/core/lib/transport/metadata_batch.h

@@ -25,7 +25,6 @@
 
 #include <cstdint>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
@@ -388,6 +387,17 @@ struct GrpcStatusContext {
   static const std::string& DisplayValue(const std::string& x);
 };
 
+// Annotation added by client surface code to denote wait-for-ready state
+struct WaitForReady {
+  struct ValueType {
+    bool value = false;
+    bool explicitly_set = false;
+  };
+  static absl::string_view DebugKey() { return "WaitForReady"; }
+  static constexpr bool kRepeatable = false;
+  static std::string DisplayValue(ValueType x);
+};
+
 namespace metadata_detail {
 
 // Build a key/value formatted debug string.
@@ -678,6 +688,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
   void EncodeTo(Encoder* encoder) const {
     encoder->Encode(Which(), value);
   }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
   void LogTo(LogFn log_fn) const {
     LogKeyValueTo(Which::key(), value, Which::Encode, log_fn);
   }
@@ -702,6 +716,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == false &&
   }
   template <typename Encoder>
   void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    encoder->Encode(Which(), value);
+  }
   void LogTo(LogFn log_fn) const {
     LogKeyValueTo(Which::DebugKey(), value, Which::DisplayValue, log_fn);
   }
@@ -733,6 +751,10 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
       encoder->Encode(Which(), v);
     }
   }
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    return EncodeTo(encoder);
+  }
   void LogTo(LogFn log_fn) const {
     for (const auto& v : value) {
       LogKeyValueTo(Which::key(), v, Which::Encode, log_fn);
@@ -762,6 +784,12 @@ struct Value<Which, absl::enable_if_t<Which::kRepeatable == true &&
   }
   template <typename Encoder>
   void EncodeTo(Encoder*) const {}
+  template <typename Encoder>
+  void VisitWith(Encoder* encoder) const {
+    for (const auto& v : value) {
+      encoder->Encode(Which(), v);
+    }
+  }
   void LogTo(LogFn log_fn) const {
     for (const auto& v : value) {
       LogKeyValueTo(Which::DebugKey(), v, Which::DisplayValue, log_fn);
@@ -806,6 +834,17 @@ struct EncodeWrapper {
   }
 };
 
+// Callable for the table ForEach in ForEach() -- for each value, call the
+// appropriate visitor method.
+template <typename Encoder>
+struct ForEachWrapper {
+  Encoder* encoder;
+  template <typename Which>
+  void operator()(const Value<Which>& which) {
+    which.VisitWith(encoder);
+  }
+};
+
 // Callable for the ForEach in Log()
 struct LogWrapper {
   LogFn log_fn;
@@ -1003,10 +1042,7 @@ class MetadataMap {
   //    void Encode(TraitsType, typename TraitsType::ValueType value);
   // For fields for which we do not have traits, this will be a method
   // with the signature:
-  //    void Encode(grpc_mdelem md);
-  // TODO(ctiller): It's expected that the latter Encode method will
-  // become Encode(Slice, Slice) by the end of the current metadata API
-  // transitions.
+  //    void Encode(string_view key, Slice value);
   template <typename Encoder>
   void Encode(Encoder* encoder) const {
     table_.ForEach(metadata_detail::EncodeWrapper<Encoder>{encoder});
@@ -1015,6 +1051,15 @@ class MetadataMap {
     }
   }
 
+  // Like Encode, but also visit the non-encodable fields.
+  template <typename Encoder>
+  void ForEach(Encoder* encoder) const {
+    table_.ForEach(metadata_detail::ForEachWrapper<Encoder>{encoder});
+    for (const auto& unk : unknown_) {
+      encoder->Encode(unk.first, unk.second);
+    }
+  }
+
   // Similar to Encode, but targeted at logging: for each metadatum,
   // call f(key, value) as absl::string_views.
   void Log(metadata_detail::LogFn log_fn) const {
@@ -1227,7 +1272,7 @@ template <typename Derived, typename... Traits>
 Derived MetadataMap<Derived, Traits...>::Copy() const {
   Derived out(unknown_.arena());
   metadata_detail::CopySink<Derived> sink(&out);
-  Encode(&sink);
+  ForEach(&sink);
   return out;
 }
 
@@ -1254,7 +1299,7 @@ using grpc_metadata_batch_base = grpc_core::MetadataMap<
     grpc_core::LbCostBinMetadata, grpc_core::LbTokenMetadata,
     // Non-encodable things
     grpc_core::GrpcStreamNetworkState, grpc_core::PeerString,
-    grpc_core::GrpcStatusContext>;
+    grpc_core::GrpcStatusContext, grpc_core::WaitForReady>;
 
 struct grpc_metadata_batch : public grpc_metadata_batch_base {
   using grpc_metadata_batch_base::grpc_metadata_batch_base;

data/src/core/lib/transport/parsed_metadata.h

@@ -21,7 +21,6 @@
 
 #include <cstdint>
 #include <string>
-#include <type_traits>
 #include <utility>
 
 #include "absl/functional/function_ref.h"

data/src/core/lib/transport/tcp_connect_handshaker.cc

@@ -25,8 +25,9 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/memory/memory.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -34,7 +35,6 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -129,25 +129,20 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   }
   GPR_ASSERT(args->endpoint == nullptr);
   args_ = args;
-  char* address = grpc_channel_args_find_string(
-      args->args, GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS);
-  absl::StatusOr<URI> uri = URI::Parse(address);
+  absl::StatusOr<URI> uri = URI::Parse(
+      args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value());
   if (!uri.ok() || !grpc_parse_uri(*uri, &addr_)) {
     MutexLock lock(&mu_);
     FinishLocked(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Resolved address in invalid format"));
     return;
   }
-  bind_endpoint_to_pollset_ = grpc_channel_args_find_bool(
-      args->args, GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET, false);
-  const char* args_to_remove[] = {
-      GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS,
-      GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET};
+  bind_endpoint_to_pollset_ =
+      args->args.GetBool(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET)
+          .value_or(false);
   // Update args to not contain the args relevant to TCP connect handshaker.
-  grpc_channel_args* channel_args = grpc_channel_args_copy_and_remove(
-      args->args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove));
-  grpc_channel_args_destroy(args->args);
-  args->args = channel_args;
+  args->args = args->args.Remove(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS)
+                   .Remove(GRPC_ARG_TCP_HANDSHAKER_BIND_ENDPOINT_TO_POLLSET);
   // In some implementations, the closure can be flushed before
   // grpc_tcp_client_connect() returns, and since the closure requires access
   // to mu_, this can result in a deadlock (see
@@ -160,7 +155,7 @@ void TCPConnectHandshaker::DoHandshake(grpc_tcp_server_acceptor* /*acceptor*/,
   // Instead pass endpoint_ and swap this endpoint to
   // args endpoint on success.
   grpc_tcp_client_connect(&connected_, &endpoint_to_destroy_,
-                          interested_parties_, args->args, &addr_,
+                          interested_parties_, args->args.ToC().get(), &addr_,
                           args->deadline);
 }
 
@@ -215,8 +210,7 @@ TCPConnectHandshaker::~TCPConnectHandshaker() {
 void TCPConnectHandshaker::CleanupArgsForFailureLocked() {
   read_buffer_to_destroy_ = args_->read_buffer;
   args_->read_buffer = nullptr;
-  grpc_channel_args_destroy(args_->args);
-  args_->args = nullptr;
+  args_->args = ChannelArgs();
 }
 
 void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
@@ -233,7 +227,7 @@ void TCPConnectHandshaker::FinishLocked(grpc_error_handle error) {
 
 class TCPConnectHandshakerFactory : public HandshakerFactory {
  public:
-  void AddHandshakers(const grpc_channel_args* /*args*/,
+  void AddHandshakers(const ChannelArgs& /*args*/,
                       grpc_pollset_set* interested_parties,
                       HandshakeManager* handshake_mgr) override {
     handshake_mgr->Add(

data/src/core/lib/transport/transport.h

@@ -344,9 +344,6 @@ struct grpc_transport_stream_op_batch_payload {
       : context(context) {}
   struct {
     grpc_metadata_batch* send_initial_metadata = nullptr;
-    /** Iff send_initial_metadata != NULL, flags associated with
-        send_initial_metadata: a bitfield of GRPC_INITIAL_METADATA_xxx */
-    uint32_t send_initial_metadata_flags = 0;
     // If non-NULL, will be set by the transport to the peer string (a char*).
     // The transport retains ownership of the string.
     // Note: This pointer may be used by the transport after the
@@ -388,10 +385,6 @@ struct grpc_transport_stream_op_batch_payload {
 
   struct {
     grpc_metadata_batch* recv_initial_metadata = nullptr;
-    // Flags are used only on the server side.  If non-null, will be set to
-    // a bitfield of the GRPC_INITIAL_METADATA_xxx macros (e.g., to
-    // indicate if the call is idempotent).
-    uint32_t* recv_flags = nullptr;
     /** Should be enqueued when initial metadata is ready to be processed. */
     grpc_closure* recv_initial_metadata_ready = nullptr;
     // If not NULL, will be set to true if trailing metadata is

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -71,7 +71,8 @@ typedef struct alts_grpc_handshaker_client {
    * handshaker service. */
   grpc_byte_buffer* send_buffer = nullptr;
   grpc_byte_buffer* recv_buffer = nullptr;
-  grpc_status_code status = GRPC_STATUS_OK;
+  // Used to inject a read failure from tests.
+  bool inject_read_failure = false;
   /* Initial metadata to be received from handshaker service. */
   grpc_metadata_array recv_initial_metadata;
   /* A callback function provided by an application to be invoked when response
@@ -106,6 +107,8 @@ typedef struct alts_grpc_handshaker_client {
   recv_message_result* pending_recv_message_result = nullptr;
   /* Maximum frame size used by frame protector. */
   size_t max_frame_size;
+  // If non-null, will be populated with an error string upon error.
+  std::string* error;
 } alts_grpc_handshaker_client;
 
 static void handshaker_client_send_buffer_destroy(
@@ -174,10 +177,11 @@ static void maybe_complete_tsi_next(
 }
 
 static void handle_response_done(alts_grpc_handshaker_client* client,
-                                 tsi_result status,
+                                 tsi_result status, std::string error,
                                  const unsigned char* bytes_to_send,
                                  size_t bytes_to_send_size,
                                  tsi_handshaker_result* result) {
+  if (client->error != nullptr) *client->error = std::move(error);
   recv_message_result* p = grpc_core::Zalloc<recv_message_result>();
   p->status = status;
   p->bytes_to_send = bytes_to_send;
@@ -193,7 +197,6 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   grpc_byte_buffer* recv_buffer = client->recv_buffer;
-  grpc_status_code status = client->status;
   alts_tsi_handshaker* handshaker = client->handshaker;
   /* Invalid input check. */
   if (client->cb == nullptr) {
@@ -204,25 +207,34 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   if (handshaker == nullptr) {
     gpr_log(GPR_ERROR,
             "handshaker is nullptr in alts_tsi_handshaker_handle_response()");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+    handle_response_done(
+        client, TSI_INTERNAL_ERROR,
+        "handshaker is nullptr in alts_tsi_handshaker_handle_response()",
+        nullptr, 0, nullptr);
     return;
   }
   /* TSI handshake has been shutdown. */
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
     gpr_log(GPR_INFO, "TSI handshake shutdown");
-    handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN,
+                         "TSI handshake shutdown", nullptr, 0, nullptr);
     return;
   }
-  /* Failed grpc call check. */
-  if (!is_ok || status != GRPC_STATUS_OK) {
-    gpr_log(GPR_INFO, "grpc call made to handshaker service failed");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+  /* Check for failed grpc read. */
+  if (!is_ok || client->inject_read_failure) {
+    gpr_log(GPR_INFO, "read failed on grpc call to handshaker service");
+    handle_response_done(client, TSI_INTERNAL_ERROR,
+                         "read failed on grpc call to handshaker service",
+                         nullptr, 0, nullptr);
     return;
   }
   if (recv_buffer == nullptr) {
     gpr_log(GPR_ERROR,
             "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+    handle_response_done(
+        client, TSI_INTERNAL_ERROR,
+        "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()",
+        nullptr, 0, nullptr);
     return;
   }
   upb::Arena arena;
@@ -233,14 +245,17 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   /* Invalid handshaker response check. */
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "alts_tsi_utils_deserialize_response() failed");
-    handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_DATA_CORRUPTED,
+                         "alts_tsi_utils_deserialize_response() failed",
+                         nullptr, 0, nullptr);
     return;
   }
   const grpc_gcp_HandshakerStatus* resp_status =
       grpc_gcp_HandshakerResp_status(resp);
   if (resp_status == nullptr) {
     gpr_log(GPR_ERROR, "No status in HandshakerResp");
-    handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_DATA_CORRUPTED,
+                         "No status in HandshakerResp", nullptr, 0, nullptr);
     return;
   }
   upb_StringView out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
@@ -262,7 +277,9 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
         alts_tsi_handshaker_result_create(resp, client->is_client, &result);
     if (status != TSI_OK) {
       gpr_log(GPR_ERROR, "alts_tsi_handshaker_result_create() failed");
-      handle_response_done(client, status, nullptr, 0, nullptr);
+      handle_response_done(client, status,
+                           "alts_tsi_handshaker_result_create() failed",
+                           nullptr, 0, nullptr);
       return;
     }
     alts_tsi_handshaker_result_set_unused_bytes(
@@ -271,13 +288,13 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   }
   grpc_status_code code = static_cast<grpc_status_code>(
       grpc_gcp_HandshakerStatus_code(resp_status));
+  std::string error;
   if (code != GRPC_STATUS_OK) {
     upb_StringView details = grpc_gcp_HandshakerStatus_details(resp_status);
     if (details.size > 0) {
-      char* error_details = static_cast<char*>(gpr_zalloc(details.size + 1));
-      memcpy(error_details, details.data, details.size);
-      gpr_log(GPR_ERROR, "Error from handshaker service:%s", error_details);
-      gpr_free(error_details);
+      error = absl::StrCat("Status ", code, " from handshaker service: ",
+                           absl::string_view(details.data, details.size));
+      gpr_log(GPR_ERROR, "%s", error.c_str());
     }
   }
   // TODO(apolcyn): consider short ciruiting handle_response_done and
@@ -285,7 +302,8 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   // handle_response_done's allocation per message received causes
   // a performance issue.
   handle_response_done(client, alts_tsi_utils_convert_to_tsi_result(code),
-                       bytes_to_send, bytes_to_send_size, result);
+                       std::move(error), bytes_to_send, bytes_to_send_size,
+                       result);
 }
 
 static tsi_result continue_make_grpc_call(alts_grpc_handshaker_client* client,
@@ -690,7 +708,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     grpc_alts_credentials_options* options, const grpc_slice& target_name,
     grpc_iomgr_cb_func grpc_cb, tsi_handshaker_on_next_done_cb cb,
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
-    bool is_client, size_t max_frame_size) {
+    bool is_client, size_t max_frame_size, std::string* error) {
   if (channel == nullptr || handshaker_service_url == nullptr) {
     gpr_log(GPR_ERROR, "Invalid arguments to alts_handshaker_client_create()");
     return nullptr;
@@ -713,6 +731,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
   client->buffer = static_cast<unsigned char*>(gpr_zalloc(client->buffer_size));
   client->handshake_status_details = grpc_empty_slice();
   client->max_frame_size = max_frame_size;
+  client->error = error;
   grpc_slice slice = grpc_slice_from_copied_string(handshaker_service_url);
   client->call =
       strcmp(handshaker_service_url, ALTS_HANDSHAKER_SERVICE_URL_FOR_TESTING) ==
@@ -776,7 +795,7 @@ void alts_handshaker_client_set_recv_bytes_for_testing(
 void alts_handshaker_client_set_fields_for_testing(
     alts_handshaker_client* c, alts_tsi_handshaker* handshaker,
     tsi_handshaker_on_next_done_cb cb, void* user_data,
-    grpc_byte_buffer* recv_buffer, grpc_status_code status) {
+    grpc_byte_buffer* recv_buffer, bool inject_read_failure) {
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
@@ -784,7 +803,7 @@ void alts_handshaker_client_set_fields_for_testing(
   client->cb = cb;
   client->user_data = user_data;
   client->recv_buffer = recv_buffer;
-  client->status = status;
+  client->inject_read_failure = inject_read_failure;
 }
 
 void alts_handshaker_client_check_fields_for_testing(

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -144,7 +144,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     grpc_alts_credentials_options* options, const grpc_slice& target_name,
     grpc_iomgr_cb_func grpc_cb, tsi_handshaker_on_next_done_cb cb,
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
-    bool is_client, size_t max_frame_size);
+    bool is_client, size_t max_frame_size, std::string* error);
 
 /**
  * This method handles handshaker response returned from ALTS handshaker