grpc 1.46.3-x86_64-linux → 1.48.0-x86_64-linux

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

@@ -1,20 +1,16 @@
-/*
- *
- * Copyright 2018 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.
- *
- */
+// Copyright 2018 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>
 
@@ -32,37 +28,32 @@
 #include <sys/utsname.h>
 
 namespace grpc_core {
-static bool errqueue_supported = false;
 
-bool kernel_supports_errqueue() { return errqueue_supported; }
-
-void grpc_errqueue_init() {
-/* Both-compile time and run-time linux kernel versions should be at least 4.0.0
- */
+bool KernelSupportsErrqueue() {
+  static const bool errqueue_supported = []() {
 #ifdef GRPC_LINUX_ERRQUEUE
-  struct utsname buffer;
-  if (uname(&buffer) != 0) {
-    gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
-    return;
-  }
-  char* release = buffer.release;
-  if (release == nullptr) {
-    return;
-  }
-
-  if (strtol(release, nullptr, 10) >= 4) {
-    errqueue_supported = true;
-  } else {
-    gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
-  }
-#endif /* GRPC_LINUX_ERRQUEUE */
+    // Both-compile time and run-time linux kernel versions should be at
+    // least 4.0.0
+    struct utsname buffer;
+    if (uname(&buffer) != 0) {
+      gpr_log(GPR_ERROR, "uname: %s", strerror(errno));
+      return false;
+    }
+    char* release = buffer.release;
+    if (release == nullptr) {
+      return false;
+    }
+
+    if (strtol(release, nullptr, 10) >= 4) {
+      return true;
+    } else {
+      gpr_log(GPR_DEBUG, "ERRQUEUE support not enabled");
+    }
+#endif  // GRPC_LINUX_ERRQUEUE
+    return false;
+  }();
+  return errqueue_supported;
 }
-} /* namespace grpc_core */
-
-#else
-
-namespace grpc_core {
-void grpc_errqueue_init() {}
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP

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

@@ -45,6 +45,13 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
                               "A debugging aid to cause a call to abort() when "
                               "gRPC objects are leaked past grpc_shutdown()");
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(
+    grpc_experimental_enable_tcp_frame_size_tuning, false,
+    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
+    "would not indicate completion of a read operation until a specified "
+    "number of bytes have been read over the socket. Buffers are also "
+    "allocated according to estimated RPC sizes.");
+
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
@@ -64,7 +71,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/iomgr_posix.cc

@@ -80,6 +80,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
   grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
+  grpc_tcp_client_global_init();
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -177,6 +177,7 @@ void grpc_set_default_iomgr_platform() {
     grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
     grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
+  grpc_tcp_client_global_init();
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
 }

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

@@ -66,7 +66,7 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
 end:
   *output = result;
   if (file != nullptr) fclose(file);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),

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>>
@@ -173,7 +165,7 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (err == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(err)) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(err);
@@ -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>>
@@ -158,7 +149,7 @@ done:
   if (result) {
     freeaddrinfo(result);
   }
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     return addresses;
   }
   auto error_result = grpc_error_to_absl_status(error);
@@ -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.cc

@@ -22,13 +22,18 @@
 
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
-void grpc_tcp_client_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
-                             grpc_pollset_set* interested_parties,
-                             const grpc_channel_args* channel_args,
-                             const grpc_resolved_address* addr,
-                             grpc_core::Timestamp deadline) {
-  grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
-                                channel_args, addr, deadline);
+int64_t grpc_tcp_client_connect(grpc_closure* on_connect,
+                                grpc_endpoint** endpoint,
+                                grpc_pollset_set* interested_parties,
+                                const grpc_channel_args* channel_args,
+                                const grpc_resolved_address* addr,
+                                grpc_core::Timestamp deadline) {
+  return grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
+                                       channel_args, addr, deadline);
+}
+
+bool grpc_tcp_client_cancel_connect(int64_t connection_handle) {
+  return grpc_tcp_client_impl->cancel_connect(connection_handle);
 }
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl) {