grpc 1.42.0 → 1.49.1

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

@@ -23,106 +23,249 @@
 
 #include <stddef.h>
 
-#include <grpc/support/time.h>
+#include <functional>
+#include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/status/statusor.h"
+#include "absl/types/optional.h"
+
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
+
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/http/parser.h"
+#include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #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"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+#include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/transport/handshaker.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
 
-/* Tracks in-progress http requests
-   TODO(ctiller): allow caching and capturing multiple requests for the
-                  same content and combining them */
-typedef struct grpc_httpcli_context {
-  grpc_pollset_set* pollset_set;
-} grpc_httpcli_context;
-
-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));
-};
-extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
-extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
-
-/* A request */
-typedef struct grpc_httpcli_request {
-  /* The host name to connect to */
-  char* host;
-  /* The host to verify in the SSL handshake (or NULL) */
-  char* ssl_host_override;
-  /* The main part of the request
-     The following headers are supplied automatically and MUST NOT be set here:
-     Host, Connection, User-Agent */
-  grpc_http_request http;
-  /* handshaker to use ssl for the request */
-  const grpc_httpcli_handshaker* handshaker;
-} grpc_httpcli_request;
-
-/* Expose the parser response type as a httpcli response too */
-typedef struct grpc_http_response grpc_httpcli_response;
-
-void grpc_httpcli_context_init(grpc_httpcli_context* context);
-void grpc_httpcli_context_destroy(grpc_httpcli_context* context);
-
-/* Asynchronously perform a HTTP GET.
-   'context' specifies the http context under which to do the get
-   '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)
-   'on_response' is a callback to report results to */
-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_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.
-     When there is no body, pass in NULL as body_bytes.
-   'deadline' contains a deadline for the request (or gpr_inf_future)
-   'em' points to a caller owned event manager that must be alive for the
-     lifetime of the request
-   'on_response' is a callback to report results to
-   Does not support ?var1=val1&var2=val2 in the path. */
-void grpc_httpcli_post(grpc_httpcli_context* context,
-                       grpc_polling_entity* pollent,
-                       grpc_resource_quota* resource_quota,
-                       const grpc_httpcli_request* request,
-                       const char* body_bytes, size_t body_size,
-                       grpc_millis deadline, grpc_closure* on_done,
-                       grpc_httpcli_response* response);
-
 /* override functions return 1 if they handled the request, 0 otherwise */
