grpc 1.28.0 → 1.42.0

data/src/core/lib/http/httpcli.cc

@@ -22,11 +22,16 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/http/format_request.h"
@@ -34,193 +39,231 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-typedef struct {
-  grpc_slice request_text;
-  grpc_http_parser parser;
-  grpc_resolved_addresses* addresses;
-  size_t next_address;
-  grpc_endpoint* ep;
-  char* host;
-  char* ssl_host_override;
-  grpc_millis deadline;
-  int have_read_byte;
-  const grpc_httpcli_handshaker* handshaker;
-  grpc_closure* on_done;
-  grpc_httpcli_context* context;
-  grpc_polling_entity* pollent;
-  grpc_iomgr_object iomgr_obj;
-  grpc_slice_buffer incoming;
-  grpc_slice_buffer outgoing;
-  grpc_closure on_read;
-  grpc_closure done_write;
-  grpc_closure connected;
-  grpc_error* overall_error;
-  grpc_resource_quota* resource_quota;
-} internal_request;
+namespace grpc_core {
+namespace {
+
+class InternalRequest {
+ public:
+  InternalRequest(const grpc_slice& request_text,
+                  grpc_httpcli_response* response,
+                  grpc_resource_quota* resource_quota, absl::string_view host,
+                  absl::string_view ssl_host_override, grpc_millis deadline,
+                  const grpc_httpcli_handshaker* handshaker,
+                  grpc_closure* on_done, grpc_httpcli_context* context,
+                  grpc_polling_entity* pollent, const char* name)
+      : request_text_(request_text),
+        resource_quota_(resource_quota),
+        host_(host),
+        ssl_host_override_(ssl_host_override),
+        deadline_(deadline),
+        handshaker_(handshaker),
+        on_done_(on_done),
+        context_(context),
+        pollent_(pollent) {
+    grpc_http_parser_init(&parser_, GRPC_HTTP_RESPONSE, response);
+    grpc_slice_buffer_init(&incoming_);
+    grpc_slice_buffer_init(&outgoing_);
+    grpc_iomgr_register_object(&iomgr_obj_, name);
+
+    GRPC_CLOSURE_INIT(&on_read_, OnRead, this, grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&done_write_, DoneWrite, this, grpc_schedule_on_exec_ctx);
+    GPR_ASSERT(pollent);
+    grpc_polling_entity_add_to_pollset_set(pollent_, context->pollset_set);
+    grpc_resolve_address(
+        host_.c_str(), handshaker_->default_port, context_->pollset_set,
+        GRPC_CLOSURE_CREATE(OnResolved, this, grpc_schedule_on_exec_ctx),
+        &addresses_);
+  }
 
-static grpc_httpcli_get_override g_get_override = nullptr;
-static grpc_httpcli_post_override g_post_override = nullptr;
+  ~InternalRequest() {
+    grpc_http_parser_destroy(&parser_);
+    if (addresses_ != nullptr) {
+      grpc_resolved_addresses_destroy(addresses_);
+    }
+    if (ep_ != nullptr) {
+      grpc_endpoint_destroy(ep_);
+    }
+    grpc_slice_unref_internal(request_text_);
+    grpc_iomgr_unregister_object(&iomgr_obj_);
+    grpc_slice_buffer_destroy_internal(&incoming_);
+    grpc_slice_buffer_destroy_internal(&outgoing_);
+    GRPC_ERROR_UNREF(overall_error_);
+    grpc_resource_quota_unref_internal(resource_quota_);
+  }
 
-static void plaintext_handshake(void* arg, grpc_endpoint* endpoint,
-                                const char* /*host*/, grpc_millis /*deadline*/,
-                                void (*on_done)(void* arg,
-                                                grpc_endpoint* endpoint)) {
-  on_done(arg, endpoint);
-}
+ private:
+  void Finish(grpc_error_handle error) {
+    grpc_polling_entity_del_from_pollset_set(pollent_, context_->pollset_set);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
+    delete this;
+  }
 
-const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
-                                                        plaintext_handshake};
+  void AppendError(grpc_error_handle error) {
+    if (overall_error_ == GRPC_ERROR_NONE) {
+      overall_error_ =
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
+    }
+    grpc_resolved_address* addr = &addresses_->addrs[next_address_ - 1];
+    std::string addr_text = grpc_sockaddr_to_uri(addr);
+    overall_error_ = grpc_error_add_child(
+        overall_error_,
+        grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS, addr_text));
+  }
 
-void grpc_httpcli_context_init(grpc_httpcli_context* context) {
-  context->pollset_set = grpc_pollset_set_create();
-}
+  void DoRead() {
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true);
+  }
 
