grpc 1.43.1 → 1.46.2

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -0,0 +1,85 @@
+//
+// Copyright 2021 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>
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/builtins.h"
+
+#ifndef GRPC_NO_XDS
+namespace grpc_core {
+void XdsClientGlobalInit();
+void XdsClientGlobalShutdown();
+}  // namespace grpc_core
+void grpc_certificate_provider_registry_init(void);
+void grpc_certificate_provider_registry_shutdown(void);
+namespace grpc_core {
+void FileWatcherCertificateProviderInit();
+void FileWatcherCertificateProviderShutdown();
+}  // namespace grpc_core
+void grpc_lb_policy_cds_init(void);
+void grpc_lb_policy_cds_shutdown(void);
+void grpc_lb_policy_xds_cluster_impl_init(void);
+void grpc_lb_policy_xds_cluster_impl_shutdown(void);
+void grpc_lb_policy_xds_cluster_resolver_init(void);
+void grpc_lb_policy_xds_cluster_resolver_shutdown(void);
+void grpc_lb_policy_xds_cluster_manager_init(void);
+void grpc_lb_policy_xds_cluster_manager_shutdown(void);
+#endif
+
+void grpc_register_extra_plugins() {
+#ifndef GRPC_NO_XDS
+  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
+                       grpc_core::XdsClientGlobalShutdown);
+  grpc_register_plugin(grpc_certificate_provider_registry_init,
+                       grpc_certificate_provider_registry_shutdown);
+  grpc_register_plugin(grpc_core::FileWatcherCertificateProviderInit,
+                       grpc_core::FileWatcherCertificateProviderShutdown);
+  grpc_register_plugin(grpc_lb_policy_cds_init, grpc_lb_policy_cds_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_impl_init,
+                       grpc_lb_policy_xds_cluster_impl_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_resolver_init,
+                       grpc_lb_policy_xds_cluster_resolver_shutdown);
+  grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
+                       grpc_lb_policy_xds_cluster_manager_shutdown);
+#endif
+}
+
+namespace grpc_core {
+#ifndef GRPC_NO_XDS
+extern void RbacFilterRegister(CoreConfiguration::Builder* builder);
+extern void RegisterXdsChannelStackModifier(
+    CoreConfiguration::Builder* builder);
+extern void RegisterChannelDefaultCreds(CoreConfiguration::Builder* builder);
+extern void RegisterXdsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterCloud2ProdResolver(CoreConfiguration::Builder* builder);
+#endif
+void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
+  // Use builder to avoid unused-parameter warning.
+  (void)builder;
+#ifndef GRPC_NO_XDS
+  // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the
+  // re2 library by default
+  RbacFilterRegister(builder);
+  RegisterXdsChannelStackModifier(builder);
+  RegisterChannelDefaultCreds(builder);
+  RegisterXdsResolver(builder);
+  RegisterCloud2ProdResolver(builder);
+#endif
+}
+}  // namespace grpc_core

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

@@ -209,13 +209,13 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   }
   /* TSI handshake has been shutdown. */
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
-    gpr_log(GPR_ERROR, "TSI handshake shutdown");
+    gpr_log(GPR_INFO, "TSI handshake shutdown");
     handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN, nullptr, 0, nullptr);
     return;
   }
   /* Failed grpc call check. */
   if (!is_ok || status != GRPC_STATUS_OK) {
-    gpr_log(GPR_ERROR, "grpc call made to handshaker service failed");
+    gpr_log(GPR_INFO, "grpc call made to handshaker service failed");
     handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
     return;
   }
@@ -243,7 +243,7 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
     return;
   }
