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

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

@@ -30,25 +30,36 @@
 #include "src/core/lib/resource_quota/memory_quota.h"
 
 typedef struct grpc_tcp_client_vtable {
-  void (*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);
+  int64_t (*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);
+  bool (*cancel_connect)(int64_t connection_handle);
 } grpc_tcp_client_vtable;
 
 /* Asynchronously connect to an address (specified as (addr, len)), and call
    cb with arg and the completed connection when done (or call cb with arg and
    NULL on failure).
    interested_parties points to a set of pollsets that would be interested
-   in this connection being established (in order to continue their work) */
-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);
-
-void grpc_tcp_client_global_init();
+   in this connection being established (in order to continue their work). It
+   returns a handle to the connect operation which can be used to cancel the
+   connection attempt. */
+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);
+
+// Returns true if a connect attempt corresponding to the provided handle
+// is successfully cancelled. Otherwise it returns false. If the connect
+// attempt is successfully cancelled, then the on_connect closure passed to
+// grpc_tcp_client_connect will not be executed. Its upto the caller to free
+// up any resources that may have been allocated to create the closure.
+bool grpc_tcp_client_cancel_connect(int64_t connection_handle);
+
+extern void grpc_tcp_client_global_init();
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl);
 

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

@@ -116,7 +116,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
     gpr_mu_unlock(&connect->mu);
     CFStreamConnectCleanup(connect);
   } else {
-    if (error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(error)) {
       CFErrorRef stream_error = CFReadStreamCopyError(connect->read_stream);
       if (stream_error == NULL) {
         stream_error = CFWriteStreamCopyError(connect->write_stream);
@@ -125,7 +125,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
         error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "connect() error");
         CFRelease(stream_error);
       }
-      if (error == GRPC_ERROR_NONE) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         *endpoint = grpc_cfstream_endpoint_create(
             connect->read_stream, connect->write_stream,
             connect->addr_name.c_str(), connect->stream_handle);
@@ -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);
@@ -149,15 +149,23 @@ static void ParseResolvedAddress(const grpc_resolved_address* addr,
   *port = grpc_sockaddr_get_port(addr);
 }
 
-static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
-                                  grpc_pollset_set* interested_parties,
-                                  const grpc_channel_args* channel_args,
-                                  const grpc_resolved_address* resolved_addr,
-                                  grpc_core::Timestamp deadline) {
+static int64_t CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
+                                     grpc_pollset_set* interested_parties,
+                                     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 0;
+  }
+
   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);
@@ -190,8 +198,14 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
   CFWriteStreamOpen(write_stream);
   grpc_timer_init(&connect->alarm, deadline, &connect->on_alarm);
   gpr_mu_unlock(&connect->mu);
+  return 0;
+}
+
+static bool CFStreamClientCancelConnect(int64_t /*connection_handle*/) {
+  return false;
 }
 
-grpc_tcp_client_vtable grpc_cfstream_client_vtable = {CFStreamClientConnect};
+grpc_tcp_client_vtable grpc_cfstream_client_vtable = {
+    CFStreamClientConnect, CFStreamClientCancelConnect};
 
 #endif /* GRPC_CFSTREAM_CLIENT */

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

@@ -27,6 +27,7 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/strings/str_cat.h"
 
 #include <grpc/support/alloc.h>
@@ -62,8 +63,33 @@ struct async_connect {
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
+  int64_t connection_handle;
+  bool connect_cancelled;
 };
 