-void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
-  grpc_pollset_set_destroy(context->pollset_set);
-}
+  static void OnRead(void* user_data, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(user_data);
+    req->OnReadInternal(error);
+  }
 
-static void next_address(internal_request* req, grpc_error* due_to_error);
+  void OnReadInternal(grpc_error_handle error) {
+    size_t i;
+
+    for (i = 0; i < incoming_.count; i++) {
+      if (GRPC_SLICE_LENGTH(incoming_.slices[i])) {
+        have_read_byte_ = 1;
+        grpc_error_handle err =
+            grpc_http_parser_parse(&parser_, incoming_.slices[i], nullptr);
+        if (err != GRPC_ERROR_NONE) {
+          Finish(err);
+          return;
+        }
+      }
+    }
 
-static void finish(internal_request* req, grpc_error* error) {
-  grpc_polling_entity_del_from_pollset_set(req->pollent,
-                                           req->context->pollset_set);
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, req->on_done, error);
-  grpc_http_parser_destroy(&req->parser);
-  if (req->addresses != nullptr) {
-    grpc_resolved_addresses_destroy(req->addresses);
+    if (error == GRPC_ERROR_NONE) {
+      DoRead();
+    } else if (!have_read_byte_) {
+      NextAddress(GRPC_ERROR_REF(error));
+    } else {
+      Finish(grpc_http_parser_eof(&parser_));
+    }
   }
-  if (req->ep != nullptr) {
-    grpc_endpoint_destroy(req->ep);
+
+  void OnWritten() { DoRead(); }
+
+  static void DoneWrite(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
+    if (error == GRPC_ERROR_NONE) {
+      req->OnWritten();
+    } else {
+      req->NextAddress(GRPC_ERROR_REF(error));
+    }
   }
-  grpc_slice_unref_internal(req->request_text);
-  gpr_free(req->host);
-  gpr_free(req->ssl_host_override);
-  grpc_iomgr_unregister_object(&req->iomgr_obj);
-  grpc_slice_buffer_destroy_internal(&req->incoming);
-  grpc_slice_buffer_destroy_internal(&req->outgoing);
-  GRPC_ERROR_UNREF(req->overall_error);
-  grpc_resource_quota_unref_internal(req->resource_quota);
-  gpr_free(req);
-}
 
-static void append_error(internal_request* req, grpc_error* error) {
-  if (req->overall_error == GRPC_ERROR_NONE) {
-    req->overall_error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed HTTP/1 client request");
+  void StartWrite() {
+    grpc_slice_ref_internal(request_text_);
+    grpc_slice_buffer_add(&outgoing_, request_text_);
+    grpc_endpoint_write(ep_, &outgoing_, &done_write_, nullptr);
   }
-  grpc_resolved_address* addr = &req->addresses->addrs[req->next_address - 1];
-  grpc_core::UniquePtr<char> addr_text(grpc_sockaddr_to_uri(addr));
-  req->overall_error = grpc_error_add_child(
-      req->overall_error,
-      grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                         grpc_slice_from_moved_string(std::move(addr_text))));
-}
 
-static void do_read(internal_request* req) {
-  grpc_endpoint_read(req->ep, &req->incoming, &req->on_read, /*urgent=*/true);
-}
+  static void OnHandshakeDone(void* arg, grpc_endpoint* ep) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
 
-static void on_read(void* user_data, grpc_error* error) {
-  internal_request* req = static_cast<internal_request*>(user_data);
-  size_t i;
-
-  for (i = 0; i < req->incoming.count; i++) {
-    if (GRPC_SLICE_LENGTH(req->incoming.slices[i])) {
-      req->have_read_byte = 1;
-      grpc_error* err = grpc_http_parser_parse(
-          &req->parser, req->incoming.slices[i], nullptr);
-      if (err != GRPC_ERROR_NONE) {
-        finish(req, err);
-        return;
-      }
+    if (!ep) {
+      req->NextAddress(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "Unexplained handshake failure"));
+      return;
     }
-  }
 
-  if (error == GRPC_ERROR_NONE) {
-    do_read(req);
-  } else if (!req->have_read_byte) {
-    next_address(req, GRPC_ERROR_REF(error));
-  } else {
-    finish(req, grpc_http_parser_eof(&req->parser));
+    req->ep_ = ep;
+    req->StartWrite();
   }
-}
 
-static void on_written(internal_request* req) { do_read(req); }
+  static void OnConnected(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
 
-static void done_write(void* arg, grpc_error* error) {
-  internal_request* req = static_cast<internal_request*>(arg);
-  if (error == GRPC_ERROR_NONE) {
-    on_written(req);
-  } else {
-    next_address(req, GRPC_ERROR_REF(error));
+    if (!req->ep_) {
+      req->NextAddress(GRPC_ERROR_REF(error));
+      return;
+    }
+    req->handshaker_->handshake(req, req->ep_,
+                                req->ssl_host_override_.empty()
+                                    ? req->host_.c_str()
+                                    : req->ssl_host_override_.c_str(),
+                                req->deadline_, OnHandshakeDone);
   }
-}
-
-static void start_write(internal_request* req) {
-  grpc_slice_ref_internal(req->request_text);
-  grpc_slice_buffer_add(&req->outgoing, req->request_text);
-  grpc_endpoint_write(req->ep, &req->outgoing, &req->done_write, nullptr);
-}
 
-static void on_handshake_done(void* arg, grpc_endpoint* ep) {
-  internal_request* req = static_cast<internal_request*>(arg);
+  void NextAddress(grpc_error_handle error) {
+    grpc_resolved_address* addr;
+    if (error != GRPC_ERROR_NONE) {
+      AppendError(error);
+    }
+    if (next_address_ == addresses_->naddrs) {
+      Finish(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
+          "Failed HTTP requests to all targets", &overall_error_, 1));
+      return;
+    }
+    addr = &addresses_->addrs[next_address_++];
+    GRPC_CLOSURE_INIT(&connected_, OnConnected, this,
+                      grpc_schedule_on_exec_ctx);
+    grpc_tcp_client_connect(&connected_, &ep_,
+                            grpc_slice_allocator_create(
+                                resource_quota_, grpc_sockaddr_to_uri(addr)),
+                            context_->pollset_set, nullptr, addr, deadline_);
+  }
 
-  if (!ep) {
-    next_address(req, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                          "Unexplained handshake failure"));
-    return;
+  static void OnResolved(void* arg, grpc_error_handle error) {
+    InternalRequest* req = static_cast<InternalRequest*>(arg);
+    if (error != GRPC_ERROR_NONE) {
+      req->Finish(GRPC_ERROR_REF(error));
+      return;
+    }
+    req->next_address_ = 0;
+    req->NextAddress(GRPC_ERROR_NONE);
   }
 
-  req->ep = ep;
-  start_write(req);
-}
+  grpc_slice request_text_;
+  grpc_http_parser parser_;
+  grpc_resolved_addresses* addresses_ = nullptr;
+  size_t next_address_ = 0;
+  grpc_endpoint* ep_ = nullptr;
+  grpc_resource_quota* resource_quota_;
+  std::string host_;
+  std::string ssl_host_override_;
+  grpc_millis deadline_;
+  int have_read_byte_ = 0;
+  const grpc_httpcli_handshaker* handshaker_;
+  grpc_closure* on_done_;
+  grpc_httpcli_context* context_;
+  grpc_polling_entity* pollent_;
+  grpc_iomgr_object iomgr_obj_;
+  grpc_slice_buffer incoming_;
+  grpc_slice_buffer outgoing_;
+  grpc_closure on_read_;
+  grpc_closure done_write_;
+  grpc_closure connected_;
+  grpc_error_handle overall_error_ = GRPC_ERROR_NONE;
+};
+
+}  // namespace
+}  // namespace grpc_core
 
