grpc 1.31.1 → 1.35.0.pre1

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

@@ -0,0 +1,77 @@
+/*
+ *
+ * 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_PARSE_ADDRESS_H
+#define GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain a
+ * unix socket path. Returns true upon success. */
+bool grpc_parse_unix(const grpc_core::URI& uri,
+                     grpc_resolved_address* resolved_addr);
+
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain a
+ * unix socket path in the abstract namespace. Returns true upon success. */
+bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
+                              grpc_resolved_address* resolved_addr);
+
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
+ * IPv4 host:port pair. Returns true upon success. */
+bool grpc_parse_ipv4(const grpc_core::URI& uri,
+                     grpc_resolved_address* resolved_addr);
+
+/** Populate \a resolved_addr from \a uri, whose path is expected to contain an
+ * IPv6 host:port pair. Returns true upon success. */
+bool grpc_parse_ipv6(const grpc_core::URI& uri,
+                     grpc_resolved_address* resolved_addr);
+
+/** Populate \a resolved_addr from \a uri. Returns true upon success. */
+bool grpc_parse_uri(const grpc_core::URI& uri,
+                    grpc_resolved_address* resolved_addr);
+
+/** Parse bare IPv4 or IPv6 "IP:port" strings. */
+bool grpc_parse_ipv4_hostport(absl::string_view hostport,
+                              grpc_resolved_address* addr, bool log_errors);
+bool grpc_parse_ipv6_hostport(absl::string_view hostport,
+                              grpc_resolved_address* addr, bool log_errors);
+
+/* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
+uint16_t grpc_strhtons(const char* port);
+
+namespace grpc_core {
+
+/** Populate \a resolved_addr to be a unix socket at |path| */
+grpc_error* UnixSockaddrPopulate(absl::string_view path,
+                                 grpc_resolved_address* resolved_addr);
+
+/** Populate \a resolved_addr to be a unix socket in the abstract namespace
+ * at |path| */
+grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
+                                         grpc_resolved_address* resolved_addr);
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H */

data/src/core/lib/iomgr/poller/eventmanager_libuv.cc

