grpc 1.28.0 → 1.37.0

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
@@ -54,31 +56,50 @@ void grpc_sockaddr_make_wildcard6(int port, grpc_resolved_address* wild_out);
 int grpc_sockaddr_get_port(const grpc_resolved_address* addr);
 
 /* Set IP port number of a sockaddr */
-int grpc_sockaddr_set_port(const grpc_resolved_address* addr, int port);
-
-/* Converts a sockaddr into a newly-allocated human-readable string.
-
-   Currently, only the AF_INET and AF_INET6 families are recognized.
-   If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
-   displayed as plain IPv4.
-
-   Usage is similar to gpr_asprintf: returns the number of bytes written
-   (excluding the final '\0'), and *out points to a string which must later be
-   destroyed using gpr_free().
-
-   In the unlikely event of an error, returns -1 and sets *out to NULL.
-   The existing value of errno is always preserved. */
-int grpc_sockaddr_to_string(char** out, const grpc_resolved_address* addr,
-                            int normalize);
-
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port);
+int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
+
+// Converts a sockaddr into a newly-allocated human-readable string.
+//
+// Currently, only the AF_INET and AF_INET6 families are recognized.
+// If the normalize flag is enabled, ::ffff:0.0.0.0/96 IPv6 addresses are
+// displayed as plain IPv4.
+std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
+                                    bool normalize);
+
+// TODO(yashykt): Remove this function and replace usages with
+// `grpc_string_to_sockaddr_new`
+void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
+                             int port);
+
+// Newer form of grpc_string_to_sockaddr which returns an error instead of
+// crashing if \a addr is not IPv6/IPv6
+grpc_error* grpc_string_to_sockaddr_new(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);
 
 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
 
+std::string grpc_sockaddr_get_packed_host(
+    const grpc_resolved_address* resolved_addr);
+
+// Applies a mask of \a mask_bits to IPv4/IPv6 addresses. Has no effect if the
+// address type is not IPv4/IPv6.
+void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
+                             uint32_t mask_bits);
+
+// If \a address is IPv4/IPv6, checks if the IP address falls in the CIDR
+// specified by \a subnet_address and \a mask_bits.
+// Returns false if \a address is not an IPv4/IPv6 address. The ports (if set)
+// are ignored for matching purposes. Note that, \a subnet_address should be
+// normalized, i.e., `grpc_sockaddr_mask_bits` should have been called on it if
+// necessary.
+bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
+                                const grpc_resolved_address* subnet_address,
+                                uint32_t mask_bits);
+
 #endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */

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

@@ -87,8 +87,9 @@ static const grpc_arg_pointer_vtable socket_factory_arg_vtable = {
     socket_factory_arg_copy, socket_factory_arg_destroy, socket_factory_cmp};
 
 grpc_arg grpc_socket_factory_to_arg(grpc_socket_factory* factory) {
-  return grpc_channel_arg_pointer_create((char*)GRPC_ARG_SOCKET_FACTORY,
-                                         factory, &socket_factory_arg_vtable);
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_SOCKET_FACTORY), factory,
+      &socket_factory_arg_vtable);
 }
 
 #endif

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

@@ -26,7 +26,7 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 
 /** The virtual table of grpc_socket_factory */
-typedef struct {
+struct grpc_socket_factory_vtable {
   /** Replacement for socket(2) */
   int (*socket)(grpc_socket_factory* factory, int domain, int type,
                 int protocol);
@@ -37,8 +37,7 @@ typedef struct {
   int (*compare)(grpc_socket_factory* a, grpc_socket_factory* b);
   /** Destroys the socket factory instance */
   void (*destroy)(grpc_socket_factory* factory);
-} grpc_socket_factory_vtable;
-
+};
 /** The Socket Factory interface allows changes on socket options */
 struct grpc_socket_factory {
   const grpc_socket_factory_vtable* vtable;

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

@@ -78,6 +78,7 @@ static const grpc_arg_pointer_vtable socket_mutator_arg_vtable = {
     socket_mutator_arg_copy, socket_mutator_arg_destroy, socket_mutator_cmp};
 
 grpc_arg grpc_socket_mutator_to_arg(grpc_socket_mutator* mutator) {
-  return grpc_channel_arg_pointer_create((char*)GRPC_ARG_SOCKET_MUTATOR,
-                                         mutator, &socket_mutator_arg_vtable);
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_SOCKET_MUTATOR), mutator,
+      &socket_mutator_arg_vtable);
 }

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

@@ -27,15 +27,14 @@
 #include <stdbool.h>
 
 /** The virtual table of grpc_socket_mutator */
-typedef struct {
+struct grpc_socket_mutator_vtable {
   /** Mutates the socket options of \a fd */
   bool (*mutate_fd)(int fd, grpc_socket_mutator* mutator);
   /** Compare socket mutator \a a and \a b */
   int (*compare)(grpc_socket_mutator* a, grpc_socket_mutator* b);
   /** Destroys the socket mutator instance */
   void (*destroy)(grpc_socket_mutator* mutator);
-} grpc_socket_mutator_vtable;
-
+};
 /** The Socket Mutator interface allows changes on socket options */
 struct grpc_socket_mutator {
   const grpc_socket_mutator_vtable* vtable;

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

@@ -41,6 +41,8 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -60,6 +62,7 @@ grpc_error* grpc_set_socket_zerocopy(int fd) {
   }
   return GRPC_ERROR_NONE;
 #else
+  (void)fd;
   return GRPC_OS_ERROR(ENOSYS, "setsockopt(SO_ZEROCOPY)");
 #endif
 }