-static void on_connected(void* arg, grpc_error* error) {
-  internal_request* req = static_cast<internal_request*>(arg);
+static grpc_httpcli_get_override g_get_override = nullptr;
+static grpc_httpcli_post_override g_post_override = nullptr;
 
-  if (!req->ep) {
-    next_address(req, GRPC_ERROR_REF(error));
-    return;
-  }
-  req->handshaker->handshake(
-      req, req->ep, req->ssl_host_override ? req->ssl_host_override : req->host,
-      req->deadline, on_handshake_done);
+static void plaintext_handshake(void* arg, grpc_endpoint* endpoint,
+                                const char* /*host*/, grpc_millis /*deadline*/,
+                                void (*on_done)(void* arg,
+                                                grpc_endpoint* endpoint)) {
+  on_done(arg, endpoint);
 }
 
-static void next_address(internal_request* req, grpc_error* error) {
-  grpc_resolved_address* addr;
-  if (error != GRPC_ERROR_NONE) {
-    append_error(req, error);
-  }
-  if (req->next_address == req->addresses->naddrs) {
-    finish(req,
-           GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-               "Failed HTTP requests to all targets", &req->overall_error, 1));
-    return;
-  }
-  addr = &req->addresses->addrs[req->next_address++];
-  GRPC_CLOSURE_INIT(&req->connected, on_connected, req,
-                    grpc_schedule_on_exec_ctx);
-  grpc_arg arg = grpc_channel_arg_pointer_create(
-      (char*)GRPC_ARG_RESOURCE_QUOTA, req->resource_quota,
-      grpc_resource_quota_arg_vtable());
-  grpc_channel_args args = {1, &arg};
-  grpc_tcp_client_connect(&req->connected, &req->ep, req->context->pollset_set,
-                          &args, addr, req->deadline);
+const grpc_httpcli_handshaker grpc_httpcli_plaintext = {"http",
+                                                        plaintext_handshake};
+
+void grpc_httpcli_context_init(grpc_httpcli_context* context) {
+  context->pollset_set = grpc_pollset_set_create();
 }
 
-static void on_resolved(void* arg, grpc_error* error) {
-  internal_request* req = static_cast<internal_request*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    finish(req, GRPC_ERROR_REF(error));
-    return;
-  }
-  req->next_address = 0;
-  next_address(req, GRPC_ERROR_NONE);
+void grpc_httpcli_context_destroy(grpc_httpcli_context* context) {
+  grpc_pollset_set_destroy(context->pollset_set);
 }
 
 static void internal_request_begin(grpc_httpcli_context* context,
@@ -231,35 +274,11 @@ static void internal_request_begin(grpc_httpcli_context* context,
                                    grpc_httpcli_response* response,
                                    const char* name,
                                    const grpc_slice& request_text) {
-  internal_request* req =
-      static_cast<internal_request*>(gpr_malloc(sizeof(internal_request)));
-  memset(req, 0, sizeof(*req));
-  req->request_text = request_text;
-  grpc_http_parser_init(&req->parser, GRPC_HTTP_RESPONSE, response);
-  req->on_done = on_done;
-  req->deadline = deadline;
-  req->handshaker =
-      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext;
-  req->context = context;
-  req->pollent = pollent;
-  req->overall_error = GRPC_ERROR_NONE;
-  req->resource_quota = grpc_resource_quota_ref_internal(resource_quota);
-  GRPC_CLOSURE_INIT(&req->on_read, on_read, req, grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&req->done_write, done_write, req,
-                    grpc_schedule_on_exec_ctx);
-  grpc_slice_buffer_init(&req->incoming);
-  grpc_slice_buffer_init(&req->outgoing);
-  grpc_iomgr_register_object(&req->iomgr_obj, name);
-  req->host = gpr_strdup(request->host);
-  req->ssl_host_override = gpr_strdup(request->ssl_host_override);
-
-  GPR_ASSERT(pollent);
-  grpc_polling_entity_add_to_pollset_set(req->pollent,
-                                         req->context->pollset_set);
-  grpc_resolve_address(
-      request->host, req->handshaker->default_port, req->context->pollset_set,
-      GRPC_CLOSURE_CREATE(on_resolved, req, grpc_schedule_on_exec_ctx),
-      &req->addresses);
+  new grpc_core::InternalRequest(
+      request_text, response, resource_quota, request->host,
+      request->ssl_host_override, deadline,
+      request->handshaker ? request->handshaker : &grpc_httpcli_plaintext,
+      on_done, context, pollent, name);
 }
 
 void grpc_httpcli_get(grpc_httpcli_context* context,
@@ -267,15 +286,15 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
                       grpc_closure* on_done, grpc_httpcli_response* response) {
-  char* name;
   if (g_get_override && g_get_override(request, deadline, on_done, response)) {
+    grpc_resource_quota_unref_internal(resource_quota);
     return;
   }
-  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:GET:%s:%s", request->host, request->http.path);
   internal_request_begin(context, pollent, resource_quota, request, deadline,
-                         on_done, response, name,
+                         on_done, response, name.c_str(),
                          grpc_httpcli_format_get_request(request));
-  gpr_free(name);
 }
 
 void grpc_httpcli_post(grpc_httpcli_context* context,
@@ -285,16 +304,17 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        const char* body_bytes, size_t body_size,
                        grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response) {
-  char* name;
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_done, response)) {
+    grpc_resource_quota_unref_internal(resource_quota);
     return;
   }
-  gpr_asprintf(&name, "HTTP:POST:%s:%s", request->host, request->http.path);
+  std::string name =
+      absl::StrFormat("HTTP:POST:%s:%s", request->host, request->http.path);
   internal_request_begin(
       context, pollent, resource_quota, request, deadline, on_done, response,
-      name, grpc_httpcli_format_post_request(request, body_bytes, body_size));
-  gpr_free(name);
+      name.c_str(),
+      grpc_httpcli_format_post_request(request, body_bytes, body_size));
 }
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,

