grpc 1.44.0.pre2 → 1.46.3

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

@@ -25,94 +25,199 @@
 
 #include <grpc/support/time.h>
 
+#include "src/core/lib/channel/handshaker.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/endpoint.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/resolve_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
 
-/* TODO(ctiller): allow caching and capturing multiple requests for the
-                  same content and combining them */
-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;
-
-/* Asynchronously perform a HTTP GET.
-   '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
-   'resource_quota' allows the caller to specify the quota against which to
-   allocate
-   '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_polling_entity* pollent,
-                      grpc_core::ResourceQuotaRefPtr resource_quota,
-                      const grpc_httpcli_request* request, grpc_millis deadline,
-                      grpc_closure* on_done, grpc_httpcli_response* response);
-
-/* Asynchronously perform a HTTP POST.
-   '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
-   'resource_quota' allows the caller to specify the quota against which to
-   allocate
-   '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_polling_entity* pollent,
-                       grpc_core::ResourceQuotaRefPtr 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);
+
+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;
+
+  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);
+
+  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);
+  }
+
+  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);
+
+  static void OnConnected(void* arg, grpc_error_handle error);
+
+  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_closure connected_;
+  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;
+  bool connecting_ 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;
+  OrphanablePtr<DNSResolver::Request> dns_request_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_HTTP_HTTPCLI_H */

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

@@ -31,20 +31,24 @@
 #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/http/httpcli.h"
 #include "src/core/lib/iomgr/pollset.h"
+#include "src/core/lib/promise/promise.h"
 #include "src/core/lib/security/credentials/credentials.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/tsi/ssl_transport_security.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) {}