+struct ConnectionShard {
+  grpc_core::Mutex mu;
+  absl::flat_hash_map<int64_t, async_connect*> pending_connections
+      ABSL_GUARDED_BY(&mu);
+};
+
+namespace {
+
+gpr_once g_tcp_client_posix_init = GPR_ONCE_INIT;
+std::vector<ConnectionShard>* g_connection_shards = nullptr;
+std::atomic<int64_t> g_connection_id{1};
+
+void do_tcp_client_global_init(void) {
+  size_t num_shards = std::max(2 * gpr_cpu_num_cores(), 1u);
+  g_connection_shards = new std::vector<struct ConnectionShard>(num_shards);
+}
+
+}  // namespace
+
+void grpc_tcp_client_global_init() {
+  gpr_once_init(&g_tcp_client_posix_init, do_tcp_client_global_init);
+}
+
 static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
                                         int fd,
                                         const grpc_channel_args* channel_args) {
@@ -72,24 +98,24 @@ static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
   GPR_ASSERT(fd >= 0);
 
   err = grpc_set_socket_nonblocking(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, channel_args,
                                            true /* is_client */);
-    if (err != GRPC_ERROR_NONE) goto error;
+    if (!GRPC_ERROR_IS_NONE(err)) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   err = grpc_apply_socket_mutator_in_args(fd, GRPC_FD_CLIENT_CONNECTION_USAGE,
                                           channel_args);
-  if (err != GRPC_ERROR_NONE) goto error;
+  if (!GRPC_ERROR_IS_NONE(err)) goto error;
 
   goto done;
 
@@ -150,17 +176,24 @@ static void on_writable(void* acp, grpc_error_handle error) {
   GPR_ASSERT(ac->fd);
   fd = ac->fd;
   ac->fd = nullptr;
+  bool connect_cancelled = ac->connect_cancelled;
   gpr_mu_unlock(&ac->mu);
 
   grpc_timer_cancel(&ac->alarm);
 
   gpr_mu_lock(&ac->mu);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     error =
         grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR, "Timeout occurred");
     goto finish;
   }
 
+  if (connect_cancelled) {
+    // The callback should not get scheduled in this case.
+    error = GRPC_ERROR_NONE;
+    goto finish;
+  }
+
   do {
     so_error_size = sizeof(so_error);
     err = getsockopt(grpc_fd_wrapped_fd(fd), SOL_SOCKET, SO_ERROR, &so_error,
@@ -208,6 +241,14 @@ static void on_writable(void* acp, grpc_error_handle error) {
   }
 
 finish:
+  if (!connect_cancelled) {
+    int shard_number = ac->connection_handle % (*g_connection_shards).size();
+    struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
+    {
+      grpc_core::MutexLock lock(&shard->mu);
+      shard->pending_connections.erase(ac->connection_handle);
+    }
+  }
   if (fd != nullptr) {
     grpc_pollset_set_del_fd(ac->interested_parties, fd);
     grpc_fd_orphan(fd, nullptr, nullptr, "tcp_client_orphan");
@@ -215,7 +256,7 @@ finish:
   }
   done = (--ac->refs == 0);
   gpr_mu_unlock(&ac->mu);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     std::string str;
     bool ret = grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &str);
     GPR_ASSERT(ret);
@@ -234,7 +275,12 @@ finish:
   // Push async connect closure to the executor since this may actually be
   // called during the shutdown process, in which case a deadlock could form
   // between the core shutdown mu and the connector mu (b/188239051)
-  grpc_core::Executor::Run(closure, error);
+  if (!connect_cancelled) {
+    grpc_core::Executor::Run(closure, error);
+  } else if (!GRPC_ERROR_IS_NONE(error)) {
+    // Unref the error here because it is not used.
+    (void)GRPC_ERROR_UNREF(error);
+  }
 }
 
 grpc_error_handle grpc_tcp_client_prepare_fd(
@@ -251,7 +297,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
   }
   error =
       grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     return error;
   }
   if (dsmode == GRPC_DSMODE_IPV4) {
@@ -267,7 +313,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
   return GRPC_ERROR_NONE;
 }
 
-void grpc_tcp_client_create_from_prepared_fd(
+int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_core::Timestamp deadline, grpc_endpoint** ep) {
@@ -277,22 +323,38 @@ 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 0;
+  }
+
+  std::string name = absl::StrCat("tcp-client:", addr_uri.value());
   grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
