grpc 1.28.0 → 1.42.0

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

@@ -0,0 +1,320 @@
+/*
+ *
+ * Copyright 2016 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/address_utils/parse_address.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>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/host_port.h"
+#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_core::URI& uri,
+                     grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() != "unix") {
+    gpr_log(GPR_ERROR, "Expected 'unix' scheme, got '%s'",
+            uri.scheme().c_str());
+    return false;
+  }
+  grpc_error_handle error =
+      grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
+    GRPC_ERROR_UNREF(error);
+    return false;
+  }
+  return true;
+}
+
+bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
+                              grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() != "unix-abstract") {
+    gpr_log(GPR_ERROR, "Expected 'unix-abstract' scheme, got '%s'",
+            uri.scheme().c_str());
+    return false;
+  }
+  grpc_error_handle error =
+      grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
+  if (error != GRPC_ERROR_NONE) {
+    gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
+    GRPC_ERROR_UNREF(error);
+    return false;
+  }
+  return true;
+}
+
+namespace grpc_core {
+
+grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
+                                       grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
+  struct sockaddr_un* un =
+      reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
+  const size_t maxlen = sizeof(un->sun_path) - 1;
+  if (path.size() > maxlen) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
+  }
+  un->sun_family = AF_UNIX;
+  path.copy(un->sun_path, path.size());
+  un->sun_path[path.size()] = '\0';
+  resolved_addr->len = static_cast<socklen_t>(sizeof(*un));
+  return GRPC_ERROR_NONE;
+}
+
+grpc_error_handle UnixAbstractSockaddrPopulate(
+    absl::string_view path, grpc_resolved_address* resolved_addr) {
+  memset(resolved_addr, 0, sizeof(*resolved_addr));
+  struct sockaddr_un* un =
+      reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
+  const size_t maxlen = sizeof(un->sun_path) - 1;
+  if (path.size() > maxlen) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
+        "Path name should not have more than ", maxlen, " characters"));
+  }
+  un->sun_family = AF_UNIX;
+  un->sun_path[0] = '\0';
+  path.copy(un->sun_path + 1, path.size());
+  resolved_addr->len =
+      static_cast<socklen_t>(sizeof(un->sun_family) + path.size() + 1);
+  return GRPC_ERROR_NONE;
+}
+
+}  // namespace grpc_core
+
+#else  /* GRPC_HAVE_UNIX_SOCKET */
+
+bool grpc_parse_unix(const grpc_core::URI& /* uri */,
+                     grpc_resolved_address* /* resolved_addr */) {
+  abort();
+}
+
+bool grpc_parse_unix_abstract(const grpc_core::URI& /* uri */,
+                              grpc_resolved_address* /* resolved_addr */) {
+  abort();
+}
+
+namespace grpc_core {
+
+grpc_error_handle UnixSockaddrPopulate(
+    absl::string_view /* path */, grpc_resolved_address* /* resolved_addr */) {
+  abort();
+}
+
+grpc_error_handle UnixAbstractSockaddrPopulate(
+    absl::string_view /* path */, grpc_resolved_address* /* resolved_addr */) {
+  abort();
+}
+
+}  // namespace grpc_core
+#endif /* GRPC_HAVE_UNIX_SOCKET */
+
+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, ...)",
+              std::string(hostport).c_str());
+    }
+    return false;
+  }
+  // Parse IP address.
+  memset(addr, 0, sizeof(*addr));
+  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
+  grpc_sockaddr_in* in = reinterpret_cast<grpc_sockaddr_in*>(addr->addr);
+  in->sin_family = GRPC_AF_INET;
+  if (grpc_inet_pton(GRPC_AF_INET, host.c_str(), &in->sin_addr) == 0) {
+    if (log_errors) {
+      gpr_log(GPR_ERROR, "invalid ipv4 address: '%s'", host.c_str());
+    }
+    goto done;
+  }
+  // Parse port.
+  if (port.empty()) {
+    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
+    goto done;
+  }
+  int port_num;
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
+      port_num > 65535) {
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port.c_str());
+    goto done;
+  }
+  in->sin_port = grpc_htons(static_cast<uint16_t>(port_num));
+  success = true;
+done:
+  return success;
+}
+
+bool grpc_parse_ipv4(const grpc_core::URI& uri,
+                     grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() != "ipv4") {
+    gpr_log(GPR_ERROR, "Expected 'ipv4' scheme, got '%s'",
+            uri.scheme().c_str());
+    return false;
+  }
+  return grpc_parse_ipv4_hostport(absl::StripPrefix(uri.path(), "/"),
+                                  resolved_addr, true /* 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, ...)",
+              std::string(hostport).c_str());
+    }
+    return false;
+  }
+  // Parse IP address.
+  memset(addr, 0, sizeof(*addr));
+  addr->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
+  grpc_sockaddr_in6* in6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr);
+  in6->sin6_family = GRPC_AF_INET6;
+  // Handle the RFC6874 syntax for IPv6 zone identifiers.
+  char* host_end =
+      static_cast<char*>(gpr_memrchr(host.c_str(), '%', host.size()));
+  if (host_end != nullptr) {
+    GPR_ASSERT(host_end >= host.c_str());
+    char host_without_scope[GRPC_INET6_ADDRSTRLEN + 1];
+    size_t host_without_scope_len =
+        static_cast<size_t>(host_end - host.c_str());
+    uint32_t sin6_scope_id = 0;
+    if (host_without_scope_len > GRPC_INET6_ADDRSTRLEN) {
+      if (log_errors) {
+        gpr_log(
+            GPR_ERROR,
+            "invalid ipv6 address length %zu. Length cannot be greater than "
+            "GRPC_INET6_ADDRSTRLEN i.e %d)",
+            host_without_scope_len, GRPC_INET6_ADDRSTRLEN);
+      }
+      goto done;
+    }
+    strncpy(host_without_scope, host.c_str(), host_without_scope_len);
+    host_without_scope[host_without_scope_len] = '\0';
+    if (grpc_inet_pton(GRPC_AF_INET6, host_without_scope, &in6->sin6_addr) ==
+        0) {
+      if (log_errors) {
+        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host_without_scope);
+      }
+      goto done;
+    }
+    if (gpr_parse_bytes_to_uint32(host_end + 1,
+                                  host.size() - host_without_scope_len - 1,
+                                  &sin6_scope_id) == 0) {
+      if ((sin6_scope_id = grpc_if_nametoindex(host_end + 1)) == 0) {
+        gpr_log(GPR_ERROR,
+                "Invalid interface name: '%s'. "
+                "Non-numeric and failed if_nametoindex.",
+                host_end + 1);
+        goto done;
+      }
+    }
+    // Handle "sin6_scope_id" being type "u_long". See grpc issue #10027.
+    in6->sin6_scope_id = sin6_scope_id;
+  } else {
+    if (grpc_inet_pton(GRPC_AF_INET6, host.c_str(), &in6->sin6_addr) == 0) {
+      if (log_errors) {
+        gpr_log(GPR_ERROR, "invalid ipv6 address: '%s'", host.c_str());
+      }
+      goto done;
+    }
+  }
+  // Parse port.
+  if (port.empty()) {
+    if (log_errors) gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
+    goto done;
+  }
+  int port_num;
+  if (sscanf(port.c_str(), "%d", &port_num) != 1 || port_num < 0 ||
+      port_num > 65535) {
+    if (log_errors) gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port.c_str());
+    goto done;
+  }
+  in6->sin6_port = grpc_htons(static_cast<uint16_t>(port_num));
+  success = true;
+done:
+  return success;
+}
+
+bool grpc_parse_ipv6(const grpc_core::URI& uri,
+                     grpc_resolved_address* resolved_addr) {
+  if (uri.scheme() != "ipv6") {
+    gpr_log(GPR_ERROR, "Expected 'ipv6' scheme, got '%s'",
+            uri.scheme().c_str());
+    return false;
+  }
+  return grpc_parse_ipv6_hostport(absl::StripPrefix(uri.path(), "/"),
+                                  resolved_addr, true /* log_errors */);
+}
+
+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);
+  }
+  if (uri.scheme() == "unix-abstract") {
+    return grpc_parse_unix_abstract(uri, resolved_addr);
+  }
+  if (uri.scheme() == "ipv4") {
+    return grpc_parse_ipv4(uri, resolved_addr);
+  }
+  if (uri.scheme() == "ipv6") {
+    return grpc_parse_ipv6(uri, resolved_addr);
+  }
+  gpr_log(GPR_ERROR, "Can't parse scheme '%s'", uri.scheme().c_str());
+  return false;
+}
+
+uint16_t grpc_strhtons(const char* port) {
+  if (strcmp(port, "http") == 0) {
+    return htons(80);
+  } else if (strcmp(port, "https") == 0) {
+    return htons(443);
+  }
+  return htons(static_cast<unsigned short>(atoi(port)));
+}