-  upb_strview out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
+  upb_StringView out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
   unsigned char* bytes_to_send = nullptr;
   size_t bytes_to_send_size = 0;
   if (out_frames.size > 0) {
@@ -272,7 +272,7 @@ 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));
   if (code != GRPC_STATUS_OK) {
-    upb_strview details = grpc_gcp_HandshakerStatus_details(resp_status);
+    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);
@@ -462,7 +462,7 @@ static void on_status_received(void* arg, grpc_error_handle error) {
 /* 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) {
+    grpc_gcp_HandshakerReq* req, upb_Arena* arena) {
   size_t buf_length;
   char* buf = grpc_gcp_HandshakerReq_serialize(req, arena, &buf_length);
   if (buf == nullptr) {
@@ -487,19 +487,21 @@ static grpc_byte_buffer* get_serialized_start_client(
   grpc_gcp_StartClientHandshakeReq_set_handshake_security_protocol(
       start_client, grpc_gcp_ALTS);
   grpc_gcp_StartClientHandshakeReq_add_application_protocols(
-      start_client, upb_strview_makez(ALTS_APPLICATION_PROTOCOL), arena.ptr());
+      start_client, upb_StringView_FromString(ALTS_APPLICATION_PROTOCOL),
+      arena.ptr());
   grpc_gcp_StartClientHandshakeReq_add_record_protocols(
-      start_client, upb_strview_makez(ALTS_RECORD_PROTOCOL), arena.ptr());
+      start_client, upb_StringView_FromString(ALTS_RECORD_PROTOCOL),
+      arena.ptr());
   grpc_gcp_RpcProtocolVersions* client_version =
       grpc_gcp_StartClientHandshakeReq_mutable_rpc_versions(start_client,
                                                             arena.ptr());
   grpc_gcp_RpcProtocolVersions_assign_from_struct(
       client_version, arena.ptr(), &client->options->rpc_versions);
   grpc_gcp_StartClientHandshakeReq_set_target_name(
-      start_client,
-      upb_strview_make(reinterpret_cast<const char*>(
-                           GRPC_SLICE_START_PTR(client->target_name)),
-                       GRPC_SLICE_LENGTH(client->target_name)));
+      start_client, upb_StringView_FromDataAndSize(
+                        reinterpret_cast<const char*>(
+                            GRPC_SLICE_START_PTR(client->target_name)),
+                        GRPC_SLICE_LENGTH(client->target_name)));
   target_service_account* ptr =
       (reinterpret_cast<grpc_alts_credentials_client_options*>(client->options))
           ->target_account_list_head;
@@ -508,7 +510,7 @@ static grpc_byte_buffer* get_serialized_start_client(
         grpc_gcp_StartClientHandshakeReq_add_target_identities(start_client,
                                                                arena.ptr());
     grpc_gcp_Identity_set_service_account(target_identity,
-                                          upb_strview_makez(ptr->data));
+                                          upb_StringView_FromString(ptr->data));
     ptr = ptr->next;
   }
   grpc_gcp_StartClientHandshakeReq_set_max_frame_size(
@@ -551,17 +553,19 @@ static grpc_byte_buffer* get_serialized_start_server(
   grpc_gcp_StartServerHandshakeReq* start_server =
       grpc_gcp_HandshakerReq_mutable_server_start(req, arena.ptr());
   grpc_gcp_StartServerHandshakeReq_add_application_protocols(
-      start_server, upb_strview_makez(ALTS_APPLICATION_PROTOCOL), arena.ptr());
+      start_server, upb_StringView_FromString(ALTS_APPLICATION_PROTOCOL),
+      arena.ptr());
   grpc_gcp_ServerHandshakeParameters* value =
       grpc_gcp_ServerHandshakeParameters_new(arena.ptr());
   grpc_gcp_ServerHandshakeParameters_add_record_protocols(
-      value, upb_strview_makez(ALTS_RECORD_PROTOCOL), arena.ptr());
+      value, upb_StringView_FromString(ALTS_RECORD_PROTOCOL), arena.ptr());
   grpc_gcp_StartServerHandshakeReq_handshake_parameters_set(
       start_server, grpc_gcp_ALTS, value, arena.ptr());
   grpc_gcp_StartServerHandshakeReq_set_in_bytes(
-      start_server, upb_strview_make(reinterpret_cast<const char*>(
-                                         GRPC_SLICE_START_PTR(*bytes_received)),
-                                     GRPC_SLICE_LENGTH(*bytes_received)));
+      start_server,
+      upb_StringView_FromDataAndSize(
+          reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(*bytes_received)),
+          GRPC_SLICE_LENGTH(*bytes_received)));
   grpc_gcp_RpcProtocolVersions* server_version =
       grpc_gcp_StartServerHandshakeReq_mutable_rpc_versions(start_server,
                                                             arena.ptr());
@@ -602,9 +606,10 @@ static grpc_byte_buffer* get_serialized_next(grpc_slice* bytes_received) {
   grpc_gcp_NextHandshakeMessageReq* next =
       grpc_gcp_HandshakerReq_mutable_next(req, arena.ptr());
   grpc_gcp_NextHandshakeMessageReq_set_in_bytes(
-      next, upb_strview_make(reinterpret_cast<const char*> GRPC_SLICE_START_PTR(
-                                 *bytes_received),
-                             GRPC_SLICE_LENGTH(*bytes_received)));
+      next,
+      upb_StringView_FromDataAndSize(
+          reinterpret_cast<const char*> GRPC_SLICE_START_PTR(*bytes_received),
+          GRPC_SLICE_LENGTH(*bytes_received)));
   return get_serialized_handshaker_req(req, arena.ptr());
 }
 
@@ -716,12 +721,12 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
           : grpc_channel_create_pollset_set_call(
                 channel, nullptr, GRPC_PROPAGATE_DEFAULTS, interested_parties,
                 grpc_slice_from_static_string(ALTS_SERVICE_METHOD), &slice,
-                GRPC_MILLIS_INF_FUTURE, nullptr);
+                grpc_core::Timestamp::InfFuture(), nullptr);
+  grpc_slice_unref_internal(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,
                     grpc_schedule_on_exec_ctx);
-  grpc_slice_unref_internal(slice);
   return &client->base;
 }
 

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

@@ -22,6 +22,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 
 static alts_shared_resource_dedicated g_alts_resource_dedicated;
@@ -55,8 +56,15 @@ void grpc_alts_shared_resource_dedicated_start(
     const char* handshaker_service_url) {
   gpr_mu_lock(&g_alts_resource_dedicated.mu);
   if (g_alts_resource_dedicated.cq == nullptr) {
+    grpc_channel_credentials* creds = grpc_insecure_credentials_create();
+    // Disable retries so that we quickly get a signal when the
+    // handshake server is not reachable.
+    grpc_arg disable_retries_arg = grpc_channel_arg_integer_create(
+        const_cast<char*>(GRPC_ARG_ENABLE_RETRIES), 0);
+    grpc_channel_args args = {1, &disable_retries_arg};
     g_alts_resource_dedicated.channel =
-        grpc_insecure_channel_create(handshaker_service_url, nullptr, nullptr);
+        grpc_channel_create(handshaker_service_url, creds, &args);
+    grpc_channel_credentials_release(creds);
     g_alts_resource_dedicated.cq =
         grpc_completion_queue_create_for_next(nullptr);
     g_alts_resource_dedicated.thread =

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

@@ -26,6 +26,7 @@
 
 #include "upb/upb.hpp"
 
+#include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -276,13 +277,13 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Invalid identity");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview peer_service_account =
+  upb_StringView peer_service_account =
       grpc_gcp_Identity_service_account(identity);
   if (peer_service_account.size == 0) {
     gpr_log(GPR_ERROR, "Invalid peer service account");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview key_data = grpc_gcp_HandshakerResult_key_data(hresult);
+  upb_StringView key_data = grpc_gcp_HandshakerResult_key_data(hresult);
   if (key_data.size < kAltsAes128GcmRekeyKeyLength) {
     gpr_log(GPR_ERROR, "Bad key length");
     return TSI_FAILED_PRECONDITION;
@@ -293,13 +294,13 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Peer does not set RPC protocol versions.");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview application_protocol =
+  upb_StringView application_protocol =
       grpc_gcp_HandshakerResult_application_protocol(hresult);
   if (application_protocol.size == 0) {
     gpr_log(GPR_ERROR, "Invalid application protocol");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview record_protocol =
+  upb_StringView record_protocol =
       grpc_gcp_HandshakerResult_record_protocol(hresult);
   if (record_protocol.size == 0) {
     gpr_log(GPR_ERROR, "Invalid record protocol");
@@ -311,7 +312,7 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     gpr_log(GPR_ERROR, "Invalid local identity");
     return TSI_FAILED_PRECONDITION;
   }
-  upb_strview local_service_account =
+  upb_StringView local_service_account =
       grpc_gcp_Identity_service_account(local_identity);
   // We don't check if local service account is empty here
   // because local identity could be empty in certain situations.
@@ -350,14 +351,14 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
     return TSI_FAILED_PRECONDITION;
   }
   if (grpc_gcp_Identity_has_attributes(identity)) {
-    size_t iter = UPB_MAP_BEGIN;
+    size_t iter = kUpb_Map_Begin;
     grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
         grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
     while (peer_attributes_entry != nullptr) {
-      upb_strview key = grpc_gcp_Identity_AttributesEntry_key(
+      upb_StringView key = grpc_gcp_Identity_AttributesEntry_key(
           const_cast<grpc_gcp_Identity_AttributesEntry*>(
               peer_attributes_entry));
-      upb_strview val = grpc_gcp_Identity_AttributesEntry_value(
+      upb_StringView val = grpc_gcp_Identity_AttributesEntry_value(
           const_cast<grpc_gcp_Identity_AttributesEntry*>(
               peer_attributes_entry));
       grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
@@ -391,7 +392,7 @@ static void on_handshaker_service_resp_recv(void* arg,
   }
   bool success = true;
   if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR,
+    gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
             grpc_error_std_string(error).c_str());
     success = false;
@@ -446,7 +447,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       GPR_ASSERT(handshaker->client == nullptr);
       handshaker->client = client;
       if (handshaker->shutdown) {
-        gpr_log(GPR_ERROR, "TSI handshake shutdown");
+        gpr_log(GPR_INFO, "TSI handshake shutdown");
         return TSI_HANDSHAKE_SHUTDOWN;
       }
     }
@@ -497,8 +498,15 @@ static void alts_tsi_handshaker_create_channel(
       static_cast<alts_tsi_handshaker_continue_handshaker_next_args*>(arg);
   alts_tsi_handshaker* handshaker = next_args->handshaker;
   GPR_ASSERT(handshaker->channel == nullptr);
-  handshaker->channel = grpc_insecure_channel_create(
-      next_args->handshaker->handshaker_service_url, nullptr, nullptr);
+  grpc_channel_credentials* creds = grpc_insecure_credentials_create();
+  // Disable retries so that we quickly get a signal when the
+  // handshake server is not reachable.
+  grpc_arg disable_retries_arg = grpc_channel_arg_integer_create(
+      const_cast<char*>(GRPC_ARG_ENABLE_RETRIES), 0);
+  grpc_channel_args args = {1, &disable_retries_arg};
+  handshaker->channel = grpc_channel_create(
+      next_args->handshaker->handshaker_service_url, creds, &args);
+  grpc_channel_credentials_release(creds);
   tsi_result continue_next_result =
       alts_tsi_handshaker_continue_handshaker_next(
           handshaker, next_args->received_bytes.get(),
@@ -524,7 +532,7 @@ static tsi_result handshaker_next(
   {
     grpc_core::MutexLock lock(&handshaker->mu);
     if (handshaker->shutdown) {
-      gpr_log(GPR_ERROR, "TSI handshake shutdown");
+      gpr_log(GPR_INFO, "TSI handshake shutdown");
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }

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

@@ -42,14 +42,14 @@ tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code) {
 }
 
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
-    grpc_byte_buffer* resp_buffer, upb_arena* arena) {
+    grpc_byte_buffer* resp_buffer, upb_Arena* arena) {
   GPR_ASSERT(resp_buffer != nullptr);
   GPR_ASSERT(arena != nullptr);
   grpc_byte_buffer_reader bbr;
   grpc_byte_buffer_reader_init(&bbr, resp_buffer);
   grpc_slice slice = grpc_byte_buffer_reader_readall(&bbr);
   size_t buf_size = GPR_SLICE_LENGTH(slice);
-  void* buf = upb_arena_malloc(arena, buf_size);
+  void* buf = upb_Arena_Malloc(arena, buf_size);
   memcpy(buf, reinterpret_cast<const char*>(GPR_SLICE_START_PTR(slice)),
          buf_size);
   grpc_gcp_HandshakerResp* resp = grpc_gcp_HandshakerResp_parse(

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

@@ -48,6 +48,6 @@ tsi_result alts_tsi_utils_convert_to_tsi_result(grpc_status_code code);
  * failure.
  */
 grpc_gcp_HandshakerResp* alts_tsi_utils_deserialize_response(
-    grpc_byte_buffer* resp_buffer, upb_arena* arena);
+    grpc_byte_buffer* resp_buffer, upb_Arena* arena);
 
 #endif /* GRPC_CORE_TSI_ALTS_HANDSHAKER_ALTS_TSI_UTILS_H */

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