@@ -63,8 +63,9 @@ bool grpc::experimental::LibuvEventManager::ShouldStop() {
 }
 
 void grpc::experimental::LibuvEventManager::Shutdown() {
-  if (should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE))
+  if (should_stop_.Load(grpc_core::MemoryOrder::ACQUIRE)) {
     return;  // Already shut down.
+  }
 
   {
     grpc_core::MutexLock lock(&shutdown_mu_);

data/src/core/lib/iomgr/poller/eventmanager_libuv.h

@@ -36,7 +36,7 @@ class LibuvEventManager {
   class Options {
    public:
     Options();
-    Options(int num_workers);
+    explicit Options(int num_workers);
 
     int num_workers() const { return num_workers_; }
     void set_num_workers(int num) { num_workers_ = num; }

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

@@ -23,7 +23,7 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 
 static grpc_pollset_set* pollset_set_create(void) {
-  return (grpc_pollset_set*)((intptr_t)0xdeafbeef);
+  return reinterpret_cast<grpc_pollset_set*>(static_cast<intptr_t>(0xdeafbeef));
 }
 
 static void pollset_set_destroy(grpc_pollset_set* /*pollset_set*/) {}

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

@@ -29,17 +29,17 @@
 // They are easier to define here (rather than in Cython)
 // because Cython doesn't handle #defines well.
 
-grpc_error* grpc_socket_error(char* error) {
+inline grpc_error* grpc_socket_error(char* error) {
   return grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error),
                             GRPC_ERROR_INT_GRPC_STATUS,
                             GRPC_STATUS_UNAVAILABLE);
 }
 
-char* grpc_slice_buffer_start(grpc_slice_buffer* buffer, int i) {
-  return (char*)GRPC_SLICE_START_PTR(buffer->slices[i]);
+inline char* grpc_slice_buffer_start(grpc_slice_buffer* buffer, int i) {
+  return reinterpret_cast<char*>(GRPC_SLICE_START_PTR(buffer->slices[i]));
 }
 
-int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
+inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int i) {
   return GRPC_SLICE_LENGTH(buffer->slices[i]);
 }
 

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

@@ -35,11 +35,11 @@ void grpc_resolve_address(const char* addr, const char* default_port,
       addr, default_port, interested_parties, on_done, addresses);
 }
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addrs) {
-  if (addrs != nullptr) {
-    gpr_free(addrs->addrs);
+void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
+  if (addresses != nullptr) {
+    gpr_free(addresses->addrs);
   }
-  gpr_free(addrs);
+  gpr_free(addresses);
 }
 
 grpc_error* grpc_blocking_resolve_address(const char* name,

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

@@ -52,11 +52,6 @@ static grpc_error* posix_blocking_resolve_address(
   size_t i;
   grpc_error* err;
 
-  if (name[0] == 'u' && name[1] == 'n' && name[2] == 'i' && name[3] == 'x' &&
-      name[4] == ':' && name[5] != 0) {
-    return grpc_resolve_unix_domain_address(name + 5, addresses);
-  }
-
   std::string host;
   std::string port;
   /* parse name, splitting it into host and port parts */
@@ -67,6 +62,7 @@ static grpc_error* posix_blocking_resolve_address(
         GRPC_ERROR_STR_TARGET_ADDRESS, grpc_slice_from_copied_string(name));
     goto done;
   }
+
   if (port.empty()) {
     if (default_port == nullptr) {
       err = grpc_error_set_str(

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

@@ -659,8 +659,8 @@ grpc_resource_quota* grpc_resource_quota_create(const char* name) {
   if (name != nullptr) {
     resource_quota->name = name;
   } else {
-    resource_quota->name =
-        absl::StrCat("anonymous_pool_", (intptr_t)resource_quota);
+    resource_quota->name = absl::StrCat(
+        "anonymous_pool_", reinterpret_cast<intptr_t>(resource_quota));
   }
   GRPC_CLOSURE_INIT(&resource_quota->rq_step_closure, rq_step, resource_quota,
                     nullptr);
@@ -807,8 +807,8 @@ grpc_resource_user* grpc_resource_user_create(
   if (name != nullptr) {
     resource_user->name = name;
   } else {
-    resource_user->name =
-        absl::StrCat("anonymous_resource_user_", (intptr_t)resource_user);
+    resource_user->name = absl::StrCat(
+        "anonymous_resource_user_", reinterpret_cast<intptr_t>(resource_user));
   }
   return resource_user;
 }

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

@@ -198,10 +198,11 @@ 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;
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
+  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
   if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
     addr6->sin6_family = GRPC_AF_INET6;
     out->len = sizeof(grpc_sockaddr_in6);
@@ -259,9 +260,11 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
       reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
   switch (addr->sa_family) {
     case GRPC_AF_INET:
-      return grpc_ntohs(((grpc_sockaddr_in*)addr)->sin_port);
+      return grpc_ntohs(
+          (reinterpret_cast<const grpc_sockaddr_in*>(addr))->sin_port);
     case GRPC_AF_INET6:
-      return grpc_ntohs(((grpc_sockaddr_in6*)addr)->sin6_port);
+      return grpc_ntohs(
+          (reinterpret_cast<const grpc_sockaddr_in6*>(addr))->sin6_port);
     default:
       if (grpc_is_unix_socket(resolved_addr)) {
         return 1;
@@ -272,19 +275,17 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
   }
 }
 
-int grpc_sockaddr_set_port(const grpc_resolved_address* resolved_addr,
-                           int port) {
-  const grpc_sockaddr* addr =
-      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
+  grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(resolved_addr->addr);
   switch (addr->sa_family) {
     case GRPC_AF_INET:
       GPR_ASSERT(port >= 0 && port < 65536);
-      ((grpc_sockaddr_in*)addr)->sin_port =
+      (reinterpret_cast<grpc_sockaddr_in*>(addr))->sin_port =
           grpc_htons(static_cast<uint16_t>(port));
       return 1;
     case GRPC_AF_INET6:
       GPR_ASSERT(port >= 0 && port < 65536);
-      ((grpc_sockaddr_in6*)addr)->sin6_port =
+      (reinterpret_cast<grpc_sockaddr_in6*>(addr))->sin6_port =
           grpc_htons(static_cast<uint16_t>(port));
       return 1;
     default:

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

@@ -56,7 +56,7 @@ 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);
+int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 
 // Converts a sockaddr into a newly-allocated human-readable string.
 //
@@ -66,7 +66,8 @@ 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 */
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);

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_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/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_custom.cc

@@ -61,7 +61,7 @@ static void custom_close_callback(grpc_custom_socket* /*socket*/) {}
 
 static void on_alarm(void* acp, grpc_error* error) {
   int done;
-  grpc_custom_socket* socket = (grpc_custom_socket*)acp;
+  grpc_custom_socket* socket = static_cast<grpc_custom_socket*>(acp);
   grpc_custom_tcp_connect* connect = socket->connector;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     const char* str = grpc_error_string(error);
@@ -124,13 +124,14 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
     for (size_t i = 0; i < channel_args->num_args; i++) {
       if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
         grpc_resource_quota_unref_internal(resource_quota);
-        resource_quota = grpc_resource_quota_ref_internal(
-            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
+        resource_quota =
+            grpc_resource_quota_ref_internal(static_cast<grpc_resource_quota*>(
+                channel_args->args[i].value.pointer.p));
       }
     }
   }
   grpc_custom_socket* socket =
-      (grpc_custom_socket*)gpr_malloc(sizeof(grpc_custom_socket));
+      static_cast<grpc_custom_socket*>(gpr_malloc(sizeof(grpc_custom_socket)));
   socket->refs = 2;
   grpc_custom_socket_vtable->init(socket, GRPC_AF_UNSPEC);
   grpc_custom_tcp_connect* connect = new grpc_custom_tcp_connect();
@@ -153,8 +154,8 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                     grpc_schedule_on_exec_ctx);
   grpc_timer_init(&connect->alarm, deadline, &connect->on_alarm);
   grpc_custom_socket_vtable->connect(
-      socket, (const grpc_sockaddr*)resolved_addr->addr, resolved_addr->len,
-      custom_connect_callback);
+      socket, reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr),
+      resolved_addr->len, custom_connect_callback);
 }
 
 grpc_tcp_client_vtable custom_tcp_client_vtable = {tcp_connect};

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

@@ -32,6 +32,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/resource_quota.h"
+#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -57,24 +58,25 @@ struct custom_tcp_endpoint {
   gpr_refcount refcount;
   grpc_custom_socket* socket;
 
-  grpc_closure* read_cb;
-  grpc_closure* write_cb;
+  grpc_closure* read_cb = nullptr;
+  grpc_closure* write_cb = nullptr;
 
-  grpc_slice_buffer* read_slices;
-  grpc_slice_buffer* write_slices;
+  grpc_slice_buffer* read_slices = nullptr;
+  grpc_slice_buffer* write_slices = nullptr;
 
   grpc_resource_user* resource_user;
   grpc_resource_user_slice_allocator slice_allocator;
 
   bool shutting_down;
 
-  char* peer_string;
+  std::string peer_string;
+  std::string local_address;
 };
 static void tcp_free(grpc_custom_socket* s) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)s->endpoint;
