grpc 1.46.3 → 1.53.1

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 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_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
-#define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
+//
+//
+// Copyright 2018 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_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
+#define GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -38,19 +38,19 @@
 const size_t kAltsAes128GcmRekeyKeyLength = 44;
 
 typedef struct alts_tsi_handshaker alts_tsi_handshaker;
-/**
- * A ALTS handshaker client interface. It is used to communicate with
- * ALTS handshaker service by scheduling a handshaker request that could be one
- * of client_start, server_start, and next handshaker requests. All APIs in the
- * header are thread-compatible.
- */
+///
+/// A ALTS handshaker client interface. It is used to communicate with
+/// ALTS handshaker service by scheduling a handshaker request that could be one
+/// of client_start, server_start, and next handshaker requests. All APIs in the
+/// header are thread-compatible.
+///
 typedef struct alts_handshaker_client alts_handshaker_client;
 
-/* A function that makes the grpc call to the handshaker service. */
+// A function that makes the grpc call to the handshaker service.
 typedef grpc_call_error (*alts_grpc_caller)(grpc_call* call, const grpc_op* ops,
                                             size_t nops, grpc_closure* tag);
 
-/* V-table for ALTS handshaker client operations. */
+// V-table for ALTS handshaker client operations.
 typedef struct alts_handshaker_client_vtable {
   tsi_result (*client_start)(alts_handshaker_client* client);
   tsi_result (*server_start)(alts_handshaker_client* client,
@@ -61,100 +61,100 @@ typedef struct alts_handshaker_client_vtable {
   void (*destruct)(alts_handshaker_client* client);
 } alts_handshaker_client_vtable;
 
-/**
- * This method schedules a client_start handshaker request to ALTS handshaker
- * service.
- *
- * - client: ALTS handshaker client instance.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a client_start handshaker request to ALTS handshaker
+/// service.
+///
+///- client: ALTS handshaker client instance.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_start_client(alts_handshaker_client* client);
 
-/**
- * This method schedules a server_start handshaker request to ALTS handshaker
- * service.
- *
- * - client: ALTS handshaker client instance.
- * - bytes_received: bytes in out_frames returned from the peer's handshaker
- *   response.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a server_start handshaker request to ALTS handshaker
+/// service.
+///
+///- client: ALTS handshaker client instance.
+///- bytes_received: bytes in out_frames returned from the peer's handshaker
+///  response.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_start_server(alts_handshaker_client* client,
                                                grpc_slice* bytes_received);
 
-/**
- * This method schedules a next handshaker request to ALTS handshaker service.
- *
- * - client: ALTS handshaker client instance.
- * - bytes_received: bytes in out_frames returned from the peer's handshaker
- *   response.
- *
- * It returns TSI_OK on success and an error status code on failure.
- */
+///
+/// This method schedules a next handshaker request to ALTS handshaker service.
+///
+///- client: ALTS handshaker client instance.
+///- bytes_received: bytes in out_frames returned from the peer's handshaker
+///  response.
+///
+/// It returns TSI_OK on success and an error status code on failure.
+///
 tsi_result alts_handshaker_client_next(alts_handshaker_client* client,
                                        grpc_slice* bytes_received);
 
-/**
- * This method cancels previously scheduled, but yet executed handshaker
- * requests to ALTS handshaker service. After this operation, the handshake
- * will be shutdown, and no more handshaker requests will get scheduled.
- *
- * - client: ALTS handshaker client instance.
- */
+///
+/// This method cancels previously scheduled, but yet executed handshaker
+/// requests to ALTS handshaker service. After this operation, the handshake
+/// will be shutdown, and no more handshaker requests will get scheduled.
+///
+///- client: ALTS handshaker client instance.
+///
 void alts_handshaker_client_shutdown(alts_handshaker_client* client);
 
-/**
- * This method destroys an ALTS handshaker client.
- *
- * - client: an ALTS handshaker client instance.
- */
+///
+/// This method destroys an ALTS handshaker client.
+///
+///- client: an ALTS handshaker client instance.
+///
 void alts_handshaker_client_destroy(alts_handshaker_client* client);
 
-/**
- * This method creates an ALTS handshaker client.
- *
- * - handshaker: ALTS TSI handshaker to which the created handshaker client
- *   belongs to.
- * - channel: grpc channel to ALTS handshaker service.
- * - handshaker_service_url: address of ALTS handshaker service in the format of
- *   "host:port".
- * - interested_parties: set of pollsets interested in this connection.
- * - options: ALTS credentials options containing information passed from TSI
- *   caller (e.g., rpc protocol versions)
- * - target_name: the name of the endpoint that the channel is connecting to,
- *   and will be used for secure naming check
- * - grpc_cb: gRPC provided callbacks passed from TSI handshaker.
- * - cb: callback to be executed when tsi_handshaker_next API compltes.
- * - user_data: argument passed to cb.
- * - vtable_for_testing: ALTS handshaker client vtable instance used for
- *   testing purpose.
- * - is_client: a boolean value indicating if the created handshaker client is
- *   used at the client (is_client = true) or server (is_client = false) side.
- * - max_frame_size: Maximum frame size used by frame protector (User specified
- *   maximum frame size if present or default max frame size).
- *
- * It returns the created ALTS handshaker client on success, and NULL
- * on failure.
- */
+///
+/// This method creates an ALTS handshaker client.
+///
+///- handshaker: ALTS TSI handshaker to which the created handshaker client
+///  belongs to.
+///- channel: grpc channel to ALTS handshaker service.
+///- handshaker_service_url: address of ALTS handshaker service in the format of
+///  "host:port".
+///- interested_parties: set of pollsets interested in this connection.
+///- options: ALTS credentials options containing information passed from TSI
+///  caller (e.g., rpc protocol versions)
+///- target_name: the name of the endpoint that the channel is connecting to,
+///  and will be used for secure naming check
+///- grpc_cb: gRPC provided callbacks passed from TSI handshaker.
+///- cb: callback to be executed when tsi_handshaker_next API compltes.
+///- user_data: argument passed to cb.
+///- vtable_for_testing: ALTS handshaker client vtable instance used for
+///  testing purpose.
+///- is_client: a boolean value indicating if the created handshaker client is
+///  used at the client (is_client = true) or server (is_client = false) side.
+///- max_frame_size: Maximum frame size used by frame protector (User specified
+///  maximum frame size if present or default max frame size).
+///
+/// It returns the created ALTS handshaker client on success, and NULL
+/// on failure.
+///
 alts_handshaker_client* alts_grpc_handshaker_client_create(
     alts_tsi_handshaker* handshaker, grpc_channel* channel,
     const char* handshaker_service_url, grpc_pollset_set* interested_parties,
     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);
-
-/**
- * This method handles handshaker response returned from ALTS handshaker
- * service. Note that the only reason the API is exposed is that it is used in
- * alts_shared_resources.cc.
- *
- * - client: an ALTS handshaker client instance.
- * - is_ok: a boolean value indicating if the handshaker response is ok to read.
- */
+    bool is_client, size_t max_frame_size, std::string* error);
+
+///
+/// This method handles handshaker response returned from ALTS handshaker
+/// service. Note that the only reason the API is exposed is that it is used in
+/// alts_shared_resources.cc.
+///
+///- client: an ALTS handshaker client instance.
+///- is_ok: a boolean value indicating if the handshaker response is ok to read.
+///
 void alts_handshaker_client_handle_response(alts_handshaker_client* client,
                                             bool is_ok);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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>
 
@@ -23,6 +23,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
 static alts_shared_resource_dedicated g_alts_resource_dedicated;

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
-#define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
+#ifndef GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
+#define GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -28,10 +28,10 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/surface/completion_queue.h"
 
-/**
- * Main struct containing ALTS shared resources used when
- * employing the dedicated completion queue and thread.
- */
+///
+/// Main struct containing ALTS shared resources used when
+/// employing the dedicated completion queue and thread.
+///
 typedef struct alts_shared_resource_dedicated {
   grpc_core::Thread thread;
   grpc_completion_queue* cq;
@@ -41,33 +41,32 @@ typedef struct alts_shared_resource_dedicated {
   grpc_channel* channel;
 } alts_shared_resource_dedicated;
 
-/* This method returns the address of alts_shared_resource_dedicated
- * object shared by all TSI handshakes.
- */
+// This method returns the address of alts_shared_resource_dedicated
+// object shared by all TSI handshakes.
+//
 alts_shared_resource_dedicated* grpc_alts_get_shared_resource_dedicated(void);
 
-/**
- * This method destroys the alts_shared_resource_dedicated object
- * shared by all TSI handshakes. The application is responsible for
- * invoking the API before calling grpc_shutdown().
- */
+///
+/// This method destroys the alts_shared_resource_dedicated object
+/// shared by all TSI handshakes. The application is responsible for
+/// invoking the API before calling grpc_shutdown().
+///
 void grpc_alts_shared_resource_dedicated_shutdown();
 
-/**
- * This method initializes the alts_shared_resource_dedicated object
- * shared by all TSI handshakes. The application is responsible for
- * invoking the API after calling grpc_init();
- */
+///
+/// This method initializes the alts_shared_resource_dedicated object
+/// shared by all TSI handshakes. The application is responsible for
+/// invoking the API after calling grpc_init();
+///
 void grpc_alts_shared_resource_dedicated_init();
 
-/**
- * This method populates various fields of the alts_shared_resource_dedicated
- * object shared by all TSI handshakes and start the dedicated thread.
- * The API will be invoked by the caller in a lazy manner. That is,
- * it will get invoked when ALTS TSI handshake occurs for the first time.
- */
+///
+/// This method populates various fields of the alts_shared_resource_dedicated
+/// object shared by all TSI handshakes and start the dedicated thread.
+/// The API will be invoked by the caller in a lazy manner. That is,
+/// it will get invoked when ALTS TSI handshake occurs for the first time.
+///
 void grpc_alts_shared_resource_dedicated_start(
     const char* handshaker_service_url);
 
-#endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H \
-        */
+#endif  // GRPC_SRC_CORE_TSI_ALTS_HANDSHAKER_ALTS_SHARED_RESOURCE_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+//
+//
+// Copyright 2018 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>
 
@@ -33,6 +33,7 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/thd_id.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/thd.h"
@@ -45,7 +46,7 @@
 #include "src/core/tsi/alts/handshaker/alts_tsi_utils.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.h"
 
-/* Main struct for ALTS TSI handshaker. */
+// Main struct for ALTS TSI handshaker.
 struct alts_tsi_handshaker {
   tsi_handshaker base;
   grpc_slice target_name;
@@ -71,7 +72,7 @@ struct alts_tsi_handshaker {
   size_t max_frame_size;
 };
 
-/* Main struct for ALTS TSI handshaker result. */
+// Main struct for ALTS TSI handshaker result.
 typedef struct alts_tsi_handshaker_result {
   tsi_handshaker_result base;
   char* peer_identity;
@@ -249,8 +250,8 @@ static void handshaker_result_destroy(tsi_handshaker_result* self) {
   gpr_free(result->peer_identity);
   gpr_free(result->key_data);
   gpr_free(result->unused_bytes);
-  grpc_slice_unref_internal(result->rpc_versions);
-  grpc_slice_unref_internal(result->serialized_context);
+  grpc_core::CSliceUnref(result->rpc_versions);
+  grpc_core::CSliceUnref(result->serialized_context);
   gpr_free(result);
 }
 
@@ -382,7 +383,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
   return TSI_OK;
 }
 
-/* gRPC provided callback used when gRPC thread model is applied. */
+// gRPC provided callback used when gRPC thread model is applied.
 static void on_handshaker_service_resp_recv(void* arg,
                                             grpc_error_handle error) {
   alts_handshaker_client* client = static_cast<alts_handshaker_client*>(arg);
@@ -391,32 +392,32 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (error != GRPC_ERROR_NONE) {
+  if (!error.ok()) {
     gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     success = false;
   }
   alts_handshaker_client_handle_response(client, success);
 }
 
-/* gRPC provided callback used when dedicatd CQ and thread are used.
- * It serves to safely bring the control back to application. */
+// gRPC provided callback used when dedicatd CQ and thread are used.
+// It serves to safely bring the control back to application.
 static void on_handshaker_service_resp_recv_dedicated(
     void* arg, grpc_error_handle /*error*/) {
   alts_shared_resource_dedicated* resource =
       grpc_alts_get_shared_resource_dedicated();
   grpc_cq_end_op(
-      resource->cq, arg, GRPC_ERROR_NONE,
+      resource->cq, arg, absl::OkStatus(),
       [](void* /*done_arg*/, grpc_cq_completion* /*storage*/) {}, nullptr,
       &resource->storage);
 }
 
-/* Returns TSI_OK if and only if no error is encountered. */
+// Returns TSI_OK if and only if no error is encountered.
 static tsi_result alts_tsi_handshaker_continue_handshaker_next(
     alts_tsi_handshaker* handshaker, const unsigned char* received_bytes,
     size_t received_bytes_size, tsi_handshaker_on_next_done_cb cb,
-    void* user_data) {
+    void* user_data, std::string* error) {
   if (!handshaker->has_created_handshaker_client) {
     if (handshaker->channel == nullptr) {
       grpc_alts_shared_resource_dedicated_start(
@@ -437,9 +438,10 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
         handshaker->interested_parties, handshaker->options,
         handshaker->target_name, grpc_cb, cb, user_data,
         handshaker->client_vtable_for_testing, handshaker->is_client,
-        handshaker->max_frame_size);
+        handshaker->max_frame_size, error);
     if (client == nullptr) {
       gpr_log(GPR_ERROR, "Failed to create ALTS handshaker client");
+      if (error != nullptr) *error = "Failed to create ALTS handshaker client";
       return TSI_FAILED_PRECONDITION;
     }
     {
@@ -448,6 +450,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       handshaker->client = client;
       if (handshaker->shutdown) {
         gpr_log(GPR_INFO, "TSI handshake shutdown");
+        if (error != nullptr) *error = "TSI handshaker shutdown";
         return TSI_HANDSHAKE_SHUTDOWN;
       }
     }
@@ -479,7 +482,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
   } else {
     ok = alts_handshaker_client_next(handshaker->client, &slice);
   }
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   return ok;
 }
 
@@ -490,6 +493,7 @@ struct alts_tsi_handshaker_continue_handshaker_next_args {
   tsi_handshaker_on_next_done_cb cb;
   void* user_data;
   grpc_closure closure;
+  std::string* error = nullptr;
 };
 
 static void alts_tsi_handshaker_create_channel(
@@ -510,7 +514,8 @@ static void alts_tsi_handshaker_create_channel(
   tsi_result continue_next_result =
       alts_tsi_handshaker_continue_handshaker_next(
           handshaker, next_args->received_bytes.get(),
-          next_args->received_bytes_size, next_args->cb, next_args->user_data);
+          next_args->received_bytes_size, next_args->cb, next_args->user_data,
+          next_args->error);
   if (continue_next_result != TSI_OK) {
     next_args->cb(continue_next_result, next_args->user_data, nullptr, 0,
                   nullptr);
@@ -522,9 +527,10 @@ static tsi_result handshaker_next(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** /*bytes_to_send*/,
     size_t* /*bytes_to_send_size*/, tsi_handshaker_result** /*result*/,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
+    tsi_handshaker_on_next_done_cb cb, void* user_data, std::string* error) {
   if (self == nullptr || cb == nullptr) {
     gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   alts_tsi_handshaker* handshaker =
@@ -533,6 +539,7 @@ static tsi_result handshaker_next(
     grpc_core::MutexLock lock(&handshaker->mu);
     if (handshaker->shutdown) {
       gpr_log(GPR_INFO, "TSI handshake shutdown");
+      if (error != nullptr) *error = "handshake shutdown";
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }
@@ -542,6 +549,7 @@ static tsi_result handshaker_next(
     args->handshaker = handshaker;
     args->received_bytes = nullptr;
     args->received_bytes_size = received_bytes_size;
+    args->error = error;
     if (received_bytes_size > 0) {
       args->received_bytes = std::unique_ptr<unsigned char>(
           static_cast<unsigned char*>(gpr_zalloc(received_bytes_size)));
@@ -556,10 +564,10 @@ static tsi_result handshaker_next(
     // stack. Doing so avoids potential lock cycles between g_init_mu and other
     // mutexes within core that might be held on the current call stack
     // (note that g_init_mu gets acquired during channel creation).
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, absl::OkStatus());
   } else {
     tsi_result ok = alts_tsi_handshaker_continue_handshaker_next(
-        handshaker, received_bytes, received_bytes_size, cb, user_data);
+        handshaker, received_bytes, received_bytes_size, cb, user_data, error);
     if (ok != TSI_OK) {
       gpr_log(GPR_ERROR, "Failed to schedule ALTS handshaker requests");
       return ok;
@@ -568,20 +576,20 @@ static tsi_result handshaker_next(
   return TSI_ASYNC;
 }
 
-/*
- * This API will be invoked by a non-gRPC application, and an ExecCtx needs
- * to be explicitly created in order to invoke ALTS handshaker client API's
- * that assumes the caller is inside gRPC core.
- */
+//
+// This API will be invoked by a non-gRPC application, and an ExecCtx needs
+// to be explicitly created in order to invoke ALTS handshaker client API's
+// that assumes the caller is inside gRPC core.
+//
 static tsi_result handshaker_next_dedicated(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** bytes_to_send,
     size_t* bytes_to_send_size, tsi_handshaker_result** result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
+    tsi_handshaker_on_next_done_cb cb, void* user_data, std::string* error) {
   grpc_core::ExecCtx exec_ctx;
   return handshaker_next(self, received_bytes, received_bytes_size,
                          bytes_to_send, bytes_to_send_size, result, cb,
-                         user_data);
+                         user_data, error);
 }
 
 static void handshaker_shutdown(tsi_handshaker* self) {
@@ -605,7 +613,7 @@ static void handshaker_destroy(tsi_handshaker* self) {
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
   alts_handshaker_client_destroy(handshaker->client);
-  grpc_slice_unref_internal(handshaker->target_name);
+  grpc_core::CSliceUnref(handshaker->target_name);
   grpc_alts_credentials_options_destroy(handshaker->options);
   if (handshaker->channel != nullptr) {
     grpc_channel_destroy_internal(handshaker->channel);