grpc 1.46.3 → 1.47.0

data/src/core/lib/iomgr/internal_errqueue.h

@@ -177,15 +177,10 @@ struct tcp_info {
 /* Returns true if kernel is capable of supporting errqueue and timestamping.
  * Currently allowing only linux kernels above 4.0.0
  */
-bool kernel_supports_errqueue();
+bool KernelSupportsErrqueue();
 
 } /* namespace grpc_core */
 
 #endif /* GRPC_POSIX_SOCKET_TCP */
 
-namespace grpc_core {
-/* Initializes errqueue support */
-void grpc_errqueue_init();
-} /* namespace grpc_core */
-
 #endif /* GRPC_CORE_LIB_IOMGR_INTERNAL_ERRQUEUE_H */

data/src/core/lib/iomgr/iomgr.cc

@@ -64,7 +64,6 @@ void grpc_iomgr_init() {
   g_root_object.name = const_cast<char*>("root");
   grpc_iomgr_platform_init();
   grpc_timer_list_init();
-  grpc_core::grpc_errqueue_init();
   g_grpc_abort_on_leaks = GPR_GLOBAL_CONFIG_GET(grpc_abort_on_leaks);
 }
 

data/src/core/{ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper_event_engine.cc → lib/iomgr/iomgr_fwd.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 The gRPC Authors
+// Copyright 2022 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,18 +11,15 @@
 // 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/lib/iomgr/port.h"
-#if GRPC_ARES == 1 && defined(GRPC_USE_EVENT_ENGINE)
+#ifndef GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H
+#define GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H
+
+// A bunch of forward declarations that are useful to higher level things that
+// don't want to depend on all of iomgr.
 
-#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
+#include <grpc/support/port_platform.h>
 
-bool grpc_ares_query_ipv6() {
-  /* The libuv grpc code currently does not have the code to probe for this,
-   * so we assume for now that IPv6 is always available in contexts where this
-   * code will be used. */
-  return true;
-}
+typedef struct grpc_pollset_set grpc_pollset_set;
 
-#endif /* GRPC_ARES == 1 && defined(GRPC_USE_EVENT_ENGINE) */
+#endif  // GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H

data/src/core/lib/iomgr/pollset_set.h

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset.h"
 
 /* A grpc_pollset_set is a set of pollsets that are interested in an
@@ -28,8 +29,6 @@
    fd's (etc) that have been registered with the set_set to that pollset.
    Registering fd's automatically adds them to all current pollsets. */
 
-typedef struct grpc_pollset_set grpc_pollset_set;
-
 typedef struct grpc_pollset_set_vtable {
   grpc_pollset_set* (*create)(void);
   void (*destroy)(grpc_pollset_set* pollset_set);

data/src/core/lib/iomgr/port.h

@@ -25,9 +25,7 @@
 #ifdef GPR_WINDOWS
 #define GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY 1
 #endif
-#if defined(GRPC_USE_EVENT_ENGINE)
-// Do Nothing
-#elif defined(GPR_WINDOWS)
+#if defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
 #define GRPC_WINDOWS_SOCKETUTILS 1
 #define GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER 1
@@ -155,6 +153,17 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(GPR_NETBSD)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_SO_NOSIGPIPE 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif defined(GPR_NACL)
 #define GRPC_HAVE_ARPA_NAMESER 1
 #define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
@@ -177,15 +186,25 @@
 // TODO(rudominer) Check this does something we want.
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_TIMER_USE_GENERIC 1
+#elif defined(GPR_HAIKU)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif
 
-#if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) +    \
-        defined(GRPC_CFSTREAM) + defined(GRPC_USE_EVENT_ENGINE) != \
+#if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) + \
+        defined(GRPC_CFSTREAM) !=                               \
     1
 #error \
-    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CFSTREAM, GRPC_USE_EVENT_ENGINE"
+    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CFSTREAM"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET

data/src/core/lib/iomgr/resolve_address.cc

@@ -19,6 +19,8 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 
@@ -29,8 +31,14 @@ namespace {
 DNSResolver* g_dns_resolver;
 }
 
+constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
+
 void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
 
 DNSResolver* GetDNSResolver() { return g_dns_resolver; }
 
+std::string DNSResolver::HandleToString(TaskHandle handle) {
+  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
+}
+
 }  // namespace grpc_core

data/src/core/lib/iomgr/resolve_address.h

@@ -25,6 +25,8 @@
 
 #include "absl/status/statusor.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/port.h"
@@ -39,37 +41,42 @@ constexpr int kDefaultSecurePortInt = 443;
 // A singleton class used for async and blocking DNS resolution
 class DNSResolver {
  public:
-  // Tracks a single asynchronous DNS resolution attempt. The DNS
-  // resolution should be arranged to be cancelled as soon as possible
-  // when Orphan is called.
-  class Request : public InternallyRefCounted<Request> {
-   public:
-    // Begins async DNS resolution
-    virtual void Start() = 0;
-  };
+  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::
+      DNSResolver::LookupTaskHandle;
+  static constexpr TaskHandle kNullHandle{0, 0};
 
   virtual ~DNSResolver() {}
 
+  static std::string HandleToString(TaskHandle handle);
+
   // Asynchronously resolve name. Use \a default_port if a port isn't designated
   // in \a name, otherwise use the port in \a name. On completion, \a on_done is
   // invoked with the result.
   //
   // Note for implementations: calls may acquire locks in \a on_done which
-  // were previously held while calling Request::Start(). Therefore,
-  // implementations must not invoke \a on_done inline from the call to
-  // Request::Start(). The DNSCallbackExecCtxScheduler utility may help address
-  // this.
-  virtual OrphanablePtr<Request> ResolveName(
+  // were previously held while starting the request. Therefore,
+  // implementations must not invoke \a on_done inline from the call site that
+  // starts the request. The DNSCallbackExecCtxScheduler utility may help
+  // address this.
+  //
+  // \a interested_parties may be deleted after a request is cancelled.
+  virtual TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
       grpc_pollset_set* interested_parties,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done) GRPC_MUST_USE_RESULT = 0;
+          on_done) = 0;
 
   // Resolve name in a blocking fashion. Use \a default_port if a port isn't
   // designated in \a name, otherwise use the port in \a name.
   virtual absl::StatusOr<std::vector<grpc_resolved_address>>
   ResolveNameBlocking(absl::string_view name,
                       absl::string_view default_port) = 0;
+
+  // This shares the same semantics with \a EventEngine::Cancel: successfully
+  // cancelled lookups will not have their callbacks executed, and this
+  // method returns true. If a TaskHandle is unknown, this method should return
+  // false.
+  virtual bool Cancel(TaskHandle handle) = 0;
 };
 
 // Override the active DNS resolver which should be used for all DNS