+  custom_tcp_endpoint* tcp =
+      reinterpret_cast<custom_tcp_endpoint*>(s->endpoint);
   grpc_resource_user_unref(tcp->resource_user);
-  gpr_free(tcp->peer_string);
-  gpr_free(tcp);
+  delete tcp;
   s->refs--;
   if (s->refs == 0) {
     grpc_custom_socket_vtable->destroy(s);
@@ -132,7 +134,8 @@ static void call_read_cb(custom_tcp_endpoint* tcp, grpc_error* error) {
     for (i = 0; i < tcp->read_slices->count; i++) {
       char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp, tcp->peer_string, dump);
+      gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp, tcp->peer_string.c_str(),
+              dump);
       gpr_free(dump);
     }
   }
@@ -147,18 +150,19 @@ static void custom_read_callback(grpc_custom_socket* socket, size_t nread,
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_slice_buffer garbage;
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
+  custom_tcp_endpoint* tcp =
+      reinterpret_cast<custom_tcp_endpoint*>(socket->endpoint);
   if (error == GRPC_ERROR_NONE && nread == 0) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("EOF");
   }
   if (error == GRPC_ERROR_NONE) {
     // Successful read
-    if ((size_t)nread < tcp->read_slices->length) {
+    if (nread < tcp->read_slices->length) {
       /* TODO(murgatroid99): Instead of discarding the unused part of the read
        * buffer, reuse it as the next read buffer. */
       grpc_slice_buffer_init(&garbage);
-      grpc_slice_buffer_trim_end(
-          tcp->read_slices, tcp->read_slices->length - (size_t)nread, &garbage);
+      grpc_slice_buffer_trim_end(tcp->read_slices,
+                                 tcp->read_slices->length - nread, &garbage);
       grpc_slice_buffer_reset_and_unref_internal(&garbage);
     }
   } else {
@@ -168,7 +172,7 @@ static void custom_read_callback(grpc_custom_socket* socket, size_t nread,
 }
 
 static void tcp_read_allocation_done(void* tcpp, grpc_error* error) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)tcpp;
+  custom_tcp_endpoint* tcp = static_cast<custom_tcp_endpoint*>(tcpp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "TCP:%p read_allocation_done: %s", tcp->socket,
             grpc_error_string(error));
@@ -177,7 +181,8 @@ static void tcp_read_allocation_done(void* tcpp, grpc_error* error) {
     /* Before calling read, we allocate a buffer with exactly one slice
      * to tcp->read_slices and wait for the callback indicating that the
      * allocation was successful. So slices[0] should always exist here */
-    char* buffer = (char*)GRPC_SLICE_START_PTR(tcp->read_slices->slices[0]);
+    char* buffer = reinterpret_cast<char*>(
+        GRPC_SLICE_START_PTR(tcp->read_slices->slices[0]));
     size_t len = GRPC_SLICE_LENGTH(tcp->read_slices->slices[0]);
     grpc_custom_socket_vtable->read(tcp->socket, buffer, len,
                                     custom_read_callback);
@@ -193,7 +198,7 @@ static void tcp_read_allocation_done(void* tcpp, grpc_error* error) {
 
 static void endpoint_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
                           grpc_closure* cb, bool /*urgent*/) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
   GPR_ASSERT(tcp->read_cb == nullptr);
   tcp->read_cb = cb;
@@ -211,7 +216,8 @@ static void custom_write_callback(grpc_custom_socket* socket,
                                   grpc_error* error) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
+  custom_tcp_endpoint* tcp =
+      reinterpret_cast<custom_tcp_endpoint*>(socket->endpoint);
   grpc_closure* cb = tcp->write_cb;
   tcp->write_cb = nullptr;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
@@ -224,7 +230,7 @@ static void custom_write_callback(grpc_custom_socket* socket,
 
 static void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* write_slices,
                            grpc_closure* cb, void* /*arg*/) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
   GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
@@ -233,8 +239,8 @@ static void endpoint_write(grpc_endpoint* ep, grpc_slice_buffer* write_slices,
     for (j = 0; j < write_slices->count; j++) {
       char* data = grpc_dump_slice(write_slices->slices[j],
                                    GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp->socket, tcp->peer_string,
-              data);
+      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp->socket,
+              tcp->peer_string.c_str(), data);
       gpr_free(data);
     }
   }
@@ -282,7 +288,7 @@ static void endpoint_delete_from_pollset_set(grpc_endpoint* ep,
 }
 
 static void endpoint_shutdown(grpc_endpoint* ep, grpc_error* why) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
   if (!tcp->shutting_down) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
       const char* str = grpc_error_string(why);
@@ -307,23 +313,29 @@ static void custom_close_callback(grpc_custom_socket* socket) {
   } else if (socket->endpoint) {
     grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
     grpc_core::ExecCtx exec_ctx;
-    custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)socket->endpoint;
+    custom_tcp_endpoint* tcp =
+        reinterpret_cast<custom_tcp_endpoint*>(socket->endpoint);
     TCP_UNREF(tcp, "destroy");
   }
 }
 
 static void endpoint_destroy(grpc_endpoint* ep) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
   grpc_custom_socket_vtable->close(tcp->socket, custom_close_callback);
 }
 
