grpc 1.30.2 → 1.32.0

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

@@ -24,11 +24,13 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
@@ -196,7 +198,8 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   return out;
 }
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
+void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
+                             int port) {
   memset(out, 0, sizeof(grpc_resolved_address));
   grpc_sockaddr_in6* addr6 = (grpc_sockaddr_in6*)out->addr;
   grpc_sockaddr_in* addr4 = (grpc_sockaddr_in*)out->addr;
@@ -212,8 +215,8 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
   grpc_sockaddr_set_port(out, port);
 }
 
-char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
-  if (resolved_addr->len == 0) return nullptr;
+std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
+  if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
   if (grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
@@ -224,9 +227,9 @@ char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   }
   std::string path =
       grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
-  char* uri_str = nullptr;
+  std::string uri_str;
   if (scheme != nullptr) {
-    gpr_asprintf(&uri_str, "%s:%s", scheme, path.c_str());
+    uri_str = absl::StrCat(scheme, ":", path);
   }
   return uri_str;
 }

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

@@ -66,10 +66,11 @@ int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
 std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
                                     bool normalize);
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port);
+void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
+                             int port);
 
 /* Returns the URI string corresponding to \a addr */
-char* grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
+std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
 
 /* Returns the URI scheme corresponding to \a addr */
 const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);

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

@@ -260,6 +260,27 @@ static int g_default_server_tcp_user_timeout_ms =
 static bool g_default_client_tcp_user_timeout_enabled = false;
 static bool g_default_server_tcp_user_timeout_enabled = true;
 
+#if GPR_LINUX == 1
+// For Linux, it will be detected to support TCP_USER_TIMEOUT
+#ifndef TCP_USER_TIMEOUT
+#define TCP_USER_TIMEOUT 18
+#endif
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0
+#else
+// For non-Linux, TCP_USER_TIMEOUT will be used if TCP_USER_TIMEOUT is defined.
+#ifdef TCP_USER_TIMEOUT
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT 0
+#else
+#define TCP_USER_TIMEOUT 0
+#define SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT -1
+#endif  // TCP_USER_TIMEOUT
+#endif  // GPR_LINUX == 1
+
+// Whether the socket supports TCP_USER_TIMEOUT option.
+// (0: don't know, 1: support, -1: not support)
+static std::atomic<int> g_socket_supports_tcp_user_timeout(
+    SOCKET_SUPPORTS_TCP_USER_TIMEOUT_DEFAULT);
+
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
   if (is_client) {
     g_default_client_tcp_user_timeout_enabled = enable;
@@ -281,68 +302,87 @@ grpc_error* grpc_set_socket_tcp_user_timeout(
   (void)fd;
   (void)channel_args;
   (void)is_client;
-#ifdef GRPC_HAVE_TCP_USER_TIMEOUT
-  bool enable;
-  int timeout;
-  if (is_client) {
-    enable = g_default_client_tcp_user_timeout_enabled;
-    timeout = g_default_client_tcp_user_timeout_ms;
-  } else {
-    enable = g_default_server_tcp_user_timeout_enabled;
-    timeout = g_default_server_tcp_user_timeout_ms;
-  }
-  if (channel_args) {
-    for (unsigned int i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
-        const int value = grpc_channel_arg_get_integer(
-            &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-        /* Continue using default if value is 0 */
-        if (value == 0) {
-          continue;
+  extern grpc_core::TraceFlag grpc_tcp_trace;
+  if (g_socket_supports_tcp_user_timeout.load() >= 0) {
+    bool enable;
+    int timeout;
+    if (is_client) {
+      enable = g_default_client_tcp_user_timeout_enabled;
+      timeout = g_default_client_tcp_user_timeout_ms;
+    } else {
+      enable = g_default_server_tcp_user_timeout_enabled;
+      timeout = g_default_server_tcp_user_timeout_ms;
+    }
+    if (channel_args) {
+      for (unsigned int i = 0; i < channel_args->num_args; i++) {
+        if (0 ==
+            strcmp(channel_args->args[i].key, GRPC_ARG_KEEPALIVE_TIME_MS)) {
+          const int value = grpc_channel_arg_get_integer(
+              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
+          /* Continue using default if value is 0 */
+          if (value == 0) {
+            continue;
+          }
+          /* Disable if value is INT_MAX */
+          enable = value != INT_MAX;
+        } else if (0 == strcmp(channel_args->args[i].key,
+                               GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
+          const int value = grpc_channel_arg_get_integer(
+              &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
+          /* Continue using default if value is 0 */
+          if (value == 0) {
+            continue;
+          }
+          timeout = value;
         }
-        /* Disable if value is INT_MAX */
-        enable = value != INT_MAX;
-      } else if (0 == strcmp(channel_args->args[i].key,
-                             GRPC_ARG_KEEPALIVE_TIMEOUT_MS)) {
-        const int value = grpc_channel_arg_get_integer(
-            &channel_args->args[i], grpc_integer_options{0, 1, INT_MAX});
-        /* Continue using default if value is 0 */
-        if (value == 0) {
-          continue;
+      }
+    }
+    if (enable) {
+      int newval;
+      socklen_t len = sizeof(newval);
+      // If this is the first time to use TCP_USER_TIMEOUT, try to check
+      // if it is available.
+      if (g_socket_supports_tcp_user_timeout.load() == 0) {
+        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
+          gpr_log(GPR_INFO,
+                  "TCP_USER_TIMEOUT is not available. TCP_USER_TIMEOUT won't "
+                  "be used thereafter");
+          g_socket_supports_tcp_user_timeout.store(-1);
+        } else {
+          gpr_log(GPR_INFO,
+                  "TCP_USER_TIMEOUT is available. TCP_USER_TIMEOUT will be "
+                  "used thereafter");
+          g_socket_supports_tcp_user_timeout.store(1);
+        }
+      }
+      if (g_socket_supports_tcp_user_timeout.load() > 0) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
+          gpr_log(GPR_INFO, "Enabling TCP_USER_TIMEOUT with a timeout of %d ms",
+                  timeout);
+        }
+        if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
+                            sizeof(timeout))) {
+          gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s",
+                  strerror(errno));
+          return GRPC_ERROR_NONE;
+        }
+        if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
+          gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s",
+                  strerror(errno));
+          return GRPC_ERROR_NONE;
+        }
+        if (newval != timeout) {
+          /* Do not fail on failing to set TCP_USER_TIMEOUT for now. */
+          gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
+          return GRPC_ERROR_NONE;
         }
-        timeout = value;
       }
     }
-  }
-  if (enable) {
-    extern grpc_core::TraceFlag grpc_tcp_trace;
+  } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-      gpr_log(GPR_INFO, "Enabling TCP_USER_TIMEOUT with a timeout of %d ms",
-              timeout);
-    }
-    int newval;
-    socklen_t len = sizeof(newval);
-    if (0 != setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout,
-                        sizeof(timeout))) {
-      gpr_log(GPR_ERROR, "setsockopt(TCP_USER_TIMEOUT) %s", strerror(errno));
-      return GRPC_ERROR_NONE;
+      gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform");
     }