@@ -69,18 +73,18 @@ class grpc_httpcli_ssl_channel_security_connector final
 
   void add_handshakers(const grpc_channel_args* 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 +92,7 @@ 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*/,
+                  RefCountedPtr<grpc_auth_context>* /*auth_context*/,
                   grpc_closure* on_peer_checked) override {
     grpc_error_handle error = GRPC_ERROR_NONE;
 
@@ -98,7 +102,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 +118,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 +130,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 +151,54 @@ 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,
+      const grpc_channel_args* args,
+      grpc_channel_args** /*new_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;
+    }
+    const char* ssl_host_override =
+        grpc_channel_args_find_string(args, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
+    if (ssl_host_override != nullptr) {
+      target = ssl_host_override;
+    }
+    return httpcli_ssl_channel_security_connector_create(pem_root_certs,
+                                                         root_store, target);
+  }
+
+  RefCountedPtr<grpc_channel_credentials> duplicate_without_call_credentials()
+      override {
+    return Ref();
+  }
 
-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);
+  grpc_channel_args* update_arguments(grpc_channel_args* args) override {
+    return args;
   }
-  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;
+  const char* type() const override { return "HttpRequestSSL"; }
+
+ 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,37 @@
+//
+// 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 "src/core/lib/security/credentials/credentials.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

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

@@ -177,6 +177,7 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
   uint8_t* cur = beg;
   uint8_t* end = beg + parser->cur_line_length;
   size_t* hdr_count = nullptr;
+  size_t size = 0;
   grpc_http_header** hdrs = nullptr;
   grpc_http_header hdr = {nullptr, nullptr};
   grpc_error_handle error = GRPC_ERROR_NONE;
@@ -205,13 +206,20 @@ static grpc_error_handle add_header(grpc_http_parser* parser) {
     cur++;
   }
   GPR_ASSERT((size_t)(end - cur) >= parser->cur_line_end_length);
-  hdr.value = buf2str(
-      cur, static_cast<size_t>(end - cur) - parser->cur_line_end_length);
+  size = static_cast<size_t>(end - cur) - parser->cur_line_end_length;
+  if ((size != 0) && (cur[size - 1] == '\r')) {
+    size--;
+  }
+  hdr.value = buf2str(cur, size);
 
   switch (parser->type) {
     case GRPC_HTTP_RESPONSE:
       hdr_count = &parser->http.response->hdr_count;
       hdrs = &parser->http.response->hdrs;
+      if ((strcmp(hdr.key, "Transfer-Encoding") == 0) &&
+          (strcmp(hdr.value, "chunked") == 0)) {
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+      }
       break;
     case GRPC_HTTP_REQUEST:
       hdr_count = &parser->http.request->hdr_count;
@@ -245,17 +253,24 @@ static grpc_error_handle finish_line(grpc_http_parser* parser,
       parser->state = GRPC_HTTP_HEADERS;
       break;
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length == parser->cur_line_end_length) {
-        parser->state = GRPC_HTTP_BODY;
-        *found_body_start = true;
+        if (parser->state == GRPC_HTTP_HEADERS) {
+          parser->state = GRPC_HTTP_BODY;
+          *found_body_start = true;
+        } else {
+          parser->state = GRPC_HTTP_END;
+        }
         break;
-      }
-      err = add_header(parser);
-      if (err != GRPC_ERROR_NONE) {
-        return err;
+      } else {
+        err = add_header(parser);
+        if (err != GRPC_ERROR_NONE) {
+          return err;
+        }
       }
       break;
     case GRPC_HTTP_BODY:
+    case GRPC_HTTP_END:
       GPR_UNREACHABLE_CODE(return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Should never reach here"));
   }
@@ -269,6 +284,59 @@ static grpc_error_handle addbyte_body(grpc_http_parser* parser, uint8_t byte) {
   char** body = nullptr;
 
   if (parser->type == GRPC_HTTP_RESPONSE) {
+    switch (parser->http.response->chunked_state) {
+      case GRPC_HTTP_CHUNKED_LENGTH:
+        if ((byte == '\r') || (byte == ';')) {
+          parser->http.response->chunked_state =
+              GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF;
+        } else if ((byte >= '0') && (byte <= '9')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - '0';
+        } else if ((byte >= 'a') && (byte <= 'f')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'a' + 10;
+        } else if ((byte >= 'A') && (byte <= 'F')) {
+          parser->http.response->chunk_length *= 16;
+          parser->http.response->chunk_length += byte - 'A' + 10;
+        } else {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected chunk size in hexadecimal");
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_IGNORE_ALL_UNTIL_LF:
+        if (byte == '\n') {
+          if (parser->http.response->chunk_length == 0) {
+            parser->state = GRPC_HTTP_TRAILERS;
+          } else {
+            parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_BODY;
+          }
+        }
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_BODY:
+        if (parser->http.response->chunk_length == 0) {
+          if (byte != '\r') {
+            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                "Expected '\\r\\n' after chunk body");
+          }
+          parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_CONSUME_LF;
+          parser->http.response->chunk_length = 0;
+          return GRPC_ERROR_NONE;
+        } else {
+          parser->http.response->chunk_length--;
+          /* fallback to the normal body appending code below */
+        }
+        break;
+      case GRPC_HTTP_CHUNKED_CONSUME_LF:
+        if (byte != '\n') {
+          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "Expected '\\r\\n' after chunk body");
+        }
+        parser->http.response->chunked_state = GRPC_HTTP_CHUNKED_LENGTH;
+        return GRPC_ERROR_NONE;
+      case GRPC_HTTP_CHUNKED_PLAIN:
+        /* avoiding warning; just fallback to normal codepath */
+        break;
+    }
     body_length = &parser->http.response->body_length;
     body = &parser->http.response->body;
   } else if (parser->type == GRPC_HTTP_REQUEST) {
@@ -318,6 +386,7 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
+    case GRPC_HTTP_TRAILERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace)) {
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
@@ -334,6 +403,8 @@ static grpc_error_handle addbyte(grpc_http_parser* parser, uint8_t byte,
       return GRPC_ERROR_NONE;
     case GRPC_HTTP_BODY:
       return addbyte_body(parser, byte);
+    case GRPC_HTTP_END:
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Unexpected byte after end");
   }
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
 }
@@ -385,7 +456,7 @@ grpc_error_handle grpc_http_parser_parse(grpc_http_parser* parser,
 }
 
 grpc_error_handle grpc_http_parser_eof(grpc_http_parser* parser) {
-  if (parser->state != GRPC_HTTP_BODY) {
+  if ((parser->state != GRPC_HTTP_BODY) && (parser->state != GRPC_HTTP_END)) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Did not finish headers");
   }
   return GRPC_ERROR_NONE;