grpc 1.34.0 → 1.37.0

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

@@ -55,8 +55,8 @@ class LockfreeEvent {
   void NotifyOn(grpc_closure* closure);
 
   // Sets the shutdown state. If a closure had been provided by NotifyOn and has
-  // not yet been scheduled, it will be scheduled with \a error.
-  bool SetShutdown(grpc_error* error);
+  // not yet been scheduled, it will be scheduled with \a shutdown_error.
+  bool SetShutdown(grpc_error* shutdown_error);
 
   // Signals that the event has been received.
   void SetReady();

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

@@ -18,18 +18,20 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "absl/strings/str_cat.h"
-
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
 #include "src/core/lib/iomgr/parse_address.h"
-#include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/socket_utils.h"
 
 #include <stdio.h>
 #include <string.h>
 #ifdef GRPC_HAVE_UNIX_SOCKET
 #include <sys/un.h>
 #endif
+#ifdef GRPC_POSIX_SOCKET
+#include <errno.h>
+#include <net/if.h>
+#endif
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/strip.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -37,21 +39,21 @@
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
-
-#ifdef GRPC_POSIX_SOCKET
-#include <errno.h>
-#include <net/if.h>
-#endif
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils.h"
 
 #ifdef GRPC_HAVE_UNIX_SOCKET
 
-bool grpc_parse_unix(const grpc_uri* uri,
+bool grpc_parse_unix(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
-  if (strcmp("unix", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'", uri->scheme);
+  if (uri.scheme() != "unix") {
+    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'",
+            uri.scheme().c_str());
     return false;
   }
-  grpc_error* error = grpc_core::UnixSockaddrPopulate(uri->path, resolved_addr);
+  grpc_error* error =
+      grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "%s", grpc_error_string(error));
     GRPC_ERROR_UNREF(error);
@@ -60,15 +62,15 @@ bool grpc_parse_unix(const grpc_uri* uri,
   return true;
 }
 
-bool grpc_parse_unix_abstract(const grpc_uri* uri,
+bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr) {
-  if (strcmp("unix-abstract", uri->scheme) != 0) {
+  if (uri.scheme() != "unix-abstract") {
     gpr_log(GPR_ERROR, "Expected 'unix-abstract' scheme, got '%s'",
-            uri->scheme);
+            uri.scheme().c_str());
     return false;
   }
   grpc_error* error =
-      grpc_core::UnixAbstractSockaddrPopulate(uri->path, resolved_addr);
+      grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
   if (error != GRPC_ERROR_NONE) {
     gpr_log(GPR_ERROR, "%s", grpc_error_string(error));
     GRPC_ERROR_UNREF(error);
@@ -120,12 +122,12 @@ grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
 
 #else  /* GRPC_HAVE_UNIX_SOCKET */
 
-bool grpc_parse_unix(const grpc_uri* uri,
+bool grpc_parse_unix(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
   abort();
 }
 
-bool grpc_parse_unix_abstract(const grpc_uri* uri,
+bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
                               grpc_resolved_address* resolved_addr) {
   abort();
 }
@@ -145,15 +147,16 @@ grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
 }  // namespace grpc_core
 #endif /* GRPC_HAVE_UNIX_SOCKET */
 
-bool grpc_parse_ipv4_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors) {
+bool grpc_parse_ipv4_hostport(absl::string_view hostport,
+                              grpc_resolved_address* addr, bool log_errors) {
   bool success = false;
   // Split host and port.
   std::string host;
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
+              std::string(hostport).c_str());
     }
     return false;
   }
@@ -185,27 +188,27 @@ done:
   return success;
 }
 
-bool grpc_parse_ipv4(const grpc_uri* uri,
+bool grpc_parse_ipv4(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
-  if (strcmp("ipv4", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'", uri->scheme);
+  if (uri.scheme() != "ipv4") {
+    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'",
+            uri.scheme().c_str());
     return false;
   }
-  const char* host_port = uri->path;
-  if (*host_port == '/') ++host_port;
-  return grpc_parse_ipv4_hostport(host_port, resolved_addr,
-                                  true /* log_errors */);
+  return grpc_parse_ipv4_hostport(absl::StripPrefix(uri.path(), "/"),
+                                  resolved_addr, true /* log_errors */);
 }
 
-bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors) {
+bool grpc_parse_ipv6_hostport(absl::string_view hostport,
+                              grpc_resolved_address* addr, bool log_errors) {
   bool success = false;
   // Split host and port.
   std::string host;
   std::string port;
   if (!grpc_core::SplitHostPort(hostport, &host, &port)) {
     if (log_errors) {
-      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)", hostport);
+      gpr_log(GPR_ERROR, "Failed gpr_split_host_port(%s, ...)",
+              std::string(hostport).c_str());
     }
     return false;
   }
@@ -280,29 +283,32 @@ done:
   return success;
 }
 
-bool grpc_parse_ipv6(const grpc_uri* uri,
+bool grpc_parse_ipv6(const grpc_core::URI& uri,
                      grpc_resolved_address* resolved_addr) {
-  if (strcmp("ipv6", uri->scheme) != 0) {
-    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'", uri->scheme);
+  if (uri.scheme() != "ipv6") {
+    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'",
+            uri.scheme().c_str());
     return false;
   }
-  const char* host_port = uri->path;
-  if (*host_port == '/') ++host_port;
-  return grpc_parse_ipv6_hostport(host_port, resolved_addr,
-                                  true /* log_errors */);
+  return grpc_parse_ipv6_hostport(absl::StripPrefix(uri.path(), "/"),
+                                  resolved_addr, true /* log_errors */);
 }
 
-bool grpc_parse_uri(const grpc_uri* uri, grpc_resolved_address* resolved_addr) {
-  if (strcmp("unix", uri->scheme) == 0) {
+bool grpc_parse_uri(const grpc_core::URI& uri,
+                    grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() == "unix") {
     return grpc_parse_unix(uri, resolved_addr);
-  } else if (strcmp("unix-abstract", uri->scheme) == 0) {
+  }
+  if (uri.scheme() == "unix-abstract") {
     return grpc_parse_unix_abstract(uri, resolved_addr);
-  } else if (strcmp("ipv4", uri->scheme) == 0) {
+  }
+  if (uri.scheme() == "ipv4") {
     return grpc_parse_ipv4(uri, resolved_addr);
-  } else if (strcmp("ipv6", uri->scheme) == 0) {
+  }
+  if (uri.scheme() == "ipv6") {
     return grpc_parse_ipv6(uri, resolved_addr);
   }
-  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri->scheme);
+  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri.scheme().c_str());
   return false;
 }
 

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

@@ -30,29 +30,33 @@
 
 /** 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_uri* uri, grpc_resolved_address* resolved_addr);
+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_uri* uri,
+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_uri* uri, grpc_resolved_address* resolved_addr);
+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_uri* uri, grpc_resolved_address* resolved_addr);
+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_uri* uri, grpc_resolved_address* resolved_addr);
+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(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors);
-bool grpc_parse_ipv6_hostport(const char* hostport, grpc_resolved_address* addr,
-                              bool log_errors);
+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);

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

@@ -36,7 +36,7 @@ inline grpc_error* grpc_socket_error(char* error) {
 }
 
 inline char* grpc_slice_buffer_start(grpc_slice_buffer* buffer, int i) {
-  return (char*)GRPC_SLICE_START_PTR(buffer->slices[i]);
+  return reinterpret_cast<char*>(GRPC_SLICE_START_PTR(buffer->slices[i]));
 }
 
 inline int grpc_slice_buffer_length(grpc_slice_buffer* buffer, int 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/resource_quota.cc

@@ -132,7 +132,7 @@ struct grpc_resource_quota {
      scaled to the range [0..RESOURCE_USAGE_ESTIMATION_MAX] */
   gpr_atm memory_usage_estimation;
 
-  /* Master combiner lock: all activity on a quota executes under this combiner
+  /* Main combiner lock: all activity on a quota executes under this combiner
    * (so no mutex is needed for this data structure) */
   grpc_core::Combiner* combiner;
   /* Size of the resource quota */
@@ -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

@@ -183,7 +183,7 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
     if (sin6_scope_id != 0) {
-      // Enclose sin6_scope_id with the format defined in RFC 6784 section 2.
+      // Enclose sin6_scope_id with the format defined in RFC 6874 section 2.
       std::string host_with_scope =
           absl::StrFormat("%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
       out = grpc_core::JoinHostPort(host_with_scope, port);
@@ -201,8 +201,8 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
 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);
@@ -215,6 +215,25 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
   grpc_sockaddr_set_port(out, port);
 }
 
+grpc_error* grpc_string_to_sockaddr_new(grpc_resolved_address* out,
+                                        const char* addr, int port) {
+  memset(out, 0, sizeof(grpc_resolved_address));
+  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);
+  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
+    addr4->sin_family = GRPC_AF_INET;
+    out->len = sizeof(grpc_sockaddr_in);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Failed to parse address:", addr).c_str());
+  }
+  grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
+}
+
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
@@ -260,9 +279,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;
@@ -273,19 +294,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:
@@ -294,3 +313,104 @@ int grpc_sockaddr_set_port(const grpc_resolved_address* resolved_addr,
       return 0;
   }
 }