-    if (0 != getsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &newval, &len)) {
-      gpr_log(GPR_ERROR, "getsockopt(TCP_USER_TIMEOUT) %s", strerror(errno));
-      return GRPC_ERROR_NONE;
-    }
-    if (newval != timeout) {
-      /* Do not fail on failing to set TCP_USER_TIMEOUT for now. */
-      gpr_log(GPR_ERROR, "Failed to set TCP_USER_TIMEOUT");
-      return GRPC_ERROR_NONE;
-    }
-  }
-#else
-  extern grpc_core::TraceFlag grpc_tcp_trace;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform");
   }
-#endif /* GRPC_HAVE_TCP_USER_TIMEOUT */
   return GRPC_ERROR_NONE;
 }
 

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

@@ -27,10 +27,11 @@
 // must be included after winsock2.h
 #include <mswsock.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/log_windows.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
@@ -42,14 +43,12 @@
 static DWORD s_wsa_socket_flags;
 
 grpc_winsocket* grpc_winsocket_create(SOCKET socket, const char* name) {
-  char* final_name;
   grpc_winsocket* r = (grpc_winsocket*)gpr_malloc(sizeof(grpc_winsocket));
   memset(r, 0, sizeof(grpc_winsocket));
   r->socket = socket;
   gpr_mu_init(&r->state_mu);
-  gpr_asprintf(&final_name, "%s:socket=0x%p", name, r);
-  grpc_iomgr_register_object(&r->iomgr_object, final_name);
-  gpr_free(final_name);
+  grpc_iomgr_register_object(
+      &r->iomgr_object, absl::StrFormat("%s:socket=0x%p", name, r).c_str());
   grpc_iocp_add_socket(r);
   return r;
 }

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