+  int64_t connection_id = 0;
+  if (errno == EWOULDBLOCK || errno == EINPROGRESS) {
+    // Connection is still in progress.
+    connection_id = g_connection_id.fetch_add(1, std::memory_order_acq_rel);
+  }
 
   if (err >= 0) {
-    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args,
-                                         grpc_sockaddr_to_uri(addr));
+    // Connection already succeded. Return 0 to discourage any cancellation
+    // attempts.
+    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, addr_uri.value());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
-    return;
+    return 0;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
+    // Connection already failed. Return 0 to discourage any cancellation
+    // attempts.
     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;
+    return 0;
   }
 
   grpc_pollset_set_add_fd(interested_parties, fdobj);
@@ -302,7 +364,9 @@ 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();
+  ac->connection_handle = connection_id;
+  ac->connect_cancelled = false;
   gpr_mu_init(&ac->mu);
   ac->refs = 2;
   GRPC_CLOSURE_INIT(&ac->write_closure, on_writable, ac,
@@ -314,18 +378,26 @@ void grpc_tcp_client_create_from_prepared_fd(
             ac->addr_str.c_str(), fdobj);
   }
 
+  int shard_number = connection_id % (*g_connection_shards).size();
+  struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
+  {
+    grpc_core::MutexLock lock(&shard->mu);
+    shard->pending_connections.insert_or_assign(connection_id, ac);
+  }
+
   gpr_mu_lock(&ac->mu);
   GRPC_CLOSURE_INIT(&ac->on_alarm, tc_on_alarm, ac, grpc_schedule_on_exec_ctx);
   grpc_timer_init(&ac->alarm, deadline, &ac->on_alarm);
   grpc_fd_notify_on_write(ac->fd, &ac->write_closure);
   gpr_mu_unlock(&ac->mu);
+  return connection_id;
 }
 
-static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
-                        grpc_pollset_set* interested_parties,
-                        const grpc_channel_args* channel_args,
-                        const grpc_resolved_address* addr,
-                        grpc_core::Timestamp deadline) {
+static int64_t tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
+                           grpc_pollset_set* interested_parties,
+                           const grpc_channel_args* channel_args,
+                           const grpc_resolved_address* addr,
+                           grpc_core::Timestamp deadline) {
   grpc_resolved_address mapped_addr;
   int fd = -1;
   grpc_error_handle error;
@@ -333,12 +405,65 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   if ((error = grpc_tcp_client_prepare_fd(channel_args, addr, &mapped_addr,
                                           &fd)) != GRPC_ERROR_NONE) {
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
-    return;
+    return 0;
+  }
+  return grpc_tcp_client_create_from_prepared_fd(interested_parties, closure,
+                                                 fd, channel_args, &mapped_addr,
+                                                 deadline, ep);
+}
+
+static bool tcp_cancel_connect(int64_t connection_handle) {
+  if (connection_handle <= 0) {
+    return false;
+  }
+  int shard_number = connection_handle % (*g_connection_shards).size();
+  struct ConnectionShard* shard = &(*g_connection_shards)[shard_number];
+  async_connect* ac = nullptr;
+  {
+    grpc_core::MutexLock lock(&shard->mu);
+    auto it = shard->pending_connections.find(connection_handle);
+    if (it != shard->pending_connections.end()) {
+      ac = it->second;
+      GPR_ASSERT(ac != nullptr);
+      // Trying to acquire ac->mu here would could cause a deadlock because
+      // the on_writable method tries to acquire the two mutexes used
+      // here in the reverse order. But we dont need to acquire ac->mu before
+      // incrementing ac->refs here. This is because the on_writable
+      // method decrements ac->refs only after deleting the connection handle
+      // from the corresponding hashmap. If the code enters here, it means that
+      // deletion hasn't happened yet. The deletion can only happen after the
+      // corresponding g_shard_mu is unlocked.
+      ++ac->refs;
+      // Remove connection from list of active connections.
+      shard->pending_connections.erase(it);
+    }
+  }
+  if (ac == nullptr) {
+    return false;
+  }
+  gpr_mu_lock(&ac->mu);
+  bool connection_cancel_success = (ac->fd != nullptr);
+  if (connection_cancel_success) {
+    // Connection is still pending. The on_writable callback hasn't executed
+    // yet because ac->fd != nullptr.
+    ac->connect_cancelled = true;
+    // Shutdown the fd. This would cause on_writable to run as soon as possible.
+    // We dont need to pass a custom error here because it wont be used since
+    // the on_connect_closure is not run if connect cancellation is successfull.
+    grpc_fd_shutdown(ac->fd, GRPC_ERROR_NONE);
+  }
+  bool done = (--ac->refs == 0);
+  gpr_mu_unlock(&ac->mu);
+  if (done) {
+    // This is safe even outside the lock, because "done", the sentinel, is
+    // populated *inside* the lock.
+    gpr_mu_destroy(&ac->mu);
+    grpc_channel_args_destroy(ac->channel_args);
+    delete ac;
   }
-  grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fd,
-                                          channel_args, &mapped_addr, deadline,
-                                          ep);
+  return connection_cancel_success;
 }
 