@@ -68,7 +68,7 @@ bool grpc_gcp_rpc_protocol_versions_encode(
 }
 
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice) {
   if (versions == nullptr || arena == nullptr || slice == nullptr) {
     gpr_log(GPR_ERROR,
@@ -135,7 +135,7 @@ void grpc_gcp_rpc_protocol_versions_assign_from_upb(
 }
 
 void grpc_gcp_RpcProtocolVersions_assign_from_struct(
-    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     const grpc_gcp_rpc_protocol_versions* value) {
   grpc_gcp_RpcProtocolVersions_Version* max_version_msg =
       grpc_gcp_RpcProtocolVersions_mutable_max_rpc_version(versions, arena);

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

@@ -91,7 +91,7 @@ bool grpc_gcp_rpc_protocol_versions_encode(
  * The method returns true on success and false otherwise.
  */
 bool grpc_gcp_rpc_protocol_versions_encode(
-    const grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    const grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     grpc_slice* slice);
 
 /**
@@ -119,7 +119,7 @@ void grpc_gcp_rpc_protocol_versions_assign_from_upb(
  * RpcProtocolVersions.
  */
 void grpc_gcp_RpcProtocolVersions_assign_from_struct(
-    grpc_gcp_RpcProtocolVersions* versions, upb_arena* arena,
+    grpc_gcp_RpcProtocolVersions* versions, upb_Arena* arena,
     const grpc_gcp_rpc_protocol_versions* value);
 
 /**

data/src/core/tsi/local_transport_security.cc

@@ -41,7 +41,6 @@ typedef struct local_zero_copy_grpc_protector {
 /* Main struct for local TSI handshaker result. */
 typedef struct local_tsi_handshaker_result {
   tsi_handshaker_result base;
-  bool is_client;
   unsigned char* unused_bytes;
   size_t unused_bytes_size;
 } local_tsi_handshaker_result;
@@ -49,7 +48,6 @@ typedef struct local_tsi_handshaker_result {
 /* Main struct for local TSI handshaker. */
 typedef struct local_tsi_handshaker {
   tsi_handshaker base;
-  bool is_client;
 } local_tsi_handshaker;
 
 /* --- tsi_handshaker_result methods implementation. --- */
@@ -99,8 +97,7 @@ const tsi_handshaker_result_vtable result_vtable = {
     handshaker_result_get_unused_bytes,
     handshaker_result_destroy};
 
-tsi_result create_handshaker_result(bool is_client,
-                                    const unsigned char* received_bytes,
+tsi_result create_handshaker_result(const unsigned char* received_bytes,
                                     size_t received_bytes_size,
                                     tsi_handshaker_result** self) {
   if (self == nullptr) {
@@ -109,7 +106,6 @@ tsi_result create_handshaker_result(bool is_client,
   }
   local_tsi_handshaker_result* result =
       grpc_core::Zalloc<local_tsi_handshaker_result>();
-  result->is_client = is_client;
   if (received_bytes_size > 0) {
     result->unused_bytes =
         static_cast<unsigned char*>(gpr_malloc(received_bytes_size));
@@ -135,11 +131,8 @@ tsi_result handshaker_next(
   /* Note that there is no interaction between TSI peers, and all operations are
    * local.
    */
-  local_tsi_handshaker* handshaker =
-      reinterpret_cast<local_tsi_handshaker*>(self);
   *bytes_to_send_size = 0;
-  create_handshaker_result(handshaker->is_client, received_bytes,
-                           received_bytes_size, result);
+  create_handshaker_result(received_bytes, received_bytes_size, result);
   return TSI_OK;
 }
 
@@ -165,13 +158,12 @@ const tsi_handshaker_vtable handshaker_vtable = {
 
 }  // namespace
 
-tsi_result tsi_local_handshaker_create(bool is_client, tsi_handshaker** self) {
+tsi_result tsi_local_handshaker_create(tsi_handshaker** self) {
   if (self == nullptr) {
     gpr_log(GPR_ERROR, "Invalid arguments to local_tsi_handshaker_create()");
     return TSI_INVALID_ARGUMENT;
   }
   local_tsi_handshaker* handshaker = grpc_core::Zalloc<local_tsi_handshaker>();
-  handshaker->is_client = is_client;
   handshaker->base.vtable = &handshaker_vtable;
   *self = &handshaker->base;
   return TSI_OK;

data/src/core/tsi/local_transport_security.h

@@ -32,9 +32,6 @@
 /**
  * This method creates a local TSI handshaker instance.
  *
- * - is_client: boolean value indicating if the handshaker is used at the client
- *   (is_client = true) or server (is_client = false) side. The parameter is
- *   added for future extension.
  * - self: address of local TSI handshaker instance to be returned from the
  *   method.
  *
@@ -45,6 +42,6 @@
  * does not fit with an insecure connector, we would need to add a separate
  * handshaker for insecure connectors.
  */
-tsi_result tsi_local_handshaker_create(bool is_client, tsi_handshaker** self);
+tsi_result tsi_local_handshaker_create(tsi_handshaker** self);
 
 #endif /* GRPC_CORE_TSI_LOCAL_TRANSPORT_SECURITY_H */

data/src/core/tsi/ssl/key_logging/ssl_key_logging.cc

@@ -0,0 +1,141 @@
+// Copyright 2021 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>
+
+#include "src/core/tsi/ssl/key_logging/ssl_key_logging.h"
+
+#include <map>
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/slice/slice_internal.h"
+
+using TlsSessionKeyLogger = tsi::TlsSessionKeyLoggerCache::TlsSessionKeyLogger;
+
+namespace tsi {
+
+namespace {
+
+gpr_once g_cache_mutex_init = GPR_ONCE_INIT;
+grpc_core::Mutex* g_tls_session_key_log_cache_mu = nullptr;
+// A pointer to a global singleton instance.
+TlsSessionKeyLoggerCache* g_cache_instance
+    ABSL_GUARDED_BY(g_tls_session_key_log_cache_mu) = nullptr;
+
+void do_cache_mutex_init(void) {
+  g_tls_session_key_log_cache_mu = new grpc_core::Mutex();
+}
+
+}  // namespace
+
+TlsSessionKeyLoggerCache::TlsSessionKeyLogger::TlsSessionKeyLogger(
+    std::string tls_session_key_log_file_path,
+    grpc_core::RefCountedPtr<TlsSessionKeyLoggerCache> cache)
+    : tls_session_key_log_file_path_(std::move(tls_session_key_log_file_path)),
+      cache_(std::move(cache)) {
+  GPR_ASSERT(!tls_session_key_log_file_path_.empty());
+  GPR_ASSERT(cache_ != nullptr);
+  fd_ = fopen(tls_session_key_log_file_path_.c_str(), "w+");
+  if (fd_ == nullptr) {
+    grpc_error_handle error = GRPC_OS_ERROR(errno, "fopen");
+    gpr_log(GPR_ERROR,
+            "Ignoring TLS Key logging. ERROR Opening TLS Keylog "
+            "file: %s",
+            grpc_error_std_string(error).c_str());
+  }
+  cache_->tls_session_key_logger_map_.emplace(tls_session_key_log_file_path_,
+                                              this);
+};
+
+TlsSessionKeyLoggerCache::TlsSessionKeyLogger::~TlsSessionKeyLogger() {
+  {
+    grpc_core::MutexLock lock(&lock_);
+    if (fd_ != nullptr) fclose(fd_);
+  }
+  {
+    grpc_core::MutexLock lock(g_tls_session_key_log_cache_mu);
+    auto it = cache_->tls_session_key_logger_map_.find(
+        tls_session_key_log_file_path_);
+    if (it != cache_->tls_session_key_logger_map_.end() && it->second == this) {
+      cache_->tls_session_key_logger_map_.erase(it);
+    }
+  }
+}
+
+void TlsSessionKeyLoggerCache::TlsSessionKeyLogger::LogSessionKeys(
+    SSL_CTX* /* ssl_context */, const std::string& session_keys_info) {
+  grpc_core::MutexLock lock(&lock_);
+  if (fd_ == nullptr || session_keys_info.empty()) return;
+  // Append to key log file under lock
+  bool err =
+      fwrite((session_keys_info + "\r\n").c_str(), sizeof(char),
+             session_keys_info.length() + 1, fd_) < session_keys_info.length();
+
+  if (err) {
+    grpc_error_handle error = GRPC_OS_ERROR(errno, "fwrite");
+    gpr_log(GPR_ERROR, "Error Appending to TLS session key log file: %s",
+            grpc_error_std_string(error).c_str());
+    fclose(fd_);
+    fd_ = nullptr;  // disable future attempts to write to this file
+  } else {
+    fflush(fd_);
+  }
+}
+
+TlsSessionKeyLoggerCache::TlsSessionKeyLoggerCache()
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(g_tls_session_key_log_cache_mu) {
+  g_cache_instance = this;
+}
+
+TlsSessionKeyLoggerCache::~TlsSessionKeyLoggerCache() {
+  grpc_core::MutexLock lock(g_tls_session_key_log_cache_mu);
+  g_cache_instance = nullptr;
+}
+
+grpc_core::RefCountedPtr<TlsSessionKeyLogger> TlsSessionKeyLoggerCache::Get(
+    std::string tls_session_key_log_file_path) {
+  gpr_once_init(&g_cache_mutex_init, do_cache_mutex_init);
+  GPR_DEBUG_ASSERT(g_tls_session_key_log_cache_mu != nullptr);
+  if (tls_session_key_log_file_path.empty()) {
+    return nullptr;
+  }
+  {
+    grpc_core::MutexLock lock(g_tls_session_key_log_cache_mu);
+    grpc_core::RefCountedPtr<TlsSessionKeyLoggerCache> cache;
+    if (g_cache_instance == nullptr) {
+      // This will automatically set g_cache_instance.
+      cache = grpc_core::MakeRefCounted<TlsSessionKeyLoggerCache>();
+    } else {
+      cache = g_cache_instance->Ref();
+    }
+    // Check cache for entry.
+    auto it =
+        cache->tls_session_key_logger_map_.find(tls_session_key_log_file_path);
+    if (it != cache->tls_session_key_logger_map_.end()) {
+      // Avoid a race condition if the destructor of the tls key logger
+      // of interest is currently executing.
+      auto key_logger = it->second->RefIfNonZero();
+      if (key_logger != nullptr) return key_logger;
+    }
+    // Not found in cache, so create new entry.
+    // This will automatically add itself to tls_session_key_logger_map_.
+    return grpc_core::MakeRefCounted<TlsSessionKeyLogger>(
+        std::move(tls_session_key_log_file_path), std::move(cache));
+  }
+}
+
+};  // namespace tsi