grpc 1.35.0 → 1.38.0.pre1

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

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/parse_address.h"
+#include "src/core/lib/address_utils/parse_address.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -52,10 +52,10 @@ bool grpc_parse_unix(const grpc_core::URI& uri,
             uri.scheme().c_str());
     return false;
   }
-  grpc_error* error =
+  grpc_error_handle error =
       grpc_core::UnixSockaddrPopulate(uri.path(), resolved_addr);
   if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "%s", grpc_error_string(error));
+    gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
   }
@@ -69,10 +69,10 @@ bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
             uri.scheme().c_str());
     return false;
   }
-  grpc_error* error =
+  grpc_error_handle error =
       grpc_core::UnixAbstractSockaddrPopulate(uri.path(), resolved_addr);
   if (error != GRPC_ERROR_NONE) {
-    gpr_log(GPR_ERROR, "%s", grpc_error_string(error));
+    gpr_log(GPR_ERROR, "%s", grpc_error_std_string(error).c_str());
     GRPC_ERROR_UNREF(error);
     return false;
   }
@@ -81,8 +81,8 @@ bool grpc_parse_unix_abstract(const grpc_core::URI& uri,
 
 namespace grpc_core {
 
-grpc_error* UnixSockaddrPopulate(absl::string_view path,
-                                 grpc_resolved_address* resolved_addr) {
+grpc_error_handle UnixSockaddrPopulate(absl::string_view path,
+                                       grpc_resolved_address* resolved_addr) {
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
@@ -99,8 +99,8 @@ grpc_error* UnixSockaddrPopulate(absl::string_view path,
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
-                                         grpc_resolved_address* resolved_addr) {
+grpc_error_handle UnixAbstractSockaddrPopulate(
+    absl::string_view path, grpc_resolved_address* resolved_addr) {
   struct sockaddr_un* un =
       reinterpret_cast<struct sockaddr_un*>(resolved_addr->addr);
   const size_t maxlen = sizeof(un->sun_path) - 1;
@@ -122,25 +122,25 @@ grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
 
 #else  /* GRPC_HAVE_UNIX_SOCKET */
 
-bool grpc_parse_unix(const grpc_core::URI& uri,
-                     grpc_resolved_address* resolved_addr) {
+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) {
+bool grpc_parse_unix_abstract(const grpc_core::URI& /* uri */,
+                              grpc_resolved_address* /* resolved_addr */) {
   abort();
 }
 
 namespace grpc_core {
 
-grpc_error* UnixSockaddrPopulate(absl::string_view path,
-                                 grpc_resolved_address* resolved_addr) {
+grpc_error_handle UnixSockaddrPopulate(
+    absl::string_view /* path */, grpc_resolved_address* /* resolved_addr */) {
   abort();
 }
 
-grpc_error* UnixAbstractSockaddrPopulate(absl::string_view path,
-                                         grpc_resolved_address* resolved_addr) {
+grpc_error_handle UnixAbstractSockaddrPopulate(
+    absl::string_view /* path */, grpc_resolved_address* /* resolved_addr */) {
   abort();
 }
 

data/src/core/lib/{iomgr → address_utils}/parse_address.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H
-#define GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H
+#ifndef GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H
+#define GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -64,14 +64,14 @@ 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);
+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* UnixAbstractSockaddrPopulate(absl::string_view path,
-                                         grpc_resolved_address* resolved_addr);
+grpc_error_handle UnixAbstractSockaddrPopulate(
+    absl::string_view path, grpc_resolved_address* resolved_addr);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_IOMGR_PARSE_ADDRESS_H */
+#endif /* GRPC_CORE_LIB_ADDRESS_UTILS_PARSE_ADDRESS_H */

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

@@ -18,7 +18,7 @@
 
 #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>
@@ -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);
@@ -198,8 +198,8 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   return out;
 }
 
-void grpc_string_to_sockaddr(grpc_resolved_address* out, const 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 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
   grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
@@ -210,9 +210,11 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
     addr4->sin_family = GRPC_AF_INET;
     out->len = sizeof(grpc_sockaddr_in);
   } else {
-    GPR_ASSERT(0);
+    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) {
@@ -294,3 +296,104 @@ int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
       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;
+}

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

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H
-#define GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H
+#ifndef GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
+#define GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -64,10 +64,12 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 // 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);
+                                    bool normalize) GRPC_MUST_USE_RESULT;
 
-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_handle 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);
@@ -77,4 +79,22 @@ const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
 
 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
 
-#endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */
+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_ADDRESS_UTILS_SOCKADDR_UTILS_H */

data/src/core/lib/channel/channel_stack.cc

@@ -81,12 +81,24 @@ grpc_channel_element* grpc_channel_stack_last_element(
   return grpc_channel_stack_element(channel_stack, channel_stack->count - 1);
 }
 
+size_t grpc_channel_stack_filter_instance_number(
+    grpc_channel_stack* channel_stack, grpc_channel_element* elem) {
+  size_t num_found = 0;
+  for (size_t i = 0; i < channel_stack->count; ++i) {
+    grpc_channel_element* element =
+        grpc_channel_stack_element(channel_stack, i);
+    if (element == elem) break;
+    if (element->filter == elem->filter) ++num_found;
+  }
+  return num_found;
+}
+
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
                                            size_t index) {
   return CALL_ELEMS_FROM_STACK(call_stack) + index;
 }
 
-grpc_error* grpc_channel_stack_init(
+grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_channel_args* channel_args, grpc_transport* optional_transport,
@@ -108,7 +120,7 @@ grpc_error* grpc_channel_stack_init(
                                              sizeof(grpc_channel_element));
 
   /* init per-filter data */
-  grpc_error* first_error = GRPC_ERROR_NONE;
+  grpc_error_handle first_error = GRPC_ERROR_NONE;
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
     args.channel_args = channel_args;
@@ -117,7 +129,8 @@ grpc_error* grpc_channel_stack_init(
     args.is_last = i == (filter_count - 1);
     elems[i].filter = filters[i];
     elems[i].channel_data = user_data;
-    grpc_error* error = elems[i].filter->init_channel_elem(&elems[i], &args);
+    grpc_error_handle error =
+        elems[i].filter->init_channel_elem(&elems[i], &args);
     if (error != GRPC_ERROR_NONE) {
       if (first_error == GRPC_ERROR_NONE) {
         first_error = error;
@@ -149,10 +162,10 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   }
 }
 
-grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
-                                 int initial_refs, grpc_iomgr_cb_func destroy,
-                                 void* destroy_arg,
-                                 const grpc_call_element_args* elem_args) {
+grpc_error_handle grpc_call_stack_init(
+    grpc_channel_stack* channel_stack, int initial_refs,
+    grpc_iomgr_cb_func destroy, void* destroy_arg,
+    const grpc_call_element_args* elem_args) {
   grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
   size_t count = channel_stack->count;
   grpc_call_element* call_elems;
@@ -166,7 +179,7 @@ grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
               GPR_ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
 
   /* init per-filter data */
-  grpc_error* first_error = GRPC_ERROR_NONE;
+  grpc_error_handle first_error = GRPC_ERROR_NONE;
   for (size_t i = 0; i < count; i++) {
     call_elems[i].filter = channel_elems[i].filter;
     call_elems[i].channel_data = channel_elems[i].channel_data;
@@ -175,7 +188,7 @@ grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
         GPR_ROUND_UP_TO_ALIGNMENT_SIZE(call_elems[i].filter->sizeof_call_data);
   }
   for (size_t i = 0; i < count; i++) {
-    grpc_error* error =
+    grpc_error_handle error =
         call_elems[i].filter->init_call_elem(&call_elems[i], elem_args);
     if (error != GRPC_ERROR_NONE) {
       if (first_error == GRPC_ERROR_NONE) {

data/src/core/lib/channel/channel_stack.h

@@ -125,8 +125,8 @@ struct grpc_channel_filter {
      transport and is on the server. Most filters want to ignore this
      argument.
      Implementations may assume that elem->call_data is all zeros. */
-  grpc_error* (*init_call_elem)(grpc_call_element* elem,
-                                const grpc_call_element_args* args);
+  grpc_error_handle (*init_call_elem)(grpc_call_element* elem,
+                                      const grpc_call_element_args* args);
   void (*set_pollset_or_pollset_set)(grpc_call_element* elem,
                                      grpc_polling_entity* pollent);
   /* Destroy per call data.
@@ -148,8 +148,8 @@ struct grpc_channel_filter {
      useful for asserting correct configuration by upper layer code.
      The filter does not need to do any chaining.
      Implementations may assume that elem->channel_data is all zeros. */
-  grpc_error* (*init_channel_elem)(grpc_channel_element* elem,
-                                   grpc_channel_element_args* args);
+  grpc_error_handle (*init_channel_elem)(grpc_channel_element* elem,
+                                         grpc_channel_element_args* args);
   /* Destroy per channel data.
      The filter does not need to do any chaining */
   void (*destroy_channel_elem)(grpc_channel_element* elem);
@@ -204,6 +204,13 @@ grpc_channel_element* grpc_channel_stack_element(grpc_channel_stack* stack,
 /* Get the last channel element in a channel stack */
 grpc_channel_element* grpc_channel_stack_last_element(
     grpc_channel_stack* stack);
+
+// A utility function for a filter to determine how many other instances
+// of the same filter exist above it in the same stack.  Intended to be
+// used in the filter's init_channel_elem() method.
+size_t grpc_channel_stack_filter_instance_number(
+    grpc_channel_stack* channel_stack, grpc_channel_element* elem);
+
 /* Get a call stack element given a call stack and an index */
 grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 
@@ -211,7 +218,7 @@ grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
 size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                size_t filter_count);
 /* Initialize a channel stack given some filters */
-grpc_error* grpc_channel_stack_init(
+grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_channel_args* args, grpc_transport* optional_transport,
@@ -222,10 +229,11 @@ void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 /* Initialize a call stack given a channel stack. transport_server_data is
    expected to be NULL on a client, or an opaque transport owned pointer on the
    server. */
-grpc_error* grpc_call_stack_init(grpc_channel_stack* channel_stack,
-                                 int initial_refs, grpc_iomgr_cb_func destroy,
-                                 void* destroy_arg,
-                                 const grpc_call_element_args* elem_args);
+grpc_error_handle grpc_call_stack_init(grpc_channel_stack* channel_stack,
+                                       int initial_refs,
+                                       grpc_iomgr_cb_func destroy,
+                                       void* destroy_arg,
+                                       const grpc_call_element_args* elem_args);
 /* Set a pollset or a pollset_set for a call stack: must occur before the first
  * op is started */
 void grpc_call_stack_set_pollset_or_pollset_set(grpc_call_stack* call_stack,