@@ -46,7 +46,7 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-typedef struct CFStreamConnect {
+struct CFStreamConnect {
   gpr_mu mu;
   gpr_refcount refcount;
 
@@ -65,9 +65,9 @@ typedef struct CFStreamConnect {
   grpc_closure* closure;
   grpc_endpoint** endpoint;
   int refs;
-  char* addr_name;
+  std::string addr_name;
   grpc_resource_quota* resource_quota;
-} CFStreamConnect;
+};
 
 static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   grpc_resource_quota_unref_internal(connect->resource_quota);
@@ -75,8 +75,7 @@ static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   CFRelease(connect->read_stream);
   CFRelease(connect->write_stream);
   gpr_mu_destroy(&connect->mu);
-  gpr_free(connect->addr_name);
-  gpr_free(connect);
+  delete connect;
 }
 
 static void OnAlarm(void* arg, grpc_error* error) {
@@ -130,8 +129,9 @@ static void OnOpen(void* arg, grpc_error* error) {
       }
       if (error == GRPC_ERROR_NONE) {
         *endpoint = grpc_cfstream_endpoint_create(
-            connect->read_stream, connect->write_stream, connect->addr_name,
-            connect->resource_quota, connect->stream_handle);
+            connect->read_stream, connect->write_stream,
+            connect->addr_name.c_str(), connect->resource_quota,
+            connect->stream_handle);
       }
     } else {
       GRPC_ERROR_REF(error);
@@ -157,9 +157,7 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
                                   const grpc_channel_args* channel_args,
                                   const grpc_resolved_address* resolved_addr,
                                   grpc_millis deadline) {
-  CFStreamConnect* connect;
-
-  connect = (CFStreamConnect*)gpr_zalloc(sizeof(CFStreamConnect));
+  CFStreamConnect* connect = new CFStreamConnect();
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
@@ -170,7 +168,7 @@ static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
 
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
-            connect, connect->addr_name);
+            connect, connect->addr_name.c_str());
   }
 
   grpc_resource_quota* resource_quota = grpc_resource_quota_create(NULL);

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

@@ -42,15 +42,14 @@ struct grpc_custom_tcp_connect {
   grpc_closure* closure;
   grpc_endpoint** endpoint;
   int refs;
-  char* addr_name;
+  std::string addr_name;
   grpc_resource_quota* resource_quota;
 };
 
 static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
   grpc_custom_socket* socket = connect->socket;
   grpc_resource_quota_unref_internal(connect->resource_quota);
-  gpr_free(connect->addr_name);
-  gpr_free(connect);
+  delete connect;
   socket->refs--;
   if (socket->refs == 0) {
     grpc_custom_socket_vtable->destroy(socket);
@@ -67,7 +66,7 @@ static void on_alarm(void* acp, grpc_error* error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            connect->addr_name, str);
+            connect->addr_name.c_str(), str);
   }
   if (error == GRPC_ERROR_NONE) {
     /* error == NONE implies that the timer ran out, and wasn't cancelled. If
@@ -89,7 +88,7 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
   grpc_timer_cancel(&connect->alarm);
   if (error == GRPC_ERROR_NONE) {
     *connect->endpoint = custom_tcp_endpoint_create(
-        socket, connect->resource_quota, connect->addr_name);
+        socket, connect->resource_quota, connect->addr_name.c_str());
   }
   done = (--connect->refs == 0);
   if (done) {
@@ -120,7 +119,6 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   (void)channel_args;
   (void)interested_parties;
-  grpc_custom_tcp_connect* connect;
   grpc_resource_quota* resource_quota = grpc_resource_quota_create(nullptr);
   if (channel_args != nullptr) {
     for (size_t i = 0; i < channel_args->num_args; i++) {
@@ -135,8 +133,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
       (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
   socket->refs = 2;
   grpc_custom_socket_vtable->init(socket, GRPC_AF_UNSPEC);
-  connect =
-      (grpc_custom_tcp_connect*)gpr_malloc(sizeof(grpc_custom_tcp_connect));
+  grpc_custom_tcp_connect* connect = new grpc_custom_tcp_connect();
   connect->closure = closure;
   connect->endpoint = ep;
   connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
@@ -149,7 +146,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %p %s: asynchronously connecting",
-            socket, connect->addr_name);
+            socket, connect->addr_name.c_str());
   }
 
   GRPC_CLOSURE_INIT(&connect->on_alarm, on_alarm, socket,

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

@@ -29,9 +29,10 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
@@ -57,11 +58,12 @@ struct async_connect {
   int refs;
   grpc_closure write_closure;
   grpc_pollset_set* interested_parties;
-  char* addr_str;
+  std::string addr_str;
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
 };
+
 static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
                                   const grpc_channel_args* channel_args) {
   grpc_error* err = GRPC_ERROR_NONE;
@@ -102,8 +104,8 @@ static void tc_on_alarm(void* acp, grpc_error* error) {
   async_connect* ac = static_cast<async_connect*>(acp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s", ac->addr_str,
-            str);
+    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
+            ac->addr_str.c_str(), str);
   }
   gpr_mu_lock(&ac->mu);
   if (ac->fd != nullptr) {
@@ -114,9 +116,8 @@ static void tc_on_alarm(void* acp, grpc_error* error) {
   gpr_mu_unlock(&ac->mu);
   if (done) {
     gpr_mu_destroy(&ac->mu);
-    gpr_free(ac->addr_str);
     grpc_channel_args_destroy(ac->channel_args);
-    gpr_free(ac);
+    delete ac;
   }
 }
 
@@ -139,8 +140,8 @@ static void on_writable(void* acp, grpc_error* error) {
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
-    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s", ac->addr_str,
-            str);
+    gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s",
+            ac->addr_str.c_str(), str);
   }
 
   gpr_mu_lock(&ac->mu);
@@ -172,7 +173,8 @@ static void on_writable(void* acp, grpc_error* error) {
   switch (so_error) {
     case 0:
       grpc_pollset_set_del_fd(ac->interested_parties, fd);
-      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args, ac->addr_str);
+      *ep = grpc_tcp_client_create_from_fd(fd, ac->channel_args,
+                                           ac->addr_str.c_str());
       fd = nullptr;
       break;
     case ENOBUFS:
@@ -214,19 +216,17 @@ finish:
   done = (--ac->refs == 0);
   // Create a copy of the data from "ac" to be accessed after the unlock, as
   // "ac" and its contents may be deallocated by the time they are read.
-  const grpc_slice addr_str_slice = grpc_slice_from_copied_string(ac->addr_str);
+  const grpc_slice addr_str_slice = grpc_slice_from_cpp_string(ac->addr_str);
   gpr_mu_unlock(&ac->mu);
   if (error != GRPC_ERROR_NONE) {
-    char* error_descr;
     grpc_slice str;
     bool ret = grpc_error_get_str(error, GRPC_ERROR_STR_DESCRIPTION, &str);
     GPR_ASSERT(ret);
-    char* desc = grpc_slice_to_c_string(str);
-    gpr_asprintf(&error_descr, "Failed to connect to remote host: %s", desc);
-    error = grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION,
-                               grpc_slice_from_copied_string(error_descr));
-    gpr_free(error_descr);
-    gpr_free(desc);
+    std::string description = absl::StrCat("Failed to connect to remote host: ",
+                                           grpc_core::StringViewFromSlice(str));
+    error =
+        grpc_error_set_str(error, GRPC_ERROR_STR_DESCRIPTION,
+                           grpc_slice_from_cpp_string(std::move(description)));
     error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
                                addr_str_slice /* takes ownership */);
   } else {
@@ -236,9 +236,8 @@ finish:
     // This is safe even outside the lock, because "done", the sentinel, is
     // populated *inside* the lock.
     gpr_mu_destroy(&ac->mu);
-    gpr_free(ac->addr_str);
     grpc_channel_args_destroy(ac->channel_args);
-    gpr_free(ac);
+    delete ac;
   }
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
 }
