grpc 1.50.0 → 1.52.0.pre2

data/src/core/tsi/alts/handshaker/alts_handshaker_client.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>
 
@@ -28,6 +28,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -53,59 +54,59 @@ struct recv_message_result {
 
 typedef struct alts_grpc_handshaker_client {
   alts_handshaker_client base;
-  /* One ref is held by the entity that created this handshaker_client, and
-   * another ref is held by the pending RECEIVE_STATUS_ON_CLIENT op. */
+  // One ref is held by the entity that created this handshaker_client, and
+  // another ref is held by the pending RECEIVE_STATUS_ON_CLIENT op.
   gpr_refcount refs;
   alts_tsi_handshaker* handshaker;
   grpc_call* call;
-  /* A pointer to a function handling the interaction with handshaker service.
-   * That is, it points to grpc_call_start_batch_and_execute when the handshaker
-   * client is used in a non-testing use case and points to a custom function
-   * that validates the data to be sent to handshaker service in a testing use
-   * case. */
+  // A pointer to a function handling the interaction with handshaker service.
+  // That is, it points to grpc_call_start_batch_and_execute when the handshaker
+  // client is used in a non-testing use case and points to a custom function
+  // that validates the data to be sent to handshaker service in a testing use
+  // case.
   alts_grpc_caller grpc_caller;
-  /* A gRPC closure to be scheduled when the response from handshaker service
-   * is received. It will be initialized with the injected grpc RPC callback. */
+  // A gRPC closure to be scheduled when the response from handshaker service
+  // is received. It will be initialized with the injected grpc RPC callback.
   grpc_closure on_handshaker_service_resp_recv;
-  /* Buffers containing information to be sent (or received) to (or from) the
-   * handshaker service. */
+  // Buffers containing information to be sent (or received) to (or from) the
+  // handshaker service.
   grpc_byte_buffer* send_buffer = nullptr;
   grpc_byte_buffer* recv_buffer = nullptr;
   // Used to inject a read failure from tests.
   bool inject_read_failure = false;
-  /* Initial metadata to be received from handshaker service. */
+  // 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
-   * is received from handshaker service. */
+  // A callback function provided by an application to be invoked when response
+  // is received from handshaker service.
   tsi_handshaker_on_next_done_cb cb;
   void* user_data;
-  /* ALTS credential options passed in from the caller. */
+  // ALTS credential options passed in from the caller.
   grpc_alts_credentials_options* options;
-  /* target name information to be passed to handshaker service for server
-   * authorization check. */
+  // target name information to be passed to handshaker service for server
+  // authorization check.
   grpc_slice target_name;
-  /* boolean flag indicating if the handshaker client is used at client
-   * (is_client = true) or server (is_client = false) side. */
+  // boolean flag indicating if the handshaker client is used at client
+  // (is_client = true) or server (is_client = false) side.
   bool is_client;
-  /* a temporary store for data received from handshaker service used to extract
-   * unused data. */
+  // a temporary store for data received from handshaker service used to extract
+  // unused data.
   grpc_slice recv_bytes;
-  /* a buffer containing data to be sent to the grpc client or server's peer. */
+  // a buffer containing data to be sent to the grpc client or server's peer.
   unsigned char* buffer;
   size_t buffer_size;
-  /** callback for receiving handshake call status */
+  /// callback for receiving handshake call status
   grpc_closure on_status_received;
-  /** gRPC status code of handshake call */
+  /// gRPC status code of handshake call
   grpc_status_code handshake_status_code = GRPC_STATUS_OK;
-  /** gRPC status details of handshake call */
+  /// gRPC status details of handshake call
   grpc_slice handshake_status_details;
-  /* mu synchronizes all fields below including their internal fields. */
+  // mu synchronizes all fields below including their internal fields.
   grpc_core::Mutex mu;
-  /* indicates if the handshaker call's RECV_STATUS_ON_CLIENT op is done. */
+  // indicates if the handshaker call's RECV_STATUS_ON_CLIENT op is done.
   bool receive_status_finished = false;
-  /* if non-null, contains arguments to complete a TSI next callback. */
+  // if non-null, contains arguments to complete a TSI next callback.
   recv_message_result* pending_recv_message_result = nullptr;
-  /* Maximum frame size used by frame protector. */
+  // 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;
@@ -135,11 +136,11 @@ static void alts_grpc_handshaker_client_unref(
     client->send_buffer = nullptr;
     client->recv_buffer = nullptr;
     grpc_metadata_array_destroy(&client->recv_initial_metadata);
-    grpc_slice_unref_internal(client->recv_bytes);
-    grpc_slice_unref_internal(client->target_name);
+    grpc_core::CSliceUnref(client->recv_bytes);
+    grpc_core::CSliceUnref(client->target_name);
     grpc_alts_credentials_options_destroy(client->options);
     gpr_free(client->buffer);
-    grpc_slice_unref_internal(client->handshake_status_details);
+    grpc_core::CSliceUnref(client->handshake_status_details);
     delete client;
   }
 }
@@ -198,7 +199,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   grpc_byte_buffer* recv_buffer = client->recv_buffer;
   alts_tsi_handshaker* handshaker = client->handshaker;
-  /* Invalid input check. */
+  // Invalid input check.
   if (client->cb == nullptr) {
     gpr_log(GPR_ERROR,
             "client->cb is nullptr in alts_tsi_handshaker_handle_response()");
@@ -213,14 +214,14 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
         nullptr, 0, nullptr);
     return;
   }