-grpc_tcp_client_vtable grpc_posix_tcp_client_vtable = {tcp_connect};
+grpc_tcp_client_vtable grpc_posix_tcp_client_vtable = {tcp_connect,
+                                                       tcp_cancel_connect};
 #endif

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

@@ -61,7 +61,7 @@ grpc_error_handle grpc_tcp_client_prepare_fd(
    deadline: connection deadline
    ep: out parameter. Set before closure is called if successful
 */
-void grpc_tcp_client_create_from_prepared_fd(
+int64_t grpc_tcp_client_create_from_prepared_fd(
     grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_core::Timestamp deadline, grpc_endpoint** ep);

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

@@ -93,7 +93,7 @@ static void on_connect(void* acp, grpc_error_handle error) {
 
   gpr_mu_lock(&ac->mu);
 
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     if (socket != NULL) {
       DWORD transfered_bytes = 0;
       DWORD flags;
@@ -121,11 +121,11 @@ static void on_connect(void* acp, grpc_error_handle error) {
 
 /* Tries to issue one async connection, then schedules both an IOCP
    notification request for the connection, and one timeout alert. */
-static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
-                        grpc_pollset_set* interested_parties,
-                        const grpc_channel_args* channel_args,
-                        const grpc_resolved_address* addr,
-                        grpc_core::Timestamp deadline) {
+static int64_t tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
+                           grpc_pollset_set* interested_parties,
+                           const grpc_channel_args* channel_args,
+                           const grpc_resolved_address* addr,
+                           grpc_core::Timestamp deadline) {
   SOCKET sock = INVALID_SOCKET;
   BOOL success;
   int status;
@@ -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;
 
@@ -154,7 +161,7 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   }
 
   error = grpc_tcp_prepare_socket(sock);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     goto failure;
   }
 
@@ -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);
@@ -209,15 +216,15 @@ static void tcp_connect(grpc_closure* on_done, grpc_endpoint** endpoint,
   grpc_timer_init(&ac->alarm, deadline, &ac->on_alarm);
   grpc_socket_notify_on_write(socket, &ac->on_connect);
   gpr_mu_unlock(&ac->mu);
-  return;
+  return 0;
 
 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);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
+  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);
@@ -225,8 +232,12 @@ failure:
     closesocket(sock);
   }
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, final_error);
+  return 0;
 }
 
-grpc_tcp_client_vtable grpc_windows_tcp_client_vtable = {tcp_connect};
+static bool tcp_cancel_connect(int64_t /*connection_handle*/) { return false; }
+
+grpc_tcp_client_vtable grpc_windows_tcp_client_vtable = {tcp_connect,
+                                                         tcp_cancel_connect};
 
 #endif /* GRPC_WINSOCK_SOCKET */