grpc 1.63.0 → 1.65.2

data/src/core/tsi/ssl_transport_security.h

@@ -19,8 +19,6 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_H
 #define GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <memory>
 
 #include <openssl/x509.h>
@@ -29,6 +27,7 @@
 
 #include <grpc/grpc_crl_provider.h>
 #include <grpc/grpc_security_constants.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/tsi/ssl/key_logging/ssl_key_logging.h"
 #include "src/core/tsi/ssl_transport_security_utils.h"

data/src/core/tsi/ssl_transport_security_utils.cc

@@ -16,18 +16,26 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #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"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/tsi/transport_security_interface.h"
 
 namespace grpc_core {
@@ -62,25 +70,25 @@ 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;
   }
 }
 
 tsi_result DoSslWrite(SSL* ssl, unsigned char* unprotected_bytes,
                       size_t unprotected_bytes_size) {
-  GPR_ASSERT(unprotected_bytes_size <= INT_MAX);
+  CHECK_LE(unprotected_bytes_size, static_cast<size_t>(INT_MAX));
   ERR_clear_error();
   int ssl_write_result = SSL_write(ssl, unprotected_bytes,
                                    static_cast<int>(unprotected_bytes_size));
   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;
     }
   }
@@ -89,7 +97,7 @@ tsi_result DoSslWrite(SSL* ssl, unsigned char* unprotected_bytes,
 
 tsi_result DoSslRead(SSL* ssl, unsigned char* unprotected_bytes,
                      size_t* unprotected_bytes_size) {
-  GPR_ASSERT(*unprotected_bytes_size <= INT_MAX);
+  CHECK_LE(*unprotected_bytes_size, static_cast<size_t>(INT_MAX));
   ERR_clear_error();
   int read_from_ssl = SSL_read(ssl, unprotected_bytes,
                                static_cast<int>(*unprotected_bytes_size));
@@ -106,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;
     }
   }
@@ -134,12 +142,11 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
   int pending_in_ssl = static_cast<int>(BIO_pending(network_io));
   if (pending_in_ssl > 0) {
     *unprotected_bytes_size = 0;
-    GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
+    CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
     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);
@@ -161,11 +168,11 @@ tsi_result SslProtectorProtect(const unsigned char* unprotected_bytes,
   result = DoSslWrite(ssl, buffer, buffer_size);
   if (result != TSI_OK) return result;
 
-  GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
+  CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
   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);
@@ -191,20 +198,20 @@ tsi_result SslProtectorProtectFlush(size_t& buffer_offset,
   }
 
   pending = static_cast<int>(BIO_pending(network_io));
-  GPR_ASSERT(pending >= 0);
+  CHECK_GE(pending, 0);
   *still_pending_size = static_cast<size_t>(pending);
   if (*still_pending_size == 0) return TSI_OK;
 
-  GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
+  CHECK_LE(*protected_output_frames_size, static_cast<size_t>(INT_MAX));
   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);
   pending = static_cast<int>(BIO_pending(network_io));
-  GPR_ASSERT(pending >= 0);
+  CHECK_GE(pending, 0);
   *still_pending_size = static_cast<size_t>(pending);
   return TSI_OK;
 }
@@ -232,12 +239,12 @@ tsi_result SslProtectorUnprotect(const unsigned char* protected_frames_bytes,
   *unprotected_bytes_size = output_bytes_size - output_bytes_offset;
 
   // Then, try to write some data to ssl.
-  GPR_ASSERT(*protected_frames_bytes_size <= INT_MAX);
+  CHECK_LE(*protected_frames_bytes_size, static_cast<size_t>(INT_MAX));
   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);
@@ -259,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;
@@ -374,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,8 +19,7 @@
 #ifndef GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_UTILS_H
 #define GRPC_SRC_CORE_TSI_SSL_TRANSPORT_SECURITY_UTILS_H
 
-#include <grpc/support/port_platform.h>
-
+#include <openssl/evp.h>
 #include <openssl/x509.h>
 
 #include "absl/status/status.h"
@@ -28,6 +27,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc_security_constants.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/tsi/ssl/key_logging/ssl_key_logging.h"
 #include "src/core/tsi/transport_security_interface.h"
@@ -169,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/ssl_types.h

@@ -27,10 +27,10 @@
 //                      function
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <openssl/ssl.h>
 
+#include <grpc/support/port_platform.h>
+
 #ifdef OPENSSL_IS_BORINGSSL
 #define TSI_INT_AS_SIZE(x) ((size_t)(x))
 #define TSI_SIZE_AS_SIZE(x) (x)

data/src/core/tsi/transport_security.cc

@@ -16,20 +16,15 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/transport_security.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <grpc/support/alloc.h>
+#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

@@ -19,15 +19,13 @@
 #ifndef GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_H
 #define GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdbool.h>
 
+#include <grpc/support/port_platform.h>
+
 #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_grpc.cc

@@ -16,10 +16,10 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/tsi/transport_security_grpc.h"
 
+#include <grpc/support/port_platform.h>
+
 // This method creates a tsi_zero_copy_grpc_protector object.
 tsi_result tsi_handshaker_result_create_zero_copy_grpc_protector(
     const tsi_handshaker_result* self, size_t* max_output_protected_frame_size,

data/src/core/tsi/transport_security_grpc.h

@@ -19,9 +19,8 @@
 #ifndef GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H
 #define GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_GRPC_H
 
-#include <grpc/support/port_platform.h>
-
 #include <grpc/slice_buffer.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/tsi/transport_security.h"
 

data/src/core/tsi/transport_security_interface.h

@@ -19,13 +19,13 @@
 #ifndef GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_INTERFACE_H
 #define GRPC_SRC_CORE_TSI_TRANSPORT_SECURITY_INTERFACE_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <string>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/debug/trace.h"
 
 // --- tsi result ---
@@ -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.cc

@@ -21,6 +21,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
@@ -59,7 +61,7 @@ void* gpr_realloc(void* p, size_t size) {
 }
 
 void* gpr_malloc_aligned(size_t size, size_t alignment) {
-  GPR_ASSERT(((alignment - 1) & alignment) == 0);  // Must be power of 2.
+  CHECK_EQ(((alignment - 1) & alignment), 0u);  // Must be power of 2.
   size_t extra = alignment - 1 + sizeof(void*);
   void* p = gpr_malloc(size + extra);
   void** ret = reinterpret_cast<void**>(

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}

@@ -18,18 +18,21 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/gcp/metadata_query.h"
+#include "src/core/util/gcp_metadata_query.h"
 
 #include <string.h>
 
 #include <memory>
 #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"
 #include "absl/strings/string_view.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/support/log.h>
@@ -43,37 +46,35 @@
 
 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);
   auto uri = URI::Create("http", std::move(metadata_server_name), attribute_,
                          {} /* query params */, "" /* fragment */);
-  GPR_ASSERT(uri.ok());  // params are hardcoded
+  CHECK(uri.ok());  // params are hardcoded
   grpc_http_request request;
   memset(&request, 0, sizeof(grpc_http_request));
   grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
@@ -88,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(
@@ -118,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,8 +14,8 @@
 // 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>
 
@@ -26,17 +26,17 @@
 
 #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

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/http/format_request.h"
+#include "src/core/util/http_client/format_request.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -34,7 +34,7 @@
 
 #include <grpc/slice.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,