data/src/core/lib/http/httpcli.h

@@ -30,6 +30,7 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resource_quota.h"
 
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
@@ -41,13 +42,12 @@ typedef struct grpc_httpcli_context {
   grpc_pollset_set* pollset_set;
 } grpc_httpcli_context;
 
-typedef struct {
+struct grpc_httpcli_handshaker {
   const char* default_port;
   void (*handshake)(void* arg, grpc_endpoint* endpoint, const char* host,
                     grpc_millis deadline,
                     void (*on_done)(void* arg, grpc_endpoint* endpoint));
-} grpc_httpcli_handshaker;
-
+};
 extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
 extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
 
@@ -76,6 +76,7 @@ void grpc_httpcli_context_destroy(grpc_httpcli_context* context);
    'pollset' indicates a grpc_pollset that is interested in the result
      of the get - work on this pollset may be used to progress the get
      operation
+   'resource_quota: this function takes ownership of a ref from the caller
    'request' contains request parameters - these are caller owned and can be
      destroyed once the call returns
    'deadline' contains a deadline for the request (or gpr_inf_future)
@@ -84,14 +85,14 @@ void grpc_httpcli_get(grpc_httpcli_context* context,
                       grpc_polling_entity* pollent,
                       grpc_resource_quota* resource_quota,
                       const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_complete,
-                      grpc_httpcli_response* response);
+                      grpc_closure* on_done, grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
    'pollset' indicates a grpc_pollset that is interested in the result
      of the post - work on this pollset may be used to progress the post
      operation
