grpc 1.64.3 → 1.65.0.pre1

data/src/core/tsi/ssl_transport_security_utils.cc

@@ -18,12 +18,19 @@
 
 #include "src/core/tsi/ssl_transport_security_utils.h"
 
+#include <openssl/bio.h>
 #include <openssl/crypto.h>
+#include <openssl/ec.h>
 #include <openssl/err.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
 #include <openssl/ssl.h>
+#include <openssl/x509.h>
 #include <openssl/x509v3.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
@@ -63,7 +70,7 @@ void LogSslErrorStack(void) {
   while ((err = ERR_get_error()) != 0) {
     char details[256];
     ERR_error_string_n(static_cast<uint32_t>(err), details, sizeof(details));
-    gpr_log(GPR_ERROR, "%s", details);
+    LOG(ERROR) << details;
   }
 }
 
@@ -76,12 +83,12 @@ tsi_result DoSslWrite(SSL* ssl, unsigned char* unprotected_bytes,
   if (ssl_write_result < 0) {
     ssl_write_result = SSL_get_error(ssl, ssl_write_result);
     if (ssl_write_result == SSL_ERROR_WANT_READ) {
-      gpr_log(GPR_ERROR,
-              "Peer tried to renegotiate SSL connection. This is unsupported.");
+      LOG(ERROR)
+          << "Peer tried to renegotiate SSL connection. This is unsupported.";
       return TSI_UNIMPLEMENTED;
     } else {
-      gpr_log(GPR_ERROR, "SSL_write failed with error %s.",
-              SslErrorString(ssl_write_result));
+      LOG(ERROR) << "SSL_write failed with error "
+                 << SslErrorString(ssl_write_result);
       return TSI_INTERNAL_ERROR;
     }
   }
@@ -107,12 +114,12 @@ tsi_result DoSslRead(SSL* ssl, unsigned char* unprotected_bytes,
             "Peer tried to renegotiate SSL connection. This is unsupported.");
         return TSI_UNIMPLEMENTED;
       case SSL_ERROR_SSL:
-        gpr_log(GPR_ERROR, "Corruption detected.");
+        LOG(ERROR) << "Corruption detected.";
         LogSslErrorStack();
         return TSI_DATA_CORRUPTED;
       default:
-        gpr_log(GPR_ERROR, "SSL_read failed with error %s.",
-                SslErrorString(read_from_ssl));
+        LOG(ERROR) << "SSL_read failed with error "
+                   << SslErrorString(read_from_ssl);
         return TSI_PROTOCOL_FAILURE;
     }
   }
@@ -139,8 +146,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
     read_from_ssl = BIO_read(network_io, protected_output_frames,
                              static_cast<int>(*protected_output_frames_size));
     if (read_from_ssl < 0) {
-      gpr_log(GPR_ERROR,
-              "Could not read from BIO even though some data is pending");
+      LOG(ERROR) << "Could not read from BIO even though some data is pending";
       return TSI_INTERNAL_ERROR;
     }
     *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
@@ -166,7 +172,7 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
   read_from_ssl = BIO_read(network_io, protected_output_frames,
                            static_cast<int>(*protected_output_frames_size));
   if (read_from_ssl < 0) {
-    gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
+    LOG(ERROR) << "Could not read from BIO after SSL_write.";
     return TSI_INTERNAL_ERROR;
   }
   *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
@@ -200,7 +206,7 @@ tsi_result SslProtectorProtectFlush(size_t& buffer_offset,
   read_from_ssl = BIO_read(network_io, protected_output_frames,
                            static_cast<int>(*protected_output_frames_size));
   if (read_from_ssl <= 0) {
-    gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
+    LOG(ERROR) << "Could not read from BIO after SSL_write.";
     return TSI_INTERNAL_ERROR;
   }
   *protected_output_frames_size = static_cast<size_t>(read_from_ssl);
@@ -237,8 +243,8 @@ tsi_result SslProtectorUnprotect(const unsigned char* protected_frames_bytes,
   written_into_ssl = BIO_write(network_io, protected_frames_bytes,
                                static_cast<int>(*protected_frames_bytes_size));
   if (written_into_ssl < 0) {
-    gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d",
-            written_into_ssl);
+    LOG(ERROR) << "Sending protected frame to ssl failed with "
+               << written_into_ssl;
     return TSI_INTERNAL_ERROR;
   }
   *protected_frames_bytes_size = static_cast<size_t>(written_into_ssl);
@@ -260,16 +266,15 @@ bool VerifyCrlSignature(X509_CRL* crl, X509* issuer) {
   if (ikey == nullptr) {
     // Can't verify signature because we couldn't get the pubkey, fail the
     // check.
-    gpr_log(GPR_DEBUG, "Could not public key from certificate.");
+    VLOG(2) << "Could not public key from certificate.";
     EVP_PKEY_free(ikey);
     return false;
   }
   int ret = X509_CRL_verify(crl, ikey);
   if (ret < 0) {
-    gpr_log(GPR_DEBUG,
-            "There was an unexpected problem checking the CRL signature.");
+    VLOG(2) << "There was an unexpected problem checking the CRL signature.";
   } else if (ret == 0) {
-    gpr_log(GPR_DEBUG, "CRL failed verification.");
+    VLOG(2) << "CRL failed verification.";
   }
   EVP_PKEY_free(ikey);
   return ret == 1;
@@ -375,4 +380,55 @@ absl::StatusOr<std::string> AkidFromCrl(X509_CRL* crl) {
   return ret;
 }
 
+absl::StatusOr<std::vector<X509*>> ParsePemCertificateChain(
+    absl::string_view cert_chain_pem) {
+  if (cert_chain_pem.empty()) {
+    return absl::InvalidArgumentError("Cert chain PEM is empty.");
+  }
+  BIO* in = BIO_new_mem_buf(cert_chain_pem.data(), cert_chain_pem.size());
+  if (in == nullptr) {
+    return absl::InternalError("BIO_new_mem_buf failed.");
+  }
+  std::vector<X509*> certs;
+  while (X509* cert = PEM_read_bio_X509(in, /*x=*/nullptr, /*cb=*/nullptr,
+                                        /*u=*/nullptr)) {
+    certs.push_back(cert);
+  }
+
+  // We always have errors at this point because in the above loop we read until
+  // we reach the end of |cert_chain_pem|, which generates a "no start line"
+  // error. Therefore, this error is OK if we have successfully parsed some
+  // certificate data previously.
+  const int last_error = ERR_peek_last_error();
+  if (ERR_GET_LIB(last_error) != ERR_LIB_PEM ||
+      ERR_GET_REASON(last_error) != PEM_R_NO_START_LINE) {
+    for (X509* cert : certs) {
+      X509_free(cert);
+    }
+    BIO_free(in);
+    return absl::FailedPreconditionError("Invalid PEM.");
+  }
+  ERR_clear_error();
+  BIO_free(in);
+  if (certs.empty()) {
+    return absl::NotFoundError("No certificates found.");
+  }
+  return certs;
+}
+
+absl::StatusOr<EVP_PKEY*> ParsePemPrivateKey(
+    absl::string_view private_key_pem) {
+  BIO* in = BIO_new_mem_buf(private_key_pem.data(), private_key_pem.size());
+  if (in == nullptr) {
+    return absl::InvalidArgumentError("Private key PEM is empty.");
+  }
+  EVP_PKEY* pkey =
+      PEM_read_bio_PrivateKey(in, /*x=*/nullptr, /*cb=*/nullptr, /*u=*/nullptr);
+  BIO_free(in);
+  if (pkey == nullptr) {
+    return absl::NotFoundError("No private key found.");
+  }
+  return pkey;
+}
+
 }  // namespace grpc_core

data/src/core/tsi/ssl_transport_security_utils.h

@@ -19,6 +19,7 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_UTILS_H
 #define GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_UTILS_H
 
+#include <openssl/evp.h>
 #include <openssl/x509.h>
 
 #include "absl/status/status.h"
@@ -168,6 +169,16 @@ absl::StatusOr<std::string> AkidFromCertificate(X509* cert);
 // crl.
 // return: a std::string of the DER encoding of the AKID or a status on failure.
 absl::StatusOr<std::string> AkidFromCrl(X509_CRL* crl);
+
+// Returns a vector of X509 instances parsed from the given PEM-encoded
+// certificate chain. Caller takes ownership of the X509 pointers in the output
+// vector.
+absl::StatusOr<std::vector<X509*>> ParsePemCertificateChain(
+    absl::string_view cert_chain_pem);
+
+// Returns an EVP_PKEY instance parsed from the non-empty PEM private key block
+// in private_key_pem. Caller takes ownership of the EVP_PKEY pointer.
+absl::StatusOr<EVP_PKEY*> ParsePemPrivateKey(absl::string_view private_key_pem);
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_UTILS_H

data/src/core/tsi/transport_security.cc

@@ -25,10 +25,6 @@
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 
-// --- Tracing. ---
-
-grpc_core::TraceFlag tsi_tracing_enabled(false, "tsi");
-
 // --- tsi_result common implementation. ---
 
 const char* tsi_result_to_string(tsi_result result) {

data/src/core/tsi/transport_security.h

@@ -26,8 +26,6 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/tsi/transport_security_interface.h"
 
-extern grpc_core::TraceFlag tsi_tracing_enabled;
-
 // Base for tsi_frame_protector implementations.
 // See transport_security_interface.h for documentation.
 // All methods must be implemented.

data/src/core/tsi/transport_security_interface.h

@@ -96,10 +96,6 @@ typedef enum {
 const char* tsi_result_to_string(tsi_result result);
 const char* tsi_security_level_to_string(tsi_security_level security_level);
 
-// --- tsi tracing ---
-
-extern grpc_core::TraceFlag tsi_tracing_enabled;
-
 // -- tsi_zero_copy_grpc_protector object --
 
 // This object protects and unprotects grpc slice buffers with zero or minimized

data/src/core/{lib/gpr → util}/alloc.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_GPR_ALLOC_H
-#define GRPC_SRC_CORE_LIB_GPR_ALLOC_H
+#ifndef GRPC_SRC_CORE_UTIL_ALLOC_H
+#define GRPC_SRC_CORE_UTIL_ALLOC_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,4 +25,4 @@
 #define GPR_ROUND_UP_TO_ALIGNMENT_SIZE(x) \
   (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
 
-#endif  // GRPC_SRC_CORE_LIB_GPR_ALLOC_H
+#endif  // GRPC_SRC_CORE_UTIL_ALLOC_H

data/src/core/{lib/gpr → util}/android/log.cc

@@ -57,23 +57,4 @@ void gpr_log(const char* file, int line, gpr_log_severity severity,
   free(message);
 }
 
-void gpr_platform_log(gpr_log_func_args* args) {
-  const char* final_slash;
-  const char* display_file;
-  char* output = NULL;
-
-  final_slash = strrchr(args->file, '/');
-  if (final_slash == NULL)
-    display_file = args->file;
-  else
-    display_file = final_slash + 1;
-
-  asprintf(&output, "%s:%d] %s", display_file, args->line, args->message);
-
-  __android_log_write(severity_to_log_priority(args->severity), "GRPC", output);
-
-  // allocated by asprintf => use free, not gpr_free
-  free(output);
-}
-
 #endif  // GPR_ANDROID

data/src/core/{lib/gpr → util}/atm.cc

@@ -20,7 +20,7 @@
 
 #include <grpc/support/atm.h>
 
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/util/useful.h"
 
 gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta,
                                        gpr_atm min, gpr_atm max) {

data/src/core/{ext/gcp/metadata_query.cc → util/gcp_metadata_query.cc}

@@ -16,7 +16,9 @@
 //
 //
 
-#include "src/core/ext/gcp/metadata_query.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/gcp_metadata_query.h"
 
 #include <string.h>
 
@@ -24,6 +26,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
@@ -33,7 +36,6 @@
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -44,31 +46,29 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_metadata_query_trace(false, "metadata_query");
+constexpr const char GcpMetadataQuery::kZoneAttribute[];
+constexpr const char GcpMetadataQuery::kClusterNameAttribute[];
+constexpr const char GcpMetadataQuery::kRegionAttribute[];
+constexpr const char GcpMetadataQuery::kInstanceIdAttribute[];
+constexpr const char GcpMetadataQuery::kIPv6Attribute[];
 
-constexpr const char MetadataQuery::kZoneAttribute[];
-constexpr const char MetadataQuery::kClusterNameAttribute[];
-constexpr const char MetadataQuery::kRegionAttribute[];
-constexpr const char MetadataQuery::kInstanceIdAttribute[];
-constexpr const char MetadataQuery::kIPv6Attribute[];
-
-MetadataQuery::MetadataQuery(
+GcpMetadataQuery::GcpMetadataQuery(
     std::string attribute, grpc_polling_entity* pollent,
     absl::AnyInvocable<void(std::string /* attribute */,
                             absl::StatusOr<std::string> /* result */)>
         callback,
     Duration timeout)
-    : MetadataQuery("metadata.google.internal.", std::move(attribute), pollent,
-                    std::move(callback), timeout) {}
+    : GcpMetadataQuery("metadata.google.internal.", std::move(attribute),
+                       pollent, std::move(callback), timeout) {}
 
-MetadataQuery::MetadataQuery(
+GcpMetadataQuery::GcpMetadataQuery(
     std::string metadata_server_name, std::string attribute,
     grpc_polling_entity* pollent,
     absl::AnyInvocable<void(std::string /* attribute */,
                             absl::StatusOr<std::string> /* result */)>
         callback,
     Duration timeout)
-    : InternallyRefCounted<MetadataQuery>(nullptr, 2),
+    : InternallyRefCounted<GcpMetadataQuery>(nullptr, 2),
       attribute_(std::move(attribute)),
       callback_(std::move(callback)) {
   GRPC_CLOSURE_INIT(&on_done_, OnDone, this, nullptr);
@@ -89,20 +89,21 @@ MetadataQuery::MetadataQuery(
   http_request_->Start();
 }
 
-MetadataQuery::~MetadataQuery() { grpc_http_response_destroy(&response_); }
+GcpMetadataQuery::~GcpMetadataQuery() {
+  grpc_http_response_destroy(&response_);
+}
 
-void MetadataQuery::Orphan() {
+void GcpMetadataQuery::Orphan() {
   http_request_.reset();
   Unref();
 }
 
-void MetadataQuery::OnDone(void* arg, grpc_error_handle error) {
-  auto* self = static_cast<MetadataQuery*>(arg);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
-    gpr_log(GPR_INFO, "MetadataServer Query for %s: HTTP status: %d, error: %s",
-            self->attribute_.c_str(), self->response_.status,
-            StatusToString(error).c_str());
-  }
+void GcpMetadataQuery::OnDone(void* arg, grpc_error_handle error) {
+  auto* self = static_cast<GcpMetadataQuery*>(arg);
+  GRPC_TRACE_LOG(metadata_query, INFO)
+      << "MetadataServer Query for " << self->attribute_
+      << ": HTTP status: " << self->response_.status
+      << ", error: " << StatusToString(error);
   absl::StatusOr<std::string> result;
   if (!error.ok()) {
     result = absl::UnavailableError(absl::StrFormat(
@@ -119,9 +120,7 @@ void MetadataQuery::OnDone(void* arg, grpc_error_handle error) {
       result = absl::UnavailableError(
           absl::StrFormat("MetadataServer Could not parse zone: %s",
                           std::string(body).c_str()));
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
-        gpr_log(GPR_INFO, "%s", result.status().ToString().c_str());
-      }
+      GRPC_TRACE_LOG(metadata_query, INFO) << result.status();
     } else {
       result = std::string(body.substr(pos + 1));
     }

data/src/core/{ext/gcp/metadata_query.h → util/gcp_metadata_query.h}

@@ -14,29 +14,29 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
-#define GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+#ifndef GRPC_SRC_CORE_UTIL_GCP_METADATA_QUERY_H
+#define GRPC_SRC_CORE_UTIL_GCP_METADATA_QUERY_H
+
+#include <grpc/support/port_platform.h>
 
 #include <string>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/http/httpcli.h"
-#include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/util/http_client/httpcli.h"
+#include "src/core/util/http_client/parser.h"
 
 namespace grpc_core {
 
 // Fetches the value of an attribute from the MetadataServer on a GCP
 // environment.
-class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
+class GcpMetadataQuery : public InternallyRefCounted<GcpMetadataQuery> {
  public:
   static constexpr const char kZoneAttribute[] =
       "/computeMetadata/v1/instance/zone";
@@ -49,7 +49,7 @@ class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
   static constexpr const char kIPv6Attribute[] =
       "/computeMetadata/v1/instance/network-interfaces/0/ipv6s";
 
-  MetadataQuery(
+  GcpMetadataQuery(
       std::string attribute, grpc_polling_entity* pollent,
       absl::AnyInvocable<void(std::string /* attribute */,
                               absl::StatusOr<std::string> /* result */)>
@@ -58,7 +58,7 @@ class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
 
   // Alternative ctor allows overriding the metadata server address, mainly
   // to inject fakes in tests
-  MetadataQuery(
+  GcpMetadataQuery(
       std::string metadata_server_name, std::string attribute,
       grpc_polling_entity* pollent,
       absl::AnyInvocable<void(std::string /* attribute */,
@@ -66,7 +66,7 @@ class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
           callback,
       Duration timeout);
 
-  ~MetadataQuery() override;
+  ~GcpMetadataQuery() override;
 
   void Orphan() override;
 
@@ -84,4 +84,4 @@ class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+#endif  // GRPC_SRC_CORE_UTIL_GCP_METADATA_QUERY_H

data/src/core/{lib/http → util/http_client}/format_request.cc

@@ -16,7 +16,9 @@
 //
 //
 
-#include "src/core/lib/http/format_request.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/http_client/format_request.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -31,9 +33,8 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/port_platform.h>
 
-#include "src/core/lib/http/httpcli.h"
+#include "src/core/util/http_client/httpcli.h"
 
 static void fill_common_header(const grpc_http_request* request,
                                const char* host, const char* path,

data/src/core/{lib/http → util/http_client}/format_request.h

@@ -16,13 +16,14 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_HTTP_FORMAT_REQUEST_H
-#define GRPC_SRC_CORE_LIB_HTTP_FORMAT_REQUEST_H
+#ifndef GRPC_SRC_CORE_UTIL_HTTP_CLIENT_FORMAT_REQUEST_H
+#define GRPC_SRC_CORE_UTIL_HTTP_CLIENT_FORMAT_REQUEST_H
 
-#include <grpc/slice.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/http/parser.h"
+#include <grpc/slice.h>
+
+#include "src/core/util/http_client/parser.h"
 
 grpc_slice grpc_httpcli_format_get_request(const grpc_http_request* request,
                                            const char* host, const char* path);
@@ -34,4 +35,4 @@ grpc_slice grpc_httpcli_format_connect_request(const grpc_http_request* request,
                                                const char* host,
                                                const char* path);
 
-#endif  // GRPC_SRC_CORE_LIB_HTTP_FORMAT_REQUEST_H
+#endif  // GRPC_SRC_CORE_UTIL_HTTP_CLIENT_FORMAT_REQUEST_H

data/src/core/{lib/http → util/http_client}/httpcli.cc

@@ -16,7 +16,9 @@
 //
 //
 
-#include "src/core/lib/http/httpcli.h"
+#include <grpc/support/port_platform.h>
+
+#include "src/core/util/http_client/httpcli.h"
 
 #include <limits.h>
 
@@ -32,7 +34,6 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/handshaker/tcp_connect/tcp_connect_handshaker.h"
@@ -41,8 +42,6 @@
 #include "src/core/lib/channel/channel_args_preconditioning.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/http/format_request.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/pollset_set.h"
@@ -52,6 +51,8 @@
 #include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/http_client/format_request.h"
+#include "src/core/util/http_client/parser.h"
 
 namespace grpc_core {
 
@@ -231,7 +232,8 @@ void HttpRequest::Orphan() {
           GRPC_ERROR_CREATE("HTTP request cancelled during handshake"));
     }
     if (own_endpoint_ && ep_ != nullptr) {
-      grpc_endpoint_shutdown(ep_, GRPC_ERROR_CREATE("HTTP request cancelled"));
+      grpc_endpoint_destroy(ep_);
+      ep_ = nullptr;
     }
   }
   Unref();
@@ -243,11 +245,8 @@ void HttpRequest::AppendError(grpc_error_handle error) {
   }
   const grpc_resolved_address* addr = &addresses_[next_address_ - 1];
   auto addr_text = grpc_sockaddr_to_uri(addr);
-  overall_error_ = grpc_error_add_child(
-      overall_error_,
-      grpc_error_set_str(
-          error, StatusStrProperty::kTargetAddress,
-          addr_text.ok() ? addr_text.value() : addr_text.status().ToString()));
+  if (addr_text.ok()) error = AddMessagePrefix(*addr_text, std::move(error));
+  overall_error_ = grpc_error_add_child(overall_error_, std::move(error));
 }
 
 void HttpRequest::OnReadInternal(grpc_error_handle error) {

data/src/core/{lib/http → util/http_client}/httpcli.h

@@ -16,8 +16,10 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_H
-#define GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_H
+#ifndef GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_H
+#define GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_H
+
+#include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 
@@ -32,7 +34,6 @@
 
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
-#include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -40,7 +41,6 @@
 #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"
@@ -52,6 +52,7 @@
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/util/http_client/parser.h"
 
 // User agent this library reports
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
@@ -264,4 +265,4 @@ class HttpRequest : public InternallyRefCounted<HttpRequest> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_HTTP_HTTPCLI_H
+#endif  // GRPC_SRC_CORE_UTIL_HTTP_CLIENT_HTTPCLI_H