data/src/core/lib/address_utils/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_ADDRESS_UTILS_PARSE_ADDRESS_H
+#define GRPC_CORE_LIB_ADDRESS_UTILS_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_handle 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_handle UnixAbstractSockaddrPopulate(
+    absl::string_view path, grpc_resolved_address* resolved_addr);
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H */

data/src/core/lib/{iomgr → address_utils}/sockaddr_utils.cc

@@ -18,18 +18,24 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/sockaddr_utils.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 
 #include <errno.h>
 #include <inttypes.h>
 #include <string.h>
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
+
+#include <grpc/event_engine/event_engine.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"
+#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
@@ -150,23 +156,18 @@ void grpc_sockaddr_make_wildcard6(int port,
   resolved_wild_out->len = static_cast<socklen_t>(sizeof(grpc_sockaddr_in6));
 }
 
-int grpc_sockaddr_to_string(char** out,
-                            const grpc_resolved_address* resolved_addr,
-                            int normalize) {
-  const grpc_sockaddr* addr;
+std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
+                                    bool normalize) {
   const int save_errno = errno;
   grpc_resolved_address addr_normalized;
-  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
-  const void* ip = nullptr;
-  int port = 0;
-  uint32_t sin6_scope_id = 0;
-  int ret;
-
-  *out = nullptr;
   if (normalize && grpc_sockaddr_is_v4mapped(resolved_addr, &addr_normalized)) {
     resolved_addr = &addr_normalized;
   }
-  addr = reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  const void* ip = nullptr;
+  int port = 0;
+  uint32_t sin6_scope_id = 0;
   if (addr->sa_family == GRPC_AF_INET) {
     const grpc_sockaddr_in* addr4 =
         reinterpret_cast<const grpc_sockaddr_in*>(addr);
@@ -179,31 +180,31 @@ int grpc_sockaddr_to_string(char** out,
     port = grpc_ntohs(addr6->sin6_port);
     sin6_scope_id = addr6->sin6_scope_id;
   }
+  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
+  std::string out;
   if (ip != nullptr && grpc_inet_ntop(addr->sa_family, ip, ntop_buf,
                                       sizeof(ntop_buf)) != nullptr) {
-    grpc_core::UniquePtr<char> tmp_out;
     if (sin6_scope_id != 0) {
-      char* host_with_scope;
-      /* Enclose sin6_scope_id with the format defined in RFC 6784 section 2. */
-      gpr_asprintf(&host_with_scope, "%s%%25%" PRIu32, ntop_buf, sin6_scope_id);
-      ret = grpc_core::JoinHostPort(&tmp_out, host_with_scope, port);
-      gpr_free(host_with_scope);
+      // 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);
     } else {
-      ret = grpc_core::JoinHostPort(&tmp_out, ntop_buf, port);
+      out = grpc_core::JoinHostPort(ntop_buf, port);
     }
-    *out = tmp_out.release();
   } else {
-    ret = gpr_asprintf(out, "(sockaddr family=%d)", addr->sa_family);
+    out = absl::StrFormat("(sockaddr family=%d)", addr->sa_family);
   }
   /* This is probably redundant, but we wouldn't want to log the wrong error. */
   errno = save_errno;
-  return ret;
+  return out;
 }
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
+grpc_error_handle 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);
@@ -211,13 +212,15 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, char* addr, int port) {
     addr4->sin_family = GRPC_AF_INET;
     out->len = sizeof(grpc_sockaddr_in);
   } else {
-    GPR_ASSERT(0);
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
   }
   grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
 }
 
-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;
@@ -226,15 +229,13 @@ char* grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (scheme == nullptr || strcmp("unix", scheme) == 0) {
     return grpc_sockaddr_to_uri_unix_if_possible(resolved_addr);
   }
-  char* path = nullptr;
-  char* uri_str = nullptr;
-  if (grpc_sockaddr_to_string(&path, resolved_addr,
-                              false /* suppress errors */) &&
-      scheme != nullptr) {
-    gpr_asprintf(&uri_str, "%s:%s", scheme, path);
+  std::string path =
+      grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
+  std::string uri_str;
+  if (scheme != nullptr) {
+    uri_str = absl::StrCat(scheme, ":", path);
   }
-  gpr_free(path);
-  return uri_str != nullptr ? uri_str : nullptr;
+  return uri_str;
 }
 
 const char* grpc_sockaddr_get_uri_scheme(
@@ -263,9 +264,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;
@@ -276,19 +279,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:
@@ -297,3 +298,115 @@ 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;
+}
+
+namespace grpc_event_engine {
+namespace experimental {
+
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
+  auto gra = CreateGRPCResolvedAddress(addr);
+  return grpc_sockaddr_to_uri(&gra);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine