grpc 1.45.0 → 1.53.0

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

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
-#define GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
+//
+//
+// Copyright 2015 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
+#define GRPC_SRC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -36,42 +36,42 @@
 #define WSA_FLAG_NO_HANDLE_INHERIT 0x80
 #endif
 
-/* This holds the data for an outstanding read or write on a socket.
-   The mutex to protect the concurrent access to that data is the one
-   inside the winsocket wrapper. */
+// This holds the data for an outstanding read or write on a socket.
+// The mutex to protect the concurrent access to that data is the one
+// inside the winsocket wrapper.
 typedef struct grpc_winsocket_callback_info {
-  /* This is supposed to be a WSAOVERLAPPED, but in order to get that
-     definition, we need to include ws2tcpip.h, which needs to be included
-     from the top, otherwise it'll clash with a previous inclusion of
-     windows.h that in turns includes winsock.h. If anyone knows a way
-     to do it properly, feel free to send a patch. */
+  // This is supposed to be a WSAOVERLAPPED, but in order to get that
+  // definition, we need to include ws2tcpip.h, which needs to be included
+  // from the top, otherwise it'll clash with a previous inclusion of
+  // windows.h that in turns includes winsock.h. If anyone knows a way
+  // to do it properly, feel free to send a patch.
   OVERLAPPED overlapped;
-  /* The callback information for the pending operation. May be empty if the
-     caller hasn't registered a callback yet. */
+  // The callback information for the pending operation. May be empty if the
+  // caller hasn't registered a callback yet.
   grpc_closure* closure;
-  /* A boolean to describe if the IO Completion Port got a notification for
-     that operation. This will happen if the operation completed before the
-     called had time to register a callback. We could avoid that behavior
-     altogether by forcing the caller to always register its callback before
-     proceeding queue an operation, but it is frequent for an IO Completion
-     Port to trigger quickly. This way we avoid a context switch for calling
-     the callback. We also simplify the read / write operations to avoid having
-     to hold a mutex for a long amount of time. */
+  // A boolean to describe if the IO Completion Port got a notification for
+  // that operation. This will happen if the operation completed before the
+  // called had time to register a callback. We could avoid that behavior
+  // altogether by forcing the caller to always register its callback before
+  // proceeding queue an operation, but it is frequent for an IO Completion
+  // Port to trigger quickly. This way we avoid a context switch for calling
+  // the callback. We also simplify the read / write operations to avoid having
+  // to hold a mutex for a long amount of time.
   int has_pending_iocp;
-  /* The results of the overlapped operation. */
+  // The results of the overlapped operation.
   DWORD bytes_transferred;
   int wsa_error;
 } grpc_winsocket_callback_info;
 