@@ -279,33 +278,25 @@ void grpc_tcp_client_create_from_prepared_fd(
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_millis deadline, grpc_endpoint** ep) {
   int err;
-  async_connect* ac;
   do {
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
                   addr->len);
   } while (err < 0 && errno == EINTR);
 
-  char* name;
-  char* addr_str;
-  addr_str = grpc_sockaddr_to_uri(addr);
-  gpr_asprintf(&name, "tcp-client:%s", addr_str);
-  grpc_fd* fdobj = grpc_fd_create(fd, name, true);
-  gpr_free(name);
-  gpr_free(addr_str);
+  std::string name = absl::StrCat("tcp-client:", grpc_sockaddr_to_uri(addr));
+  grpc_fd* fdobj = grpc_fd_create(fd, name.c_str(), true);
 
   if (err >= 0) {
-    char* addr_str = grpc_sockaddr_to_uri(addr);
-    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, addr_str);
-    gpr_free(addr_str);
+    *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args,
+                                         grpc_sockaddr_to_uri(addr).c_str());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
     grpc_error* error = GRPC_OS_ERROR(errno, "connect");
-    char* addr_str = grpc_sockaddr_to_uri(addr);
-    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
-                               grpc_slice_from_copied_string(addr_str));
-    gpr_free(addr_str);
+    error = grpc_error_set_str(
+        error, GRPC_ERROR_STR_TARGET_ADDRESS,
+        grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr)));
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
@@ -313,7 +304,7 @@ void grpc_tcp_client_create_from_prepared_fd(
 
   grpc_pollset_set_add_fd(interested_parties, fdobj);
 
-  ac = static_cast<async_connect*>(gpr_malloc(sizeof(async_connect)));
+  async_connect* ac = new async_connect();
   ac->closure = closure;
   ac->ep = ep;
   ac->fd = fdobj;
@@ -327,7 +318,7 @@ void grpc_tcp_client_create_from_prepared_fd(
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: asynchronously connecting fd %p",
-            ac->addr_str, fdobj);
+            ac->addr_str.c_str(), fdobj);
   }
 
   gpr_mu_lock(&ac->mu);