-  /* TSI handshake has been shutdown. */
+  // 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,
                          "TSI handshake shutdown", nullptr, 0, nullptr);
     return;
   }
-  /* Check for failed grpc read. */
+  // 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,
@@ -242,7 +243,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
       alts_tsi_utils_deserialize_response(recv_buffer, arena.ptr());
   grpc_byte_buffer_destroy(client->recv_buffer);
   client->recv_buffer = nullptr;
-  /* Invalid handshaker response check. */
+  // Invalid handshaker response check.
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "alts_tsi_utils_deserialize_response() failed");
     handle_response_done(client, TSI_DATA_CORRUPTED,
@@ -406,14 +407,14 @@ class HandshakeQueue {
 };
 
 gpr_once g_queued_handshakes_init = GPR_ONCE_INIT;
-/* Using separate queues for client and server handshakes is a
- * hack that's mainly intended to satisfy the alts_concurrent_connectivity_test,
- * which runs many concurrent handshakes where both endpoints
- * are in the same process; this situation is problematic with a
- * single queue because we have a high chance of using up all outstanding
- * slots in the queue, such that there aren't any
- * mutual client/server handshakes outstanding at the same time and
- * able to make progress. */
+// Using separate queues for client and server handshakes is a
+// hack that's mainly intended to satisfy the alts_concurrent_connectivity_test,
+// which runs many concurrent handshakes where both endpoints
+// are in the same process; this situation is problematic with a
+// single queue because we have a high chance of using up all outstanding
+// slots in the queue, such that there aren't any
+// mutual client/server handshakes outstanding at the same time and
+// able to make progress.
 HandshakeQueue* g_client_handshake_queue;
 HandshakeQueue* g_server_handshake_queue;
 
@@ -440,10 +441,10 @@ void HandshakeDone(bool is_client) {
 
 };  // namespace
 
-/**
- * Populate grpc operation data with the fields of ALTS handshaker client and
- * make a grpc call.
- */
+///
+/// Populate grpc operation data with the fields of ALTS handshaker client and
+/// make a grpc call.
+///
 static tsi_result make_grpc_call(alts_handshaker_client* c, bool is_start) {
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
@@ -468,7 +469,7 @@ static void on_status_received(void* arg, grpc_error_handle error) {
             "alts_grpc_handshaker_client:%p on_status_received "
             "status:%d details:|%s| error:|%s|",
             client, client->handshake_status_code, status_details,
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     gpr_free(status_details);
   }
   maybe_complete_tsi_next(client, true /* receive_status_finished */,
@@ -477,8 +478,8 @@ static void on_status_received(void* arg, grpc_error_handle error) {
   alts_grpc_handshaker_client_unref(client);
 }
 
-/* Serializes a grpc_gcp_HandshakerReq message into a buffer and returns newly
- * grpc_byte_buffer holding it. */
+// Serializes a grpc_gcp_HandshakerReq message into a buffer and returns newly
+// grpc_byte_buffer holding it.
 static grpc_byte_buffer* get_serialized_handshaker_req(
     grpc_gcp_HandshakerReq* req, upb_Arena* arena) {
   size_t buf_length;
@@ -488,11 +489,11 @@ static grpc_byte_buffer* get_serialized_handshaker_req(
   }
   grpc_slice slice = grpc_slice_from_copied_buffer(buf, buf_length);
   grpc_byte_buffer* byte_buffer = grpc_raw_byte_buffer_create(&slice, 1);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   return byte_buffer;
 }
 
-/* Create and populate a client_start handshaker request, then serialize it. */
+// Create and populate a client_start handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_start_client(
     alts_handshaker_client* c) {
   GPR_ASSERT(c != nullptr);
@@ -557,7 +558,7 @@ static tsi_result handshaker_client_start_client(alts_handshaker_client* c) {
   return result;
 }
 
-/* Create and populate a start_server handshaker request, then serialize it. */
+// Create and populate a start_server handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_start_server(
     alts_handshaker_client* c, grpc_slice* bytes_received) {
   GPR_ASSERT(c != nullptr);
@@ -616,7 +617,7 @@ static tsi_result handshaker_client_start_server(alts_handshaker_client* c,
   return result;
 }
 
-/* Create and populate a next handshaker request, then serialize it. */
+// Create and populate a next handshaker request, then serialize it.
 static grpc_byte_buffer* get_serialized_next(grpc_slice* bytes_received) {
   GPR_ASSERT(bytes_received != nullptr);
   upb::Arena arena;
@@ -639,8 +640,8 @@ static tsi_result handshaker_client_next(alts_handshaker_client* c,
   }
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
-  grpc_slice_unref_internal(client->recv_bytes);
-  client->recv_bytes = grpc_slice_ref_internal(*bytes_received);
+  grpc_core::CSliceUnref(client->recv_bytes);
+  client->recv_bytes = grpc_core::CSliceRef(*bytes_received);
   grpc_byte_buffer* buffer = get_serialized_next(bytes_received);
   if (buffer == nullptr) {
     gpr_log(GPR_ERROR, "get_serialized_next() failed");
@@ -692,7 +693,7 @@ static void handshaker_client_destruct(alts_handshaker_client* c) {
           DEBUG_LOCATION,
           GRPC_CLOSURE_CREATE(handshaker_call_unref, client->call,
                               grpc_schedule_on_exec_ctx),
-          GRPC_ERROR_NONE);
+          absl::OkStatus());
     }
   }
 }
@@ -741,7 +742,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
                 grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
                 grpc_core::Timestamp::InfFuture(), nullptr);
-  grpc_slice_unref_internal(slice);
+  grpc_core::CSliceUnref(slice);
   GRPC_CLOSURE_INIT(&client->on_handshaker_service_resp_recv, grpc_cb, client,
                     grpc_schedule_on_exec_ctx);
   GRPC_CLOSURE_INIT(&client->on_status_received, on_status_received, client,
@@ -789,7 +790,7 @@ void alts_handshaker_client_set_recv_bytes_for_testing(
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
-  client->recv_bytes = grpc_slice_ref_internal(*recv_bytes);
+  client->recv_bytes = CSliceRef(*recv_bytes);
 }
 
 void alts_handshaker_client_set_fields_for_testing(

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

@@ -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.
+//
+//
 
 #ifndef GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_H
 #define GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_HANDSHAKER_CLIENT_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,83 +61,83 @@ 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,
@@ -146,15 +146,15 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
     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.
- */
+///
+/// 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_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;