-/* This is a wrapper to a Windows socket. A socket can have one outstanding
-   read, and one outstanding write. Doing an asynchronous accept means waiting
-   for a read operation. Doing an asynchronous connect means waiting for a
-   write operation. These are completely arbitrary ties between the operation
-   and the kind of event, because we can have one overlapped per pending
-   operation, whichever its nature is. So we could have more dedicated pending
-   operation callbacks for connect and listen. But given the scope of listen
-   and accept, we don't need to go to that extent and waste memory. Also, this
-   is closer to what happens in posix world. */
+// This is a wrapper to a Windows socket. A socket can have one outstanding
+// read, and one outstanding write. Doing an asynchronous accept means waiting
+// for a read operation. Doing an asynchronous connect means waiting for a
+// write operation. These are completely arbitrary ties between the operation
+// and the kind of event, because we can have one overlapped per pending
+// operation, whichever its nature is. So we could have more dedicated pending
+// operation callbacks for connect and listen. But given the scope of listen
+// and accept, we don't need to go to that extent and waste memory. Also, this
+// is closer to what happens in posix world.
 typedef struct grpc_winsocket {
   SOCKET socket;
   bool destroy_called;
@@ -82,27 +82,25 @@ typedef struct grpc_winsocket {
   gpr_mu state_mu;
   bool shutdown_called;
 
-  /* You can't add the same socket twice to the same IO Completion Port.
-     This prevents that. */
+  // You can't add the same socket twice to the same IO Completion Port.
+  // This prevents that.
   int added_to_iocp;
 
-  grpc_closure shutdown_closure;
-
-  /* A label for iomgr to track outstanding objects */
+  // A label for iomgr to track outstanding objects
   grpc_iomgr_object iomgr_object;
 } grpc_winsocket;
 
-/* Create a wrapped windows handle. This takes ownership of it, meaning that
-   it will be responsible for closing it. */
+// Create a wrapped windows handle. This takes ownership of it, meaning that
+// it will be responsible for closing it.
 grpc_winsocket* grpc_winsocket_create(SOCKET socket, const char* name);
 
 SOCKET grpc_winsocket_wrapped_socket(grpc_winsocket* socket);
 
-/* Initiate an asynchronous shutdown of the socket. Will call off any pending
-   operation to cancel them. */
+// Initiate an asynchronous shutdown of the socket. Will call off any pending
+// operation to cancel them.
 void grpc_winsocket_shutdown(grpc_winsocket* socket);
 
-/* Destroy a socket. Should only be called if there's no pending operation. */
+// Destroy a socket. Should only be called if there's no pending operation.
 void grpc_winsocket_destroy(grpc_winsocket* socket);
 
 void grpc_socket_notify_on_write(grpc_winsocket* winsocket,
@@ -114,8 +112,8 @@ void grpc_socket_notify_on_read(grpc_winsocket* winsocket,
 void grpc_socket_become_ready(grpc_winsocket* winsocket,
                               grpc_winsocket_callback_info* ci);
 
-/* Returns true if this system can create AF_INET6 sockets bound to ::1.
-   The value is probed once, and cached for the life of the process. */
+// Returns true if this system can create AF_INET6 sockets bound to ::1.
+// The value is probed once, and cached for the life of the process.
 int grpc_ipv6_loopback_available(void);
 
 void grpc_wsa_socket_flags_init();
@@ -124,4 +122,4 @@ DWORD grpc_get_default_wsa_socket_flags();
 
 #endif
 
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H

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

@@ -0,0 +1,116 @@
+//
+//
+// 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.
+// 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/lib/iomgr/port.h"
+
+#ifdef GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON
+
+#ifdef HAVE_LIBSYSTEMD
+#include <systemd/sd-daemon.h>
+#endif
+
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/systemd_utils.h"
+
+#ifdef HAVE_LIBSYSTEMD
+bool set_matching_sd_unix_fd(grpc_tcp_server* s,
+                             const grpc_resolved_address* addr,
+                             const int fd_start, const int n) {
+  absl::StatusOr<std::string> addr_name = grpc_sockaddr_to_string(addr, true);
+  for (int i = fd_start; i < fd_start + n; i++) {
+    if (sd_is_socket_unix(i, SOCK_STREAM, 1, addr_name.value().c_str(), 0)) {
+      grpc_tcp_server_set_pre_allocated_fd(s, i);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool set_matching_sd_inet_fd(grpc_tcp_server* s,
+                             const grpc_resolved_address* addr,
+                             const int family, const int port,
+                             const int fd_start, const int n) {
+  for (int i = fd_start; i < fd_start + n; i++) {
+    int r_inet = sd_is_socket_inet(i, family, SOCK_STREAM, 1, (uint16_t)port);
+    int r_addr = sd_is_socket_sockaddr(
+        i, SOCK_STREAM,
+        reinterpret_cast<grpc_sockaddr*>(const_cast<char*>(addr->addr)),
+        addr->len, 1);
+
+    if (r_inet > 0 && r_addr > 0) {
+      grpc_tcp_server_set_pre_allocated_fd(s, i);
+      return true;
+    }
+  }
+  return false;
+}
+
+void set_matching_sd_fds(grpc_tcp_server* s, const grpc_resolved_address* addr,
+                         int requested_port) {
+  int n = sd_listen_fds(0);
+  if (n <= 0) {
+    return;
+  }
+
+  int fd_start = SD_LISTEN_FDS_START;
+  grpc_resolved_address addr6_v4mapped;
+
+  if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) {
+    addr = &addr6_v4mapped;
+  }
+
+  int family = grpc_sockaddr_get_family(addr);
+  int port = grpc_sockaddr_get_port(addr);
+
+  if (family == AF_UNIX) {
+    set_matching_sd_unix_fd(s, addr, fd_start, n);
+  } else {
+    if (grpc_sockaddr_is_wildcard(addr, &requested_port)) {
+      grpc_resolved_address wild4;
+      grpc_resolved_address wild6;
+      grpc_resolved_address wildcard_addrs[2];
+
+      grpc_sockaddr_make_wildcards(requested_port, &wild4, &wild6);
+      wildcard_addrs[0] = wild4;
+      wildcard_addrs[1] = wild6;
+
+      for (grpc_resolved_address addr_w : wildcard_addrs) {
+        int family_w = grpc_sockaddr_get_family(&addr_w);
+        int port_w = grpc_sockaddr_get_port(&addr_w);
+        if (set_matching_sd_inet_fd(s, &addr_w, family_w, port_w, fd_start,
+                                    n)) {
+          return;
+        }
+      }
+      return;
+    }
+
+    set_matching_sd_inet_fd(s, addr, family, port, fd_start, n);
+  }
+}
+#else
+void set_matching_sd_fds(GRPC_UNUSED grpc_tcp_server* s,
+                         GRPC_UNUSED const grpc_resolved_address* addr,
+                         GRPC_UNUSED int requested_port) {}
+#endif  // HAVE_LIBSYSTEMD
+
+#endif  // GRPC_POSIX_SOCKET_TCP_SERVER_UTILS_COMMON

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

@@ -0,0 +1,33 @@
+//
+//
+// 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.
+// 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_SYSTEMD_UTILS_H
+#define GRPC_SRC_CORE_LIB_IOMGR_SYSTEMD_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/tcp_server_utils_posix.h"
+
+// Check whether systemd has pre-allocated FDs. If so, check whether any
+// pre-allocated FD is valid, i.e. matches addr and its family. If there is
+// any valid FD, set its value to s->pre_allocated_fd
+//
+void set_matching_sd_fds(grpc_tcp_server* s, const grpc_resolved_address* addr,
+                         int requested_port);
+
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_SYSTEMD_UTILS_H

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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>
 
@@ -22,13 +22,17 @@
 
 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_event_engine::experimental::EndpointConfig& config,
+    const grpc_resolved_address* addr, grpc_core::Timestamp deadline) {
+  return grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
+                                       config, 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) {

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

@@ -1,27 +1,28 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
-
-#ifndef GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H
-#define GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H
+//
+//
+// Copyright 2015 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.
+//
+//
+
+#ifndef GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_H
+#define GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/impl/grpc_types.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/iomgr/endpoint.h"
@@ -30,26 +31,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_event_engine::experimental::EndpointConfig& config,
+      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);
+// 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). 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_event_engine::experimental::EndpointConfig& config,
+    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);
 
-void grpc_tcp_client_global_init();
+extern void grpc_tcp_client_global_init();
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl);
 
-#endif /* GRPC_CORE_LIB_IOMGR_TCP_CLIENT_H */
+#endif  // GRPC_SRC_CORE_LIB_IOMGR_TCP_CLIENT_H

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

@@ -1,21 +1,21 @@
 
-/*
- *
- * 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>
 
@@ -27,12 +27,13 @@
 #include <netinet/in.h>
 #include <string.h>
 
+#include <grpc/event_engine/endpoint_config.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
-#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -78,7 +79,7 @@ static void OnAlarm(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%s", connect,
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
   }
   gpr_mu_lock(&connect->mu);
   grpc_closure* closure = connect->closure;
@@ -90,8 +91,7 @@ static void OnAlarm(void* arg, grpc_error_handle error) {
   if (done) {
     CFStreamConnectCleanup(connect);
   } else {
-    grpc_error_handle error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("connect() timed out");
+    grpc_error_handle error = GRPC_ERROR_CREATE("connect() timed out");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
   }
 }
@@ -100,7 +100,7 @@ static void OnOpen(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%s", connect,
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
   }
   gpr_mu_lock(&connect->mu);
   grpc_timer_cancel(&connect->alarm);
@@ -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 (error.ok()) {
       CFErrorRef stream_error = CFReadStreamCopyError(connect->read_stream);
       if (stream_error == NULL) {
         stream_error = CFWriteStreamCopyError(connect->write_stream);
@@ -125,13 +125,11 @@ 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 (error.ok()) {
         *endpoint = grpc_cfstream_endpoint_create(
             connect->read_stream, connect->write_stream,
             connect->addr_name.c_str(), connect->stream_handle);
       }
-    } else {
-      (void)GRPC_ERROR_REF(error);
     }
     gpr_mu_unlock(&connect->mu);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
@@ -140,7 +138,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 +147,22 @@ 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_event_engine::experimental::EndpointConfig& /*config*/,
+    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(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 +195,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 */
+#endif  // GRPC_CFSTREAM_CLIENT