+   'resource_quota' - this function takes ownership of a ref from the caller.
    'request' contains request parameters - these are caller owned and can be
      destroyed once the call returns
    'body_bytes' and 'body_size' specify the payload for the post.
@@ -106,7 +107,7 @@ void grpc_httpcli_post(grpc_httpcli_context* context,
                        grpc_resource_quota* resource_quota,
                        const grpc_httpcli_request* request,
                        const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_complete,
+                       grpc_millis deadline, grpc_closure* on_done,
                        grpc_httpcli_response* response);
 
 /* override functions return 1 if they handled the request, 0 otherwise */

data/src/core/lib/http/httpcli_security_connector.cc

@@ -18,19 +18,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/http/httpcli.h"
-
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/handshaker_registry.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/string_view.h"
+#include "src/core/lib/http/httpcli.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
@@ -41,7 +42,7 @@
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
-  grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
+  explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
             /*url_scheme=*/nullptr,
             /*channel_creds=*/nullptr,
@@ -89,21 +90,23 @@ class grpc_httpcli_ssl_channel_security_connector final
   void check_peer(tsi_peer peer, grpc_endpoint* /*ep*/,
                   grpc_core::RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
-    grpc_error* error = GRPC_ERROR_NONE;
+    grpc_error_handle error = GRPC_ERROR_NONE;
 
     /* Check the peer name. */
     if (secure_peer_name_ != nullptr &&
         !tsi_ssl_peer_matches_name(&peer, secure_peer_name_)) {
-      char* msg;
-      gpr_asprintf(&msg, "Peer name %s is not in peer certificate",
-                   secure_peer_name_);
-      error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
+      error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+          "Peer name ", secure_peer_name_, " is not in peer certificate"));
     }
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
   }
 