data/src/core/lib/iomgr/resolve_address_impl.h

@@ -26,9 +26,8 @@
 
 namespace grpc_core {
 
-// A fire and forget class used by DNSResolver::Request implementations to
-// schedule DNS  resolution callbacks on the ExecCtx, which is frequently
-// necessary to avoid lock inversion related problems.
+// A fire and forget class to schedule DNS resolution callbacks on the ExecCtx,
+// which is frequently necessary to avoid lock inversion related problems.
 class DNSCallbackExecCtxScheduler {
  public:
   DNSCallbackExecCtxScheduler(

data/src/core/lib/iomgr/resolve_address_posix.cc

@@ -45,7 +45,7 @@
 namespace grpc_core {
 namespace {
 
-class NativeDNSRequest : public DNSResolver::Request {
+class NativeDNSRequest {
  public:
   NativeDNSRequest(
       absl::string_view name, absl::string_view default_port,
@@ -53,18 +53,9 @@ class NativeDNSRequest : public DNSResolver::Request {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-  }
-
-  // Starts the resolution
-  void Start() override {
-    Ref().release();  // ref held by callback
     Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
   }
 
-  // This is a no-op for the native resolver. Note
-  // that no I/O polling is required for the resolution to finish.
-  void Orphan() override { Unref(); }
-
  private:
   // Callback to be passed to grpc Executor to asynch-ify
   // ResolveNameBlocking
@@ -74,7 +65,7 @@ class NativeDNSRequest : public DNSResolver::Request {
         GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
     // running inline is safe since we've already been scheduled on the executor
     r->on_done_(std::move(result));
-    r->Unref();
+    delete r;
   }
 
   const std::string name_;
@@ -91,13 +82,14 @@ NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
   return instance;
 }
 
-OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+DNSResolver::TaskHandle NativeDNSResolver::ResolveName(
     absl::string_view name, absl::string_view default_port,
     grpc_pollset_set* /* interested_parties */,
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_done) {
-  return MakeOrphanable<NativeDNSRequest>(name, default_port,
-                                          std::move(on_done));
+  // self-deleting class
+  new NativeDNSRequest(name, default_port, std::move(on_done));
+  return kNullHandle;
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -181,6 +173,8 @@ done:
   return error_result;
 }
 
+bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
+
 }  // namespace grpc_core
 
 #endif

data/src/core/lib/iomgr/resolve_address_posix.h

@@ -32,14 +32,17 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  OrphanablePtr<DNSResolver::Request> ResolveName(
+  TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* interested_parties,
+      grpc_pollset_set* /* interested_parties */,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
           on_done) override;
 
   absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
       absl::string_view name, absl::string_view default_port) override;
+
+  // NativeDNSResolver does not support cancellation.
+  bool Cancel(TaskHandle handle) override;
 };
 
 }  // namespace grpc_core

data/src/core/lib/iomgr/resolve_address_windows.cc

@@ -48,7 +48,7 @@
 namespace grpc_core {
 namespace {
 
-class NativeDNSRequest : public DNSResolver::Request {
+class NativeDNSRequest {
  public:
   NativeDNSRequest(
       absl::string_view name, absl::string_view default_port,
@@ -56,18 +56,9 @@ class NativeDNSRequest : public DNSResolver::Request {
           on_done)
       : name_(name), default_port_(default_port), on_done_(std::move(on_done)) {
     GRPC_CLOSURE_INIT(&request_closure_, DoRequestThread, this, nullptr);
-  }
-
-  // Starts the resolution
-  void Start() override {
-    Ref().release();  // ref held by callback
     Executor::Run(&request_closure_, GRPC_ERROR_NONE, ExecutorType::RESOLVER);
   }
 
-  // This is a no-op for the native resolver. Note
-  // that no I/O polling is required for the resolution to finish.
-  void Orphan() override { Unref(); }
-
  private:
   // Callback to be passed to grpc Executor to asynch-ify
   // ResolveNameBlocking
@@ -77,7 +68,7 @@ class NativeDNSRequest : public DNSResolver::Request {
         GetDNSResolver()->ResolveNameBlocking(r->name_, r->default_port_);
     // running inline is safe since we've already been scheduled on the executor
     r->on_done_(std::move(result));
-    r->Unref();
+    delete r;
   }
 
   const std::string name_;
@@ -94,13 +85,13 @@ NativeDNSResolver* NativeDNSResolver::GetOrCreate() {
   return instance;
 }
 
-OrphanablePtr<DNSResolver::Request> NativeDNSResolver::ResolveName(
+DNSResolver::TaskHandle NativeDNSResolver::ResolveName(
     absl::string_view name, absl::string_view default_port,
     grpc_pollset_set* /* interested_parties */,
     std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
         on_done) {
-  return MakeOrphanable<NativeDNSRequest>(name, default_port,
-                                          std::move(on_done));
+  new NativeDNSRequest(name, default_port, std::move(on_done));
+  return kNullHandle;
 }
 
 absl::StatusOr<std::vector<grpc_resolved_address>>
@@ -166,6 +157,8 @@ done:
   return error_result;
 }
 
+bool NativeDNSResolver::Cancel(TaskHandle /*handle*/) { return false; }
+
 }  // namespace grpc_core
 
 #endif

data/src/core/lib/iomgr/resolve_address_windows.h

@@ -32,14 +32,17 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  OrphanablePtr<DNSResolver::Request> ResolveName(
+  TaskHandle ResolveName(
       absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* interested_parties,
+      grpc_pollset_set* /* interested_parties */,
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
           on_done) override;
 
   absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
       absl::string_view name, absl::string_view default_port) override;
+
+  // NativeDNSResolver does not support cancellation.
+  bool Cancel(TaskHandle handle) override;
 };
 
 }  // namespace grpc_core

data/src/core/lib/iomgr/sockaddr.h

@@ -25,9 +25,8 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/event_engine/sockaddr.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/sockaddr_posix.h"
-#include "src/core/lib/iomgr/sockaddr_windows.h"
+#include "src/core/lib/iomgr/sockaddr_posix.h"    // IWYU pragma: export
+#include "src/core/lib/iomgr/sockaddr_windows.h"  // IWYU pragma: export
 
 #endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_H */

data/src/core/lib/iomgr/sockaddr_posix.h

@@ -19,6 +19,8 @@
 #ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_SOCKADDR_POSIX_H
 
+// IWYU pragma: private, include "src/core/lib/iomgr/sockaddr.h"
+
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/port.h"

data/src/core/lib/iomgr/sockaddr_windows.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+// IWYU pragma: private, include "src/core/lib/iomgr/sockaddr.h"
+
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_WINSOCK_SOCKET

data/src/core/lib/iomgr/socket_utils_common_posix.cc

@@ -441,9 +441,10 @@ int grpc_ipv6_loopback_available(void) {
 static grpc_error_handle error_for_fd(int fd,
                                       const grpc_resolved_address* addr) {
   if (fd >= 0) return GRPC_ERROR_NONE;
-  std::string addr_str = grpc_sockaddr_to_string(addr, false);
+  auto addr_str = grpc_sockaddr_to_string(addr, false);
   grpc_error_handle err = grpc_error_set_str(
-      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS, addr_str);
+      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
+      addr_str.ok() ? addr_str.value() : addr_str.status().ToString());
   return err;
 }
 

data/src/core/lib/iomgr/tcp_client_cfstream.cc

@@ -140,7 +140,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
 
 static void ParseResolvedAddress(const grpc_resolved_address* addr,
                                  CFStringRef* host, int* port) {
-  std::string host_port = grpc_sockaddr_to_string(addr, true);
+  std::string host_port = grpc_sockaddr_to_string(addr, true).value();
   std::string host_string;
   std::string port_string;
   grpc_core::SplitHostPort(host_port, &host_string, &port_string);
@@ -154,10 +154,18 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
                                   const grpc_channel_args* channel_args,
                                   const grpc_resolved_address* resolved_addr,
                                   grpc_core::Timestamp deadline) {
+  auto addr_uri = grpc_sockaddr_to_uri(resolved_addr);
+  if (!addr_uri.ok()) {
+    grpc_error_handle error =
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_uri.status().ToString());
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
+    return;
+  }
+
   CFStreamConnect* connect = new CFStreamConnect();
   connect->closure = closure;
   connect->endpoint = ep;
-  connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
+  connect->addr_name = addr_uri.value();
   connect->refs = 2;  // One for the connect operation, one for the timer.
   gpr_ref_init(&connect->refcount, 1);
   gpr_mu_init(&connect->mu);

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -277,19 +277,26 @@ void grpc_tcp_client_create_from_prepared_fd(
                   addr->len);
   } while (err < 0 && errno == EINTR);
 
-  std::string name = absl::StrCat("tcp-client:", grpc_sockaddr_to_uri(addr));
+  auto addr_uri = grpc_sockaddr_to_uri(addr);
+  if (!addr_uri.ok()) {
+    grpc_error_handle error =
+        GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_uri.status().ToString());
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
+    return;
+  }
+
+  std::string name = absl::StrCat("tcp-client:", addr_uri.value());
   grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
 
   if (err >= 0) {
-    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args,
-                                         grpc_sockaddr_to_uri(addr));
+    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, addr_uri.value());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
     grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
     error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                               grpc_sockaddr_to_uri(addr));
+                               addr_uri.value());
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
@@ -302,7 +309,7 @@ void grpc_tcp_client_create_from_prepared_fd(
   ac->ep = ep;
   ac->fd = fdobj;
   ac->interested_parties = interested_parties;
-  ac->addr_str = grpc_sockaddr_to_uri(addr);
+  ac->addr_str = addr_uri.value();
   gpr_mu_init(&ac->mu);
   ac->refs = 2;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,

data/src/core/lib/iomgr/tcp_client_windows.cc

@@ -138,6 +138,13 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   grpc_winsocket_callback_info* info;
   grpc_error_handle error = GRPC_ERROR_NONE;
   async_connect* ac = NULL;
+  absl::StatusOr<std::string> addr_uri;
+
+  addr_uri = grpc_sockaddr_to_uri(addr);
+  if (!addr_uri.ok()) {
+    error = GRPC_ERROR_CREATE_FROM_CPP_STRING(addr_uri.status().ToString());
+    goto failure;
+  }
 
   *endpoint = NULL;
 
@@ -199,7 +206,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   ac->socket = socket;
   gpr_mu_init(&ac->mu);
   ac->refs = 2;
-  ac->addr_name = grpc_sockaddr_to_uri(addr);
+  ac->addr_name = addr_uri.value();
   ac->endpoint = endpoint;
   ac->channel_args = grpc_channel_args_copy(channel_args);
   GRPC_CLOSURE_INIT(&ac->on_connect, on_connect, ac, grpc_schedule_on_exec_ctx);
@@ -213,11 +220,11 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
 
 failure:
   GPR_ASSERT(error != GRPC_ERROR_NONE);
-  std::string target_uri = grpc_sockaddr_to_uri(addr);
-  grpc_error_handle final_error =
-      grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                             "Failed to connect", &error, 1),
-                         GRPC_ERROR_STR_TARGET_ADDRESS, target_uri);
+  grpc_error_handle final_error = grpc_error_set_str(
+      GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Failed to connect",
+                                                       &error, 1),
+      GRPC_ERROR_STR_TARGET_ADDRESS,
+      addr_uri.ok() ? *addr_uri : addr_uri.status().ToString());
   GRPC_ERROR_UNREF(error);
   if (socket != NULL) {
     grpc_winsocket_destroy(socket);