-typedef int (*grpc_httpcli_get_override)(const grpc_httpcli_request* request,
-                                         grpc_millis deadline,
+typedef int (*grpc_httpcli_get_override)(const grpc_http_request* request,
+                                         const char* host, const char* path,
+                                         grpc_core::Timestamp deadline,
                                          grpc_closure* on_complete,
-                                         grpc_httpcli_response* response);
-typedef int (*grpc_httpcli_post_override)(const grpc_httpcli_request* request,
-                                          const char* body_bytes,
-                                          size_t body_size,
-                                          grpc_millis deadline,
-                                          grpc_closure* on_complete,
-                                          grpc_httpcli_response* response);
-
-void grpc_httpcli_set_override(grpc_httpcli_get_override get,
-                               grpc_httpcli_post_override post);
+                                         grpc_http_response* response);
+typedef int (*grpc_httpcli_post_override)(
+    const grpc_http_request* request, const char* host, const char* path,
+    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
+    grpc_closure* on_complete, grpc_http_response* response);
+typedef int (*grpc_httpcli_put_override)(
+    const grpc_http_request* request, const char* host, const char* path,
+    const char* body_bytes, size_t body_size, grpc_core::Timestamp deadline,
+    grpc_closure* on_complete, grpc_http_response* response);
+
+namespace grpc_core {
+
+// Tracks an in-progress GET or POST request. Calling \a Start()
+// begins async work and calling \a Orphan() arranges for async work
+// to be completed as sooon as possible (possibly aborting the request
+// if it's in flight).
+// TODO(ctiller): allow caching and capturing multiple requests for the
+//                same content and combining them
+class HttpRequest : public InternallyRefCounted<HttpRequest> {
+ public:
+  // Asynchronously perform a HTTP GET.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the get - work on this entity may be used to progress the get
+  //   operation
+  // '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)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(yihuaz): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  static OrphanablePtr<HttpRequest> Get(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
+  // Asynchronously perform a HTTP POST.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the post - work on this entity may be used to progress the post
+  //   operation
+  // '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)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  // Does not support ?var1=val1&var2=val2 in the path.
+  static OrphanablePtr<HttpRequest> Post(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
+  // Asynchronously perform a HTTP PUT.
+  // 'uri' is the target to make the request to. The scheme field is used to
+  //  determine the port number. The authority field is the target host. The
+  //  path field determines the path of the request. No other fields are used.
+  // 'args' are optional channel args for the request.
+  // 'pollent' indicates a grpc_polling_entity that is interested in the result
+  //   of the post - work on this entity may be used to progress the post
+  //   operation
+  // '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)
+  // 'on_done' is a callback to report results to
+  // 'channel_creds' are used to configurably secure the connection.
+  //   For insecure requests, use grpc_insecure_credentials_create.
+  //   For secure requests, use CreateHttpRequestSSLCredentials().
+  //   nullptr is treated as insecure credentials.
+  //   TODO(apolcyn): disallow nullptr as a value after unsecure builds
+  //   are removed.
+  // Does not support ?var1=val1&var2=val2 in the path.
+  static OrphanablePtr<HttpRequest> Put(
+      URI uri, const grpc_channel_args* args, grpc_polling_entity* pollent,
+      const grpc_http_request* request, Timestamp deadline,
+      grpc_closure* on_done, grpc_http_response* response,
+      RefCountedPtr<grpc_channel_credentials> channel_creds)
+      GRPC_MUST_USE_RESULT;
+
+  HttpRequest(URI uri, const grpc_slice& request_text,
+              grpc_http_response* response, Timestamp deadline,
+              const grpc_channel_args* channel_args, grpc_closure* on_done,
+              grpc_polling_entity* pollent, const char* name,
+              absl::optional<std::function<void()>> test_only_generate_response,
+              RefCountedPtr<grpc_channel_credentials> channel_creds);
+
+  ~HttpRequest() override;
+
+  void Start();
+
+  void Orphan() override;
+
+  static void SetOverride(grpc_httpcli_get_override get,
+                          grpc_httpcli_post_override post,
+                          grpc_httpcli_put_override put);
+
+  static void TestOnlySetOnHandshakeDoneIntercept(
+      void (*intercept)(HttpRequest* req));
+
+ private:
+  void Finish(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    grpc_polling_entity_del_from_pollset_set(pollent_, pollset_set_);
+    ExecCtx::Run(DEBUG_LOCATION, on_done_, error);
+  }
+
+  void AppendError(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void DoRead() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+    Ref().release();  // ref held by pending read
+    grpc_endpoint_read(ep_, &incoming_, &on_read_, /*urgent=*/true,
+                       /*min_progress_size=*/1);
+  }
+
+  static void OnRead(void* user_data, grpc_error_handle error) {
+    HttpRequest* req = static_cast<HttpRequest*>(user_data);
+    ExecCtx::Run(DEBUG_LOCATION,
+                 &req->continue_on_read_after_schedule_on_exec_ctx_,
+                 GRPC_ERROR_REF(error));
+  }
+
+  // Needed since OnRead may be called inline from grpc_endpoint_read
+  static void ContinueOnReadAfterScheduleOnExecCtx(void* user_data,
+                                                   grpc_error_handle error) {
+    RefCountedPtr<HttpRequest> req(static_cast<HttpRequest*>(user_data));
+    MutexLock lock(&req->mu_);
+    req->OnReadInternal(error);
+  }
+
+  void OnReadInternal(grpc_error_handle error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void OnWritten() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) { DoRead(); }
+
+  static void DoneWrite(void* arg, grpc_error_handle error) {
+    HttpRequest* req = static_cast<HttpRequest*>(arg);
+    ExecCtx::Run(DEBUG_LOCATION,
+                 &req->continue_done_write_after_schedule_on_exec_ctx_,
+                 GRPC_ERROR_REF(error));
+  }
+
+  // Needed since DoneWrite may be called inline from grpc_endpoint_write
+  static void ContinueDoneWriteAfterScheduleOnExecCtx(void* arg,
+                                                      grpc_error_handle error);
+
+  void StartWrite() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  static void OnHandshakeDone(void* arg, grpc_error_handle error);
+
+  void DoHandshake(const grpc_resolved_address* addr)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void NextAddress(grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  void OnResolved(
+      absl::StatusOr<std::vector<grpc_resolved_address>> addresses_or);
+
+  const URI uri_;
+  const grpc_slice request_text_;
+  const Timestamp deadline_;
+  const grpc_channel_args* channel_args_;
+  RefCountedPtr<grpc_channel_credentials> channel_creds_;
+  grpc_closure on_read_;
+  grpc_closure continue_on_read_after_schedule_on_exec_ctx_;
+  grpc_closure done_write_;
+  grpc_closure continue_done_write_after_schedule_on_exec_ctx_;
+  grpc_endpoint* ep_ = nullptr;
+  grpc_closure* on_done_;
+  ResourceQuotaRefPtr resource_quota_;
+  grpc_polling_entity* pollent_;
+  grpc_pollset_set* pollset_set_;
+  const absl::optional<std::function<void()>> test_only_generate_response_;
+  Mutex mu_;
+  RefCountedPtr<HandshakeManager> handshake_mgr_ ABSL_GUARDED_BY(mu_);
+  bool own_endpoint_ ABSL_GUARDED_BY(mu_) = true;
+  bool cancelled_ ABSL_GUARDED_BY(mu_) = false;
+  grpc_http_parser parser_ ABSL_GUARDED_BY(mu_);
+  std::vector<grpc_resolved_address> addresses_ ABSL_GUARDED_BY(mu_);
+  size_t next_address_ ABSL_GUARDED_BY(mu_) = 0;
+  int have_read_byte_ ABSL_GUARDED_BY(mu_) = 0;
+  grpc_iomgr_object iomgr_obj_ ABSL_GUARDED_BY(mu_);
+  grpc_slice_buffer incoming_ ABSL_GUARDED_BY(mu_);
+  grpc_slice_buffer outgoing_ ABSL_GUARDED_BY(mu_);
+  grpc_error_handle overall_error_ ABSL_GUARDED_BY(mu_) = GRPC_ERROR_NONE;
+  absl::optional<DNSResolver::TaskHandle> dns_request_handle_
+      ABSL_GUARDED_BY(mu_) = DNSResolver::kNullHandle;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_HTTP_HTTPCLI_H */

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

@@ -20,31 +20,49 @@
 
 #include <string.h>
 
+#include <string>
+
+#include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/grpc_types.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/config/core_configuration.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/http/httpcli.h"
-#include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/endpoint.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/security/security_connector/ssl_utils.h"
 #include "src/core/lib/security/transport/security_handshaker.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/transport/handshaker.h"
 #include "src/core/tsi/ssl_transport_security.h"
+#include "src/core/tsi/transport_security_interface.h"
+
+namespace grpc_core {
+
+namespace {
 
 class grpc_httpcli_ssl_channel_security_connector final
     : public grpc_channel_security_connector {
  public:
   explicit grpc_httpcli_ssl_channel_security_connector(char* secure_peer_name)
       : grpc_channel_security_connector(
-            /*url_scheme=*/nullptr,
+            /*url_scheme=*/{},
             /*channel_creds=*/nullptr,
             /*request_metadata_creds=*/nullptr),
         secure_peer_name_(secure_peer_name) {}
@@ -67,20 +85,20 @@ class grpc_httpcli_ssl_channel_security_connector final
         &options, &handshaker_factory_);
   }
 
-  void add_handshakers(const grpc_channel_args* args,
+  void add_handshakers(const ChannelArgs& args,
                        grpc_pollset_set* /*interested_parties*/,
-                       grpc_core::HandshakeManager* handshake_mgr) override {
+                       HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
     if (handshaker_factory_ != nullptr) {
       tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
-          handshaker_factory_, secure_peer_name_, &handshaker);
+          handshaker_factory_, secure_peer_name_, /*network_bio_buf_size=*/0,
+          /*ssl_bio_buf_size=*/0, &handshaker);
       if (result != TSI_OK) {
         gpr_log(GPR_ERROR, "Handshaker creation failed with error %s.",
                 tsi_result_to_string(result));
       }
     }
-    handshake_mgr->Add(
-        grpc_core::SecurityHandshakerCreate(handshaker, this, args));
+    handshake_mgr->Add(SecurityHandshakerCreate(handshaker, this, args));
   }
 
   tsi_ssl_client_handshaker_factory* handshaker_factory() const {
@@ -88,7 +106,8 @@ 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*/,
+                  const ChannelArgs& /*args*/,
+                  RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error_handle error = GRPC_ERROR_NONE;
 
@@ -98,7 +117,7 @@ class grpc_httpcli_ssl_channel_security_connector final
       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);
+    ExecCtx::Run(DEBUG_LOCATION, on_peer_checked, error);
     tsi_peer_destruct(&peer);
   }
 
@@ -114,17 +133,9 @@ class grpc_httpcli_ssl_channel_security_connector final
     return strcmp(secure_peer_name_, other->secure_peer_name_);
   }
 
-  bool check_call_host(absl::string_view /*host*/,
-                       grpc_auth_context* /*auth_context*/,
-                       grpc_closure* /*on_call_host_checked*/,
-                       grpc_error_handle* error) override {
-    *error = GRPC_ERROR_NONE;
-    return true;
-  }
-
-  void cancel_check_call_host(grpc_closure* /*on_call_host_checked*/,
-                              grpc_error_handle error) override {
-    GRPC_ERROR_UNREF(error);
+  ArenaPromise<absl::Status> CheckCallHost(absl::string_view,
+                                           grpc_auth_context*) override {
+    return ImmediateOkStatus();
   }
 
   const char* secure_peer_name() const { return secure_peer_name_; }
@@ -134,17 +145,17 @@ class grpc_httpcli_ssl_channel_security_connector final
   char* secure_peer_name_;
 };
 
-static grpc_core::RefCountedPtr<grpc_channel_security_connector>
+RefCountedPtr<grpc_channel_security_connector>
 httpcli_ssl_channel_security_connector_create(
     const char* pem_root_certs, const tsi_ssl_root_certs_store* root_store,
-    const char* secure_peer_name, grpc_channel_args* /*channel_args*/) {
+    const char* secure_peer_name) {
   if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR,
             "Cannot assert a secure peer name without a trust root.");
     return nullptr;
   }
-  grpc_core::RefCountedPtr<grpc_httpcli_ssl_channel_security_connector> c =
-      grpc_core::MakeRefCounted<grpc_httpcli_ssl_channel_security_connector>(
+  RefCountedPtr<grpc_httpcli_ssl_channel_security_connector> c =
+      MakeRefCounted<grpc_httpcli_ssl_channel_security_connector>(
           secure_peer_name == nullptr ? nullptr : gpr_strdup(secure_peer_name));
   tsi_result result = c->InitHandshakerFactory(pem_root_certs, root_store);
   if (result != TSI_OK) {
@@ -155,61 +166,50 @@ httpcli_ssl_channel_security_connector_create(
   return c;
 }
 
-/* handshaker */
+class HttpRequestSSLCredentials : public grpc_channel_credentials {
+ public:
+  RefCountedPtr<grpc_channel_security_connector> create_security_connector(
+      RefCountedPtr<grpc_call_credentials> /*call_creds*/, const char* target,
+      ChannelArgs* args) override {
+    const char* pem_root_certs = DefaultSslRootStore::GetPemRootCerts();
+    const tsi_ssl_root_certs_store* root_store =
+        DefaultSslRootStore::GetRootStore();
+    if (root_store == nullptr) {
+      gpr_log(GPR_ERROR, "Could not get default pem root certs.");
+      return nullptr;
+    }
+    absl::optional<std::string> target_string =
+        args->GetOwnedString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG)
+            .value_or(target);
+    return httpcli_ssl_channel_security_connector_create(
+        pem_root_certs, root_store, target_string->c_str());
+  }
 
-struct on_done_closure {
-  void (*func)(void* arg, grpc_endpoint* endpoint);
-  void* arg;
-  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
-};
-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) {
-    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);
-    grpc_slice_buffer_destroy_internal(args->read_buffer);
-    gpr_free(args->read_buffer);
-    c->func(c->arg, args->endpoint);
+  RefCountedPtr<grpc_channel_credentials> duplicate_without_call_credentials()
+      override {
+    return Ref();
+  }
+
+  UniqueTypeName type() const override {
+    static UniqueTypeName::Factory kFactory("HttpRequestSSL");
+    return kFactory.Create();
   }
-  delete c;
-}
 
-static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
-                          grpc_millis deadline,
-                          void (*on_done)(void* arg, grpc_endpoint* endpoint)) {
-  auto* c = new on_done_closure();
-  const char* pem_root_certs =
-      grpc_core::DefaultSslRootStore::GetPemRootCerts();
-  const tsi_ssl_root_certs_store* root_store =
-      grpc_core::DefaultSslRootStore::GetRootStore();
-  if (root_store == nullptr) {
-    gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(arg, nullptr);
-    gpr_free(c);
-    return;
+ private:
+  int cmp_impl(const grpc_channel_credentials* /* other */) const override {
+    // There's no differentiating factor between two HttpRequestSSLCredentials
+    // objects.
+    return 0;
   }
-  c->func = on_done;
-  c->arg = arg;
-  grpc_core::RefCountedPtr<grpc_channel_security_connector> sc =
-      httpcli_ssl_channel_security_connector_create(
-          pem_root_certs, root_store, host,
-          static_cast<grpc_core::HandshakerArgs*>(arg)->args);
-
-  GPR_ASSERT(sc != nullptr);
-  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::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);
-  sc.reset(DEBUG_LOCATION, "httpcli");
+};
+
+}  // namespace
+
+RefCountedPtr<grpc_channel_credentials> CreateHttpRequestSSLCredentials() {
+  // Create a singleton object for HttpRequestSSLCredentials so that channels to
+  // the same target with HttpRequestSSLCredentials can reuse the subchannels.
+  static auto* creds = new HttpRequestSSLCredentials();
+  return creds->Ref();
 }
 
-const grpc_httpcli_handshaker grpc_httpcli_ssl = {"https", ssl_handshake};
+}  // namespace grpc_core

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

@@ -0,0 +1,39 @@
+//
+// Copyright 2015 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_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+#define GRPC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/grpc.h>
+
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+
+namespace grpc_core {
+
+// Creates a channel credentials suitable for use with the
+// HttpRequest::Get and HttpRequest::Post APIs. Notably, this allows
+// HTTP1 requests to use secure connections without ALPN (as the
+// typical gRPC SSL credentials do).
+//
+// These credentials are NOT INTENDED FOR USE with gRPC channels, and
+// MUST ONLY BE USED with the HttpRequest::Get and Post APIs.
+RefCountedPtr<grpc_channel_credentials> CreateHttpRequestSSLCredentials();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_HTTP_HTTPCLI_SSL_CREDENTIALS_H