@@ -210,7 +213,6 @@ static gpr_once g_probe_so_reuesport_once = GPR_ONCE_INIT;
 static int g_support_so_reuseport = false;
 
 void probe_so_reuseport_once(void) {
-#ifndef GPR_MANYLINUX1
   int s = socket(AF_INET, SOCK_STREAM, 0);
   if (s < 0) {
     /* This might be an ipv6-only environment in which case 'socket(AF_INET,..)'
@@ -222,7 +224,6 @@ void probe_so_reuseport_once(void) {
         "check for SO_REUSEPORT", grpc_set_socket_reuse_port(s, 1));
     close(s);
   }
-#endif
 }
 
 bool grpc_is_socket_reuse_port_supported() {
@@ -260,6 +261,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 +303,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;
-    }
-    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;
+      gpr_log(GPR_INFO, "TCP_USER_TIMEOUT not supported for this platform");
     }
   }
-#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;
 }
 
@@ -396,31 +437,12 @@ int grpc_ipv6_loopback_available(void) {
   return g_ipv6_loopback_available;
 }
 
-/* This should be 0 in production, but it may be enabled for testing or
-   debugging purposes, to simulate an environment where IPv6 sockets can't
-   also speak IPv4. */
-int grpc_forbid_dualstack_sockets_for_testing = 0;
-
-static int set_socket_dualstack(int fd) {
-  if (!grpc_forbid_dualstack_sockets_for_testing) {
-    const int off = 0;
-    return 0 == setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
-  } else {
-    /* Force an IPv6-only socket, for testing purposes. */
-    const int on = 1;
-    setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
-    return 0;
-  }
-}
-
 static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
   if (fd >= 0) return GRPC_ERROR_NONE;
-  char* addr_str;
-  grpc_sockaddr_to_string(&addr_str, addr, 0);
-  grpc_error* err = grpc_error_set_str(GRPC_OS_ERROR(errno, "socket"),
-                                       GRPC_ERROR_STR_TARGET_ADDRESS,
-                                       grpc_slice_from_copied_string(addr_str));
-  gpr_free(addr_str);
+  std::string addr_str = grpc_sockaddr_to_string(addr, false);
+  grpc_error* err = grpc_error_set_str(
+      GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
+      grpc_slice_from_copied_string(addr_str.c_str()));
   return err;
 }
 
@@ -452,7 +474,7 @@ grpc_error* grpc_create_dualstack_socket_using_factory(
       errno = EAFNOSUPPORT;
     }
     /* Check if we've got a valid dualstack socket. */
-    if (*newfd >= 0 && set_socket_dualstack(*newfd)) {
+    if (*newfd >= 0 && grpc_set_socket_dualstack(*newfd)) {
       *dsmode = GRPC_DSMODE_DUALSTACK;
       return GRPC_ERROR_NONE;
     }

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

@@ -126,6 +126,9 @@ typedef enum grpc_dualstack_mode {
 /* Only tests should use this flag. */
 extern int grpc_forbid_dualstack_sockets_for_testing;
 
+/* Tries to set the socket to dualstack. Returns 1 on success. */
+int grpc_set_socket_dualstack(int fd);
+
 /* Creates a new socket for connecting to (or listening on) an address.
 
    If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,

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.cc

@@ -22,13 +22,13 @@
 
 grpc_tcp_client_vtable* grpc_tcp_client_impl;
 
-void grpc_tcp_client_connect(grpc_closure* closure, grpc_endpoint** ep,
+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_millis deadline) {
-  grpc_tcp_client_impl->connect(closure, ep, interested_parties, channel_args,
-                                addr, deadline);
+  grpc_tcp_client_impl->connect(on_connect, endpoint, interested_parties,
+                                channel_args, addr, deadline);
 }
 
 void grpc_set_tcp_client_impl(grpc_tcp_client_vtable* impl) {

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);
@@ -143,14 +143,12 @@ static void OnOpen(void* arg, grpc_error* error) {
 
 static void ParseResolvedAddress(const grpc_resolved_address* addr,
                                  CFStringRef* host, int* port) {
-  char* host_port;
-  grpc_sockaddr_to_string(&host_port, addr, 1);
-  grpc_core::UniquePtr<char> host_string;
-  grpc_core::UniquePtr<char> port_string;
+  std::string host_port = grpc_sockaddr_to_string(addr, true);
+  std::string host_string;
+  std::string port_string;
   grpc_core::SplitHostPort(host_port, &host_string, &port_string);
-  *host =
-      CFStringCreateWithCString(NULL, host_string.get(), kCFStringEncodingUTF8);
-  gpr_free(host_port);
+  *host = CFStringCreateWithCString(NULL, host_string.c_str(),
+                                    kCFStringEncodingUTF8);
   *port = grpc_sockaddr_get_port(addr);
 }
 
@@ -159,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);
@@ -172,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);