+
+std::string grpc_sockaddr_get_packed_host(
+    const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family == GRPC_AF_INET) {
+    const grpc_sockaddr_in* addr4 =
+        reinterpret_cast<const grpc_sockaddr_in*>(addr);
+    const char* addr_bytes = reinterpret_cast<const char*>(&addr4->sin_addr);
+    return std::string(addr_bytes, 4);
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    const grpc_sockaddr_in6* addr6 =
+        reinterpret_cast<const grpc_sockaddr_in6*>(addr);
+    const char* addr_bytes = reinterpret_cast<const char*>(&addr6->sin6_addr);
+    return std::string(addr_bytes, 16);
+  } else {
+    GPR_ASSERT(false);
+  }
+}
+
+void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
+                             uint32_t mask_bits) {
+  grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(address->addr);
+  if (addr->sa_family == GRPC_AF_INET) {
+    grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(addr);
+    if (mask_bits == 0) {
+      memset(&addr4->sin_addr, 0, sizeof(addr4->sin_addr));
+      return;
+    } else if (mask_bits >= 32) {
+      return;
+    }
+    uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+    addr4->sin_addr.s_addr &= grpc_htonl(mask_ip_addr);
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr);
+    if (mask_bits == 0) {
+      memset(&addr6->sin6_addr, 0, sizeof(addr6->sin6_addr));
+      return;
+    } else if (mask_bits >= 128) {
+      return;
+    }
+    // We cannot use s6_addr32 since it is not defined on all platforms that we
+    // need it on.
+    uint32_t address_parts[4];
+    GPR_ASSERT(sizeof(addr6->sin6_addr) == sizeof(address_parts));
+    memcpy(address_parts, &addr6->sin6_addr, sizeof(grpc_in6_addr));
+    if (mask_bits <= 32) {
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[0] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[1], 0, sizeof(uint32_t));
+      memset(&address_parts[2], 0, sizeof(uint32_t));
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else if (mask_bits <= 64) {
+      mask_bits -= 32;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[1] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[2], 0, sizeof(uint32_t));
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else if (mask_bits <= 96) {
+      mask_bits -= 64;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[2] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else {
+      mask_bits -= 96;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[3] &= grpc_htonl(mask_ip_addr);
+    }
+    memcpy(&addr6->sin6_addr, address_parts, sizeof(grpc_in6_addr));
+  }
+}
+
+bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
+                                const grpc_resolved_address* subnet_address,
+                                uint32_t mask_bits) {
+  auto* addr = reinterpret_cast<const grpc_sockaddr*>(address->addr);
+  auto* subnet_addr =
+      reinterpret_cast<const grpc_sockaddr*>(subnet_address->addr);
+  if (addr->sa_family != subnet_addr->sa_family) return false;
+  grpc_resolved_address masked_address;
+  memcpy(&masked_address, address, sizeof(grpc_resolved_address));
+  addr = reinterpret_cast<grpc_sockaddr*>((&masked_address)->addr);
+  grpc_sockaddr_mask_bits(&masked_address, mask_bits);
+  if (addr->sa_family == GRPC_AF_INET) {
+    auto* addr4 = reinterpret_cast<const grpc_sockaddr_in*>(addr);
+    auto* subnet_addr4 = reinterpret_cast<const grpc_sockaddr_in*>(subnet_addr);
+    if (memcmp(&addr4->sin_addr, &subnet_addr4->sin_addr,
+               sizeof(addr4->sin_addr)) == 0) {
+      return true;
+    }
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    auto* addr6 = reinterpret_cast<const grpc_sockaddr_in6*>(addr);
+    auto* subnet_addr6 =
+        reinterpret_cast<const grpc_sockaddr_in6*>(subnet_addr);
+    if (memcmp(&addr6->sin6_addr, &subnet_addr6->sin6_addr,
+               sizeof(addr6->sin6_addr)) == 0) {
+      return true;
+    }
+  }
+  return false;
+}