+  void cancel_check_peer(grpc_closure* /*on_peer_checked*/,
+                         grpc_error_handle error) override {
+    GRPC_ERROR_UNREF(error);
+  }
+
   int cmp(const grpc_security_connector* other_sc) const override {
     auto* other =
         reinterpret_cast<const grpc_httpcli_ssl_channel_security_connector*>(
@@ -111,16 +114,16 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(grpc_core::StringView /*host*/,
+  bool check_call_host(absl::string_view /*host*/,
                        grpc_auth_context* /*auth_context*/,
                        grpc_closure* /*on_call_host_checked*/,
-                       grpc_error** error) override {
+                       grpc_error_handle* error) override {
     *error = GRPC_ERROR_NONE;
     return true;
   }
 
   void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
-                              grpc_error* error) override {
+                              grpc_error_handle error) override {
     GRPC_ERROR_UNREF(error);
   }
 
@@ -154,19 +157,17 @@ httpcli_ssl_channel_security_connector_create(
 
 /* handshaker */
 
-typedef struct {
+struct on_done_closure {
   void (*func)(void* arg, grpc_endpoint* endpoint);
   void* arg;
   grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
-} on_done_closure;
-
-static void on_handshake_done(void* arg, grpc_error* error) {
+};
+static void on_handshake_done(void* arg, grpc_error_handle error) {
   auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   on_done_closure* c = static_cast<on_done_closure*>(args->user_data);
   if (error != GRPC_ERROR_NONE) {
-    const char* msg = grpc_error_string(error);
-    gpr_log(GPR_ERROR, "Secure transport setup failed: %s", msg);
-
+    gpr_log(GPR_ERROR, "Secure transport setup failed: %s",
+            grpc_error_std_string(error).c_str());
     c->func(c->arg, nullptr);
   } else {
     grpc_channel_args_destroy(args->args);
@@ -202,9 +203,9 @@ static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
   grpc_arg channel_arg = grpc_security_connector_to_arg(sc.get());
   grpc_channel_args args = {1, &channel_arg};
   c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
-  grpc_core::HandshakerRegistry::AddHandshakers(
-      grpc_core::HANDSHAKER_CLIENT, &args, /*interested_parties=*/nullptr,
-      c->handshake_mgr.get());
+  grpc_core::CoreConfiguration::Get().handshaker_registry().AddHandshakers(
+      grpc_core::HANDSHAKER_CLIENT, &args,
+      /*interested_parties=*/nullptr, c->handshake_mgr.get());
   c->handshake_mgr->DoHandshake(tcp, /*channel_args=*/nullptr, deadline,
                                 /*acceptor=*/nullptr, on_handshake_done,
                                 /*user_data=*/c);