grpc 1.34.0 → 1.37.0

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <ares.h>
+
 #include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/polling_entity.h"
@@ -93,5 +95,8 @@ bool grpc_ares_query_ipv6();
 void grpc_cares_wrapper_address_sorting_sort(
     const grpc_ares_request* request, grpc_core::ServerAddressList* addresses);
 
+/* Exposed in this header for C-core tests only */
+extern void (*grpc_ares_test_only_inject_config)(ares_channel channel);
+
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H \
         */

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -74,9 +74,11 @@ class NativeDnsResolver : public Resolver {
   void OnResolvedLocked(grpc_error* error);
 
   /// name to resolve
-  char* name_to_resolve_ = nullptr;
+  std::string name_to_resolve_;
   /// channel args
   grpc_channel_args* channel_args_ = nullptr;
+  std::shared_ptr<WorkSerializer> work_serializer_;
+  std::unique_ptr<ResultHandler> result_handler_;
   /// pollset_set to drive the name resolution process
   grpc_pollset_set* interested_parties_ = nullptr;
   /// are we shutting down?
@@ -99,7 +101,14 @@ class NativeDnsResolver : public Resolver {
 };
 
 NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
-    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
+    : name_to_resolve_(absl::StripPrefix(args.uri.path(), "/")),
+      channel_args_(grpc_channel_args_copy(args.args)),
+      work_serializer_(std::move(args.work_serializer)),
+      result_handler_(std::move(args.result_handler)),
+      interested_parties_(grpc_pollset_set_create()),
+      min_time_between_resolutions_(grpc_channel_args_find_integer(
+          channel_args_, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS,
+          {1000 * 30, 0, INT_MAX})),
       backoff_(
           BackOff::Options()
               .set_initial_backoff(GRPC_DNS_INITIAL_CONNECT_BACKOFF_SECONDS *
@@ -107,15 +116,6 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
               .set_multiplier(GRPC_DNS_RECONNECT_BACKOFF_MULTIPLIER)
               .set_jitter(GRPC_DNS_RECONNECT_JITTER)
               .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000)) {
-  char* path = args.uri->path;
-  if (path[0] == '/') ++path;
-  name_to_resolve_ = gpr_strdup(path);
-  channel_args_ = grpc_channel_args_copy(args.args);
-  const grpc_arg* arg = grpc_channel_args_find(
-      args.args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
-  min_time_between_resolutions_ =
-      grpc_channel_arg_get_integer(arg, {1000 * 30, 0, INT_MAX});
-  interested_parties_ = grpc_pollset_set_create();
   if (args.pollset_set != nullptr) {
     grpc_pollset_set_add_pollset_set(interested_parties_, args.pollset_set);
   }
@@ -124,7 +124,6 @@ NativeDnsResolver::NativeDnsResolver(ResolverArgs args)
 NativeDnsResolver::~NativeDnsResolver() {
   grpc_channel_args_destroy(channel_args_);
   grpc_pollset_set_destroy(interested_parties_);
-  gpr_free(name_to_resolve_);
 }
 
 void NativeDnsResolver::StartLocked() { MaybeStartResolvingLocked(); }
@@ -152,8 +151,8 @@ void NativeDnsResolver::ShutdownLocked() {
 void NativeDnsResolver::OnNextResolution(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   GRPC_ERROR_REF(error);  // ref owned by lambda
-  r->work_serializer()->Run([r, error]() { r->OnNextResolutionLocked(error); },
-                            DEBUG_LOCATION);
+  r->work_serializer_->Run([r, error]() { r->OnNextResolutionLocked(error); },
+                           DEBUG_LOCATION);
 }
 
 void NativeDnsResolver::OnNextResolutionLocked(grpc_error* error) {
@@ -168,8 +167,8 @@ void NativeDnsResolver::OnNextResolutionLocked(grpc_error* error) {
 void NativeDnsResolver::OnResolved(void* arg, grpc_error* error) {
   NativeDnsResolver* r = static_cast<NativeDnsResolver*>(arg);
   GRPC_ERROR_REF(error);  // owned by lambda
-  r->work_serializer()->Run([r, error]() { r->OnResolvedLocked(error); },
-                            DEBUG_LOCATION);
+  r->work_serializer_->Run([r, error]() { r->OnResolvedLocked(error); },
+                           DEBUG_LOCATION);
 }
 
 void NativeDnsResolver::OnResolvedLocked(grpc_error* error) {
@@ -189,7 +188,7 @@ void NativeDnsResolver::OnResolvedLocked(grpc_error* error) {
     }
     grpc_resolved_addresses_destroy(addresses_);
     result.args = grpc_channel_args_copy(channel_args_);
-    result_handler()->ReturnResult(std::move(result));
+    result_handler_->ReturnResult(std::move(result));
     // Reset backoff state so that we start from the beginning when the
     // next request gets triggered.
     backoff_.Reset();
@@ -199,7 +198,7 @@ void NativeDnsResolver::OnResolvedLocked(grpc_error* error) {
     // Return transient error.
     std::string error_message =
         absl::StrCat("DNS resolution failed for service: ", name_to_resolve_);
-    result_handler()->ReturnError(grpc_error_set_int(
+    result_handler_->ReturnError(grpc_error_set_int(
         GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(error_message.c_str(),
                                                          &error, 1),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
@@ -269,8 +268,8 @@ void NativeDnsResolver::StartResolvingLocked() {
   addresses_ = nullptr;
   GRPC_CLOSURE_INIT(&on_resolved_, NativeDnsResolver::OnResolved, this,
                     grpc_schedule_on_exec_ctx);
-  grpc_resolve_address(name_to_resolve_, kDefaultPort, interested_parties_,
-                       &on_resolved_, &addresses_);
+  grpc_resolve_address(name_to_resolve_.c_str(), kDefaultPort,
+                       interested_parties_, &on_resolved_, &addresses_);
   last_resolution_timestamp_ = grpc_core::ExecCtx::Get()->Now();
 }
 
@@ -280,8 +279,8 @@ void NativeDnsResolver::StartResolvingLocked() {
 
 class NativeDnsResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* uri) const override {
-    if (GPR_UNLIKELY(0 != strcmp(uri->authority, ""))) {
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
       gpr_log(GPR_ERROR, "authority based dns uri's not supported");
       return false;
     }

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -69,6 +69,8 @@ class FakeResolver : public Resolver {
 
   // passed-in parameters
   grpc_channel_args* channel_args_ = nullptr;
+  std::shared_ptr<WorkSerializer> work_serializer_;
+  std::unique_ptr<ResultHandler> result_handler_;
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
   // If has_next_result_ is true, next_result_ is the next resolution result
   // to be returned.
@@ -89,7 +91,8 @@ class FakeResolver : public Resolver {
 };
 
 FakeResolver::FakeResolver(ResolverArgs args)
-    : Resolver(std::move(args.work_serializer), std::move(args.result_handler)),
+    : work_serializer_(std::move(args.work_serializer)),
+      result_handler_(std::move(args.result_handler)),
       response_generator_(
           FakeResolverResponseGenerator::GetFromArgs(args.args)) {
   // Channels sharing the same subchannels may have different resolver response
@@ -121,8 +124,8 @@ void FakeResolver::RequestReresolutionLocked() {
     if (!reresolution_closure_pending_) {
       reresolution_closure_pending_ = true;
       Ref().release();  // ref held by closure
-      work_serializer()->Run([this]() { ReturnReresolutionResult(); },
-                             DEBUG_LOCATION);
+      work_serializer_->Run([this]() { ReturnReresolutionResult(); },
+                            DEBUG_LOCATION);
     }
   }
 }
@@ -140,7 +143,7 @@ void FakeResolver::MaybeSendResultLocked() {
   if (return_failure_) {
     // TODO(roth): Change resolver result generator to be able to inject
     // the error to be returned.
-    result_handler()->ReturnError(grpc_error_set_int(
+    result_handler_->ReturnError(grpc_error_set_int(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Resolver transient failure"),
         GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE));
     return_failure_ = false;
@@ -155,7 +158,7 @@ void FakeResolver::MaybeSendResultLocked() {
     // name, only the one in next_results_ will be kept since next_results_ is
     // before channel_args_.
     result.args = grpc_channel_args_union(next_result_.args, channel_args_);
-    result_handler()->ReturnResult(std::move(result));
+    result_handler_->ReturnResult(std::move(result));
     has_next_result_ = false;
   }
 }
@@ -236,8 +239,8 @@ void FakeResolverResponseGenerator::SetResponse(Resolver::Result result) {
   }
   FakeResolverResponseSetter* arg =
       new FakeResolverResponseSetter(resolver, std::move(result));
-  resolver->work_serializer()->Run([arg]() { arg->SetResponseLocked(); },
-                                   DEBUG_LOCATION);
+  resolver->work_serializer_->Run([arg]() { arg->SetResponseLocked(); },
+                                  DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetReresolutionResponse(
@@ -250,7 +253,7 @@ void FakeResolverResponseGenerator::SetReresolutionResponse(
   }
   FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
       resolver, std::move(result), true /* has_result */);
-  resolver->work_serializer()->Run(
+  resolver->work_serializer_->Run(
       [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
 }
 
@@ -263,7 +266,7 @@ void FakeResolverResponseGenerator::UnsetReresolutionResponse() {
   }
   FakeResolverResponseSetter* arg =
       new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer()->Run(
+  resolver->work_serializer_->Run(
       [arg]() { arg->SetReresolutionResponseLocked(); }, DEBUG_LOCATION);
 }
 
@@ -276,8 +279,8 @@ void FakeResolverResponseGenerator::SetFailure() {
   }
   FakeResolverResponseSetter* arg =
       new FakeResolverResponseSetter(resolver, Resolver::Result());
-  resolver->work_serializer()->Run([arg]() { arg->SetFailureLocked(); },
-                                   DEBUG_LOCATION);
+  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
+                                  DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetFailureOnReresolution() {
@@ -290,8 +293,8 @@ void FakeResolverResponseGenerator::SetFailureOnReresolution() {
   FakeResolverResponseSetter* arg = new FakeResolverResponseSetter(
       resolver, Resolver::Result(), false /* has_result */,
       false /* immediate */);
-  resolver->work_serializer()->Run([arg]() { arg->SetFailureLocked(); },
-                                   DEBUG_LOCATION);
+  resolver->work_serializer_->Run([arg]() { arg->SetFailureLocked(); },
+                                  DEBUG_LOCATION);
 }
 
 void FakeResolverResponseGenerator::SetFakeResolver(
@@ -302,8 +305,8 @@ void FakeResolverResponseGenerator::SetFakeResolver(
   if (has_result_) {
     FakeResolverResponseSetter* arg =
         new FakeResolverResponseSetter(resolver_, std::move(result_));
-    resolver_->work_serializer()->Run([arg]() { arg->SetResponseLocked(); },
-                                      DEBUG_LOCATION);
+    resolver_->work_serializer_->Run([arg]() { arg->SetResponseLocked(); },
+                                     DEBUG_LOCATION);
     has_result_ = false;
   }
 }
@@ -339,7 +342,7 @@ grpc_arg FakeResolverResponseGenerator::MakeChannelArg(
     FakeResolverResponseGenerator* generator) {
   grpc_arg arg;
   arg.type = GRPC_ARG_POINTER;
-  arg.key = (char*)GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR;
+  arg.key = const_cast<char*>(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR);
   arg.value.pointer.p = generator;
   arg.value.pointer.vtable = &response_generator_arg_vtable;
   return arg;
@@ -362,7 +365,7 @@ namespace {
 
 class FakeResolverFactory : public ResolverFactory {
  public:
-  bool IsValidUri(const grpc_uri* /*uri*/) const override { return true; }
+  bool IsValidUri(const URI& /*uri*/) const override { return true; }
 
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     return MakeOrphanable<FakeResolver>(std::move(args));

data/src/core/ext/filters/client_channel/resolver/google_c2p/google_c2p_resolver.cc

@@ -0,0 +1,377 @@
+//
+// Copyright 2021 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/resolver_registry.h"
+#include "src/core/ext/xds/xds_client.h"
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/http/httpcli.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
+
+namespace grpc_core {
+
+namespace {
+
+class GoogleCloud2ProdResolver : public Resolver {
+ public:
+  explicit GoogleCloud2ProdResolver(ResolverArgs args);
+
+  void StartLocked() override;
+  void RequestReresolutionLocked() override;
+  void ResetBackoffLocked() override;
+  void ShutdownLocked() override;
+
+ private:
+  // Represents an HTTP request to the metadata server.
+  class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
+   public:
+    MetadataQuery(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
+                  const char* path, grpc_polling_entity* pollent);
+    ~MetadataQuery() override;
+
+    void Orphan() override;
+
+   private:
+    static void OnHttpRequestDone(void* arg, grpc_error* error);
+
+    // Calls OnDone() if not already called.  Releases a ref.
+    void MaybeCallOnDone(grpc_error* error);
+
+    // If error is not GRPC_ERROR_NONE, then it's not safe to look at response.
+    virtual void OnDone(GoogleCloud2ProdResolver* resolver,
+                        const grpc_http_response* response,
+                        grpc_error* error) = 0;
+
+    RefCountedPtr<GoogleCloud2ProdResolver> resolver_;
+    grpc_httpcli_context context_;
+    grpc_httpcli_response response_;
+    grpc_closure on_done_;
+    Atomic<bool> on_done_called_{false};
+  };
+
+  // A metadata server query to get the zone.
+  class ZoneQuery : public MetadataQuery {
+   public:
+    ZoneQuery(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
+              grpc_polling_entity* pollent);
+
+   private:
+    void OnDone(GoogleCloud2ProdResolver* resolver,
+                const grpc_http_response* response, grpc_error* error) override;
+  };
+
+  // A metadata server query to get the IPv6 address.
+  class IPv6Query : public MetadataQuery {
+   public:
+    IPv6Query(RefCountedPtr<GoogleCloud2ProdResolver> resolver,
+              grpc_polling_entity* pollent);
+
+   private:
+    void OnDone(GoogleCloud2ProdResolver* resolver,
+                const grpc_http_response* response, grpc_error* error) override;
+  };
+
+  void ZoneQueryDone(std::string zone);
+  void IPv6QueryDone(bool ipv6_supported);
+  void StartXdsResolver();
+
+  std::shared_ptr<WorkSerializer> work_serializer_;
+  grpc_polling_entity pollent_;
+  bool using_dns_ = false;
+  OrphanablePtr<Resolver> child_resolver_;
+
+  OrphanablePtr<ZoneQuery> zone_query_;
+  absl::optional<std::string> zone_;
+
+  OrphanablePtr<IPv6Query> ipv6_query_;
+  absl::optional<bool> supports_ipv6_;
+};
+
+//
+// GoogleCloud2ProdResolver::MetadataQuery
+//
+
+GoogleCloud2ProdResolver::MetadataQuery::MetadataQuery(
+    RefCountedPtr<GoogleCloud2ProdResolver> resolver, const char* path,
+    grpc_polling_entity* pollent)
+    : resolver_(std::move(resolver)) {
+  grpc_httpcli_context_init(&context_);
+  // Start HTTP request.
+  GRPC_CLOSURE_INIT(&on_done_, OnHttpRequestDone, this, nullptr);
+  Ref().release();  // Ref held by callback.
+  grpc_httpcli_request request;
+  memset(&request, 0, sizeof(grpc_httpcli_request));
+  grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
+                             const_cast<char*>("Google")};
+  request.host = const_cast<char*>("metadata.google.internal");
+  request.http.path = const_cast<char*>(path);
+  request.http.hdr_count = 1;
+  request.http.hdrs = &header;
+  grpc_resource_quota* resource_quota =
+      grpc_resource_quota_create("c2p_resolver");
+  grpc_httpcli_get(&context_, pollent, resource_quota, &request,
+                   ExecCtx::Get()->Now() + 10000,  // 10s timeout
+                   &on_done_, &response_);
+  grpc_resource_quota_unref_internal(resource_quota);
+}
+
+GoogleCloud2ProdResolver::MetadataQuery::~MetadataQuery() {
+  grpc_httpcli_context_destroy(&context_);
+  grpc_http_response_destroy(&response_);
+}
+
+void GoogleCloud2ProdResolver::MetadataQuery::Orphan() {
+  // TODO(roth): Once the HTTP client library supports cancellation,
+  // use that here.
+  MaybeCallOnDone(GRPC_ERROR_CANCELLED);
+}
+
+void GoogleCloud2ProdResolver::MetadataQuery::OnHttpRequestDone(
+    void* arg, grpc_error* error) {
+  auto* self = static_cast<MetadataQuery*>(arg);
+  self->MaybeCallOnDone(GRPC_ERROR_REF(error));
+}
+
+void GoogleCloud2ProdResolver::MetadataQuery::MaybeCallOnDone(
+    grpc_error* error) {
+  bool expected = false;
+  if (!on_done_called_.CompareExchangeStrong(
+          &expected, true, MemoryOrder::RELAXED, MemoryOrder::RELAXED)) {
+    // We've already called OnDone(), so just clean up.
+    GRPC_ERROR_UNREF(error);
+    Unref();
+    return;
+  }
+  // Hop back into WorkSerializer to call OnDone().
+  // Note: We implicitly pass our ref to the callback here.
+  resolver_->work_serializer_->Run(
+      [this, error]() {
+        OnDone(resolver_.get(), &response_, error);
+        Unref();
+      },
+      DEBUG_LOCATION);
+}
+
+//
+// GoogleCloud2ProdResolver::ZoneQuery
+//
+
+GoogleCloud2ProdResolver::ZoneQuery::ZoneQuery(
+    RefCountedPtr<GoogleCloud2ProdResolver> resolver,
+    grpc_polling_entity* pollent)
+    : MetadataQuery(std::move(resolver), "/computeMetadata/v1/instance/zone",
+                    pollent) {}
+
+void GoogleCloud2ProdResolver::ZoneQuery::OnDone(
+    GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
+    grpc_error* error) {
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "error fetching zone from metadata server: %s",
+            grpc_error_string(error));
+  }
+  std::string zone;
+  if (error == GRPC_ERROR_NONE && response->status == 200) {
+    absl::string_view body(response->body, response->body_length);
+    size_t i = body.find_last_of('/');
+    if (i == body.npos) {
+      gpr_log(GPR_ERROR, "could not parse zone from metadata server: %s",
+              std::string(body).c_str());
+    } else {
+      zone = std::string(body.substr(i));
+    }
+  }
+  resolver->ZoneQueryDone(std::move(zone));
+  GRPC_ERROR_UNREF(error);
+}
+
+//
+// GoogleCloud2ProdResolver::IPv6Query
+//
+
+GoogleCloud2ProdResolver::IPv6Query::IPv6Query(
+    RefCountedPtr<GoogleCloud2ProdResolver> resolver,
+    grpc_polling_entity* pollent)
+    : MetadataQuery(std::move(resolver),
+                    "/computeMetadata/v1/instance/network-interfaces/0/ipv6s",
+                    pollent) {}
+
+void GoogleCloud2ProdResolver::IPv6Query::OnDone(
+    GoogleCloud2ProdResolver* resolver, const grpc_http_response* response,
+    grpc_error* error) {
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "error fetching IPv6 address from metadata server: %s",
+            grpc_error_string(error));
+  }
+  resolver->IPv6QueryDone(error == GRPC_ERROR_NONE && response->status == 200);
+  GRPC_ERROR_UNREF(error);
+}
+
+//
+// GoogleCloud2ProdResolver
+//
+
+GoogleCloud2ProdResolver::GoogleCloud2ProdResolver(ResolverArgs args)
+    : work_serializer_(std::move(args.work_serializer)),
+      pollent_(grpc_polling_entity_create_from_pollset_set(args.pollset_set)) {
+  absl::string_view name_to_resolve = absl::StripPrefix(args.uri.path(), "/");
+  // If we're not running on GCP, we can't use DirectPath, so delegate
+  // to the DNS resolver.
+  if (!grpc_alts_is_running_on_gcp() ||
+      // If the client is already using xDS, we can't use it here, because
+      // they may be talking to a completely different xDS server than we
+      // want to.
+      // TODO(roth): When we implement xDS federation, remove this constraint.
+      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP")) != nullptr ||
+      UniquePtr<char>(gpr_getenv("GRPC_XDS_BOOTSTRAP_CONFIG")) != nullptr) {
+    using_dns_ = true;
+    child_resolver_ = ResolverRegistry::CreateResolver(
+        absl::StrCat("dns:", name_to_resolve).c_str(), args.args,
+        args.pollset_set, work_serializer_, std::move(args.result_handler));
+    GPR_ASSERT(child_resolver_ != nullptr);
+    return;
+  }
+  // Create xds resolver.
+  child_resolver_ = ResolverRegistry::CreateResolver(
+      absl::StrCat("xds:", name_to_resolve).c_str(), args.args,
+      args.pollset_set, work_serializer_, std::move(args.result_handler));
+  GPR_ASSERT(child_resolver_ != nullptr);
+}
+
+void GoogleCloud2ProdResolver::StartLocked() {
+  if (using_dns_) {
+    child_resolver_->StartLocked();
+    return;
+  }
+  // Using xDS.  Start metadata server queries.
+  zone_query_ = MakeOrphanable<ZoneQuery>(Ref(), &pollent_);
+  ipv6_query_ = MakeOrphanable<IPv6Query>(Ref(), &pollent_);
+}
+
+void GoogleCloud2ProdResolver::RequestReresolutionLocked() {
+  if (child_resolver_ != nullptr) {
+    child_resolver_->RequestReresolutionLocked();
+  }
+}
+
+void GoogleCloud2ProdResolver::ResetBackoffLocked() {
+  if (child_resolver_ != nullptr) {
+    child_resolver_->ResetBackoffLocked();
+  }
+}
+
+void GoogleCloud2ProdResolver::ShutdownLocked() {
+  zone_query_.reset();
+  ipv6_query_.reset();
+  child_resolver_.reset();
+}
+
+void GoogleCloud2ProdResolver::ZoneQueryDone(std::string zone) {
+  zone_query_.reset();
+  zone_ = std::move(zone);
+  if (supports_ipv6_.has_value()) StartXdsResolver();
+}
+
+void GoogleCloud2ProdResolver::IPv6QueryDone(bool ipv6_supported) {
+  ipv6_query_.reset();
+  supports_ipv6_ = ipv6_supported;
+  if (zone_.has_value()) StartXdsResolver();
+}
+
+void GoogleCloud2ProdResolver::StartXdsResolver() {
+  // Construct bootstrap JSON.
+  Json::Object node = {
+      {"id", "C2P"},
+  };
+  if (!zone_->empty()) {
+    node["locality"] = Json::Object{
+        {"zone", *zone_},
+    };
+  };
+  if (*supports_ipv6_) {
+    node["metadata"] = Json::Object{
+        {"TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true},
+    };
+  }
+  // Allow the TD server uri to be overridden for testing purposes.
+  UniquePtr<char> override_server(
+      gpr_getenv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI"));
+  const char* server_uri =
+      override_server != nullptr && strlen(override_server.get()) > 0
+          ? override_server.get()
+          : "directpath-trafficdirector.googleapis.com";
+  Json bootstrap = Json::Object{
+      {"xds_servers",
+       Json::Array{
+           Json::Object{
+               {"server_uri", server_uri},
+               {"channel_creds",
+                Json::Array{
+                    Json::Object{
+                        {"type", "google_default"},
+                    },
+                }},
+               {"server_features", Json::Array{"xds_v3"}},
+           },
+       }},
+      {"node", std::move(node)},
+  };
+  // Inject bootstrap JSON as fallback config.
+  internal::SetXdsFallbackBootstrapConfig(bootstrap.Dump().c_str());
+  // Now start xDS resolver.
+  child_resolver_->StartLocked();
+}
+
+//
+// Factory
+//
+
+class GoogleCloud2ProdResolverFactory : public ResolverFactory {
+ public:
+  bool IsValidUri(const URI& uri) const override {
+    if (GPR_UNLIKELY(!uri.authority().empty())) {
+      gpr_log(GPR_ERROR, "google-c2p URI scheme does not support authorities");
+      return false;
+    }
+    return true;
+  }
+
+  OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
+    if (!IsValidUri(args.uri)) return nullptr;
+    return MakeOrphanable<GoogleCloud2ProdResolver>(std::move(args));
+  }
+
+  const char* scheme() const override { return "google-c2p"; }
+};
+
+}  // namespace
+
+void GoogleCloud2ProdResolverInit() {
+  // TODO(roth): Remove env var protection once this code is proven stable.
+  UniquePtr<char> value(gpr_getenv("GRPC_EXPERIMENTAL_GOOGLE_C2P_RESOLVER"));
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value.get(), &parsed_value);
+  if (parse_succeeded && parsed_value) {
+    ResolverRegistry::Builder::RegisterResolverFactory(
+        absl::make_unique<GoogleCloud2ProdResolverFactory>());
+  }
+}
+
+void GoogleCloud2ProdResolverShutdown() {}
+
+}  // namespace grpc_core