-static char* endpoint_get_peer(grpc_endpoint* ep) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
-  return gpr_strdup(tcp->peer_string);
+static absl::string_view endpoint_get_peer(grpc_endpoint* ep) {
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
+  return tcp->peer_string;
+}
+
+static absl::string_view endpoint_get_local_address(grpc_endpoint* ep) {
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
+  return tcp->local_address;
 }
 
 static grpc_resource_user* endpoint_get_resource_user(grpc_endpoint* ep) {
-  custom_tcp_endpoint* tcp = (custom_tcp_endpoint*)ep;
+  custom_tcp_endpoint* tcp = reinterpret_cast<custom_tcp_endpoint*>(ep);
   return tcp->resource_user;
 }
 
@@ -340,27 +352,36 @@ static grpc_endpoint_vtable vtable = {endpoint_read,
                                       endpoint_destroy,
                                       endpoint_get_resource_user,
                                       endpoint_get_peer,
+                                      endpoint_get_local_address,
                                       endpoint_get_fd,
                                       endpoint_can_track_err};
 
 grpc_endpoint* custom_tcp_endpoint_create(grpc_custom_socket* socket,
                                           grpc_resource_quota* resource_quota,
                                           const char* peer_string) {
-  custom_tcp_endpoint* tcp =
-      (custom_tcp_endpoint*)gpr_malloc(sizeof(custom_tcp_endpoint));
+  custom_tcp_endpoint* tcp = new custom_tcp_endpoint;
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "Creating TCP endpoint %p", socket);
   }
-  memset(tcp, 0, sizeof(custom_tcp_endpoint));
   socket->refs++;
-  socket->endpoint = (grpc_endpoint*)tcp;
+  socket->endpoint = reinterpret_cast<grpc_endpoint*>(tcp);
   tcp->socket = socket;
   tcp->base.vtable = &vtable;
   gpr_ref_init(&tcp->refcount, 1);
-  tcp->peer_string = gpr_strdup(peer_string);
+  tcp->peer_string = peer_string;
+  grpc_resolved_address resolved_local_addr;
+  resolved_local_addr.len = sizeof(resolved_local_addr.addr);
+  if (grpc_custom_socket_vtable->getsockname(
+          socket, reinterpret_cast<sockaddr*>(resolved_local_addr.addr),
+          reinterpret_cast<int*>(&resolved_local_addr.len)) !=
+      GRPC_ERROR_NONE) {
+    tcp->local_address = "";
+  } else {
+    tcp->local_address = grpc_sockaddr_to_uri(&resolved_local_addr);
+  }
   tcp->shutting_down = false;
   tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);
   grpc_resource_user_slice_allocator_init(