grpc 1.58.0 → 1.62.0

data/src/core/ext/xds/xds_endpoint.cc

@@ -23,6 +23,7 @@
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <set>
 #include <vector>
 
@@ -33,7 +34,6 @@
 #include "absl/types/optional.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
-#include "envoy/config/core/v3/health_check.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upb.h"
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "envoy/config/endpoint/v3/endpoint_components.upb.h"
@@ -44,25 +44,41 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/xds/upb_utils.h"
-#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_health_status.h"
 #include "src/core/ext/xds/xds_resource_type.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 
+// IWYU pragma: no_include "absl/meta/type_traits.h"
+
 namespace grpc_core {
 
+namespace {
+
+// TODO(roth): Remove this once dualstack support is stable.
+bool XdsDualstackEndpointsEnabled() {
+  auto value = GetEnv("GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
+}  // namespace
+
 //
 // XdsEndpointResource
 //
 
 std::string XdsEndpointResource::Priority::Locality::ToString() const {
   std::vector<std::string> endpoint_strings;
-  for (const ServerAddress& endpoint : endpoints) {
+  for (const EndpointAddresses& endpoint : endpoints) {
     endpoint_strings.emplace_back(endpoint.ToString());
   }
   return absl::StrCat("{name=", name->AsHumanReadableString(),
@@ -126,8 +142,9 @@ std::string XdsEndpointResource::ToString() const {
     priority_strings.emplace_back(
         absl::StrCat("priority ", i, ": ", priority.ToString()));
   }
-  return absl::StrCat("priorities=[", absl::StrJoin(priority_strings, ", "),
-                      "], drop_config=", drop_config->ToString());
+  return absl::StrCat(
+      "priorities=[", absl::StrJoin(priority_strings, ", "), "], drop_config=",
+      drop_config == nullptr ? "<null>" : drop_config->ToString());
 }
 
 //
@@ -145,23 +162,51 @@ void MaybeLogClusterLoadAssignment(
         envoy_config_endpoint_v3_ClusterLoadAssignment_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_TextEncode(cla, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(cla), msg_type, nullptr,
+                   0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] ClusterLoadAssignment: %s",
             context.client, buf);
   }
 }
 
-absl::optional<ServerAddress> ServerAddressParse(
+absl::optional<grpc_resolved_address> ParseCoreAddress(
+    const envoy_config_core_v3_Address* address, ValidationErrors* errors) {
+  if (address == nullptr) {
+    errors->AddError("field not present");
+    return absl::nullopt;
+  }
+  ValidationErrors::ScopedField field(errors, ".socket_address");
+  const envoy_config_core_v3_SocketAddress* socket_address =
+      envoy_config_core_v3_Address_socket_address(address);
+  if (socket_address == nullptr) {
+    errors->AddError("field not present");
+    return absl::nullopt;
+  }
+  std::string address_str = UpbStringToStdString(
+      envoy_config_core_v3_SocketAddress_address(socket_address));
+  uint32_t port;
+  {
+    ValidationErrors::ScopedField field(errors, ".port_value");
+    port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
+    if (GPR_UNLIKELY(port >> 16) != 0) {
+      errors->AddError("invalid port");
+      return absl::nullopt;
+    }
+  }
+  auto addr = StringToSockaddr(address_str, port);
+  if (!addr.ok()) {
+    errors->AddError(addr.status().message());
+    return absl::nullopt;
+  }
+  return *addr;
+}
+
+absl::optional<EndpointAddresses> EndpointAddressesParse(
     const envoy_config_endpoint_v3_LbEndpoint* lb_endpoint,
     ValidationErrors* errors) {
   // health_status
   const int32_t health_status =
       envoy_config_endpoint_v3_LbEndpoint_health_status(lb_endpoint);
-  if (!XdsOverrideHostEnabled() &&
-      health_status != envoy_config_core_v3_UNKNOWN &&
-      health_status != envoy_config_core_v3_HEALTHY) {
-    return absl::nullopt;
-  }
   auto status = XdsHealthStatus::FromUpb(health_status);
   if (!status.has_value()) return absl::nullopt;
   // load_balancing_weight
@@ -178,7 +223,7 @@ absl::optional<ServerAddress> ServerAddressParse(
     }
   }
   // endpoint
-  grpc_resolved_address grpc_address;
+  std::vector<grpc_resolved_address> addresses;
   {
     ValidationErrors::ScopedField field(errors, ".endpoint");
     const envoy_config_endpoint_v3_Endpoint* endpoint =
@@ -187,43 +232,34 @@ absl::optional<ServerAddress> ServerAddressParse(
       errors->AddError("field not present");
       return absl::nullopt;
     }
-    ValidationErrors::ScopedField field2(errors, ".address");
-    const envoy_config_core_v3_Address* address =
-        envoy_config_endpoint_v3_Endpoint_address(endpoint);
-    if (address == nullptr) {
-      errors->AddError("field not present");
-      return absl::nullopt;
-    }
-    ValidationErrors::ScopedField field3(errors, ".socket_address");
-    const envoy_config_core_v3_SocketAddress* socket_address =
-        envoy_config_core_v3_Address_socket_address(address);
-    if (socket_address == nullptr) {
-      errors->AddError("field not present");
-      return absl::nullopt;
-    }
-    std::string address_str = UpbStringToStdString(
-        envoy_config_core_v3_SocketAddress_address(socket_address));
-    uint32_t port;
     {
-      ValidationErrors::ScopedField field(errors, ".port_value");
-      port = envoy_config_core_v3_SocketAddress_port_value(socket_address);
-      if (GPR_UNLIKELY(port >> 16) != 0) {
-        errors->AddError("invalid port");
-        return absl::nullopt;
-      }
+      ValidationErrors::ScopedField field(errors, ".address");
+      auto address = ParseCoreAddress(
+          envoy_config_endpoint_v3_Endpoint_address(endpoint), errors);
+      if (address.has_value()) addresses.push_back(*address);
     }
-    auto addr = StringToSockaddr(address_str, port);
-    if (!addr.ok()) {
-      errors->AddError(addr.status().message());
-    } else {
-      grpc_address = *addr;
+    if (XdsDualstackEndpointsEnabled()) {
+      size_t size;
+      auto* additional_addresses =
+          envoy_config_endpoint_v3_Endpoint_additional_addresses(endpoint,
+                                                                 &size);
+      for (size_t i = 0; i < size; ++i) {
+        ValidationErrors::ScopedField field(
+            errors, absl::StrCat(".additional_addresses[", i, "].address"));
+        auto address = ParseCoreAddress(
+            envoy_config_endpoint_v3_Endpoint_AdditionalAddress_address(
+                additional_addresses[i]),
+            errors);
+        if (address.has_value()) addresses.push_back(*address);
+      }
     }
   }
-  // Convert to ServerAddress.
-  return ServerAddress(grpc_address,
-                       ChannelArgs()
-                           .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
-                           .Set(GRPC_ARG_XDS_HEALTH_STATUS, status->status()));
+  if (addresses.empty()) return absl::nullopt;
+  // Convert to EndpointAddresses.
+  return EndpointAddresses(
+      addresses, ChannelArgs()
+                     .Set(GRPC_ARG_ADDRESS_WEIGHT, weight)
+                     .Set(GRPC_ARG_XDS_HEALTH_STATUS, status->status()));
 }
 
 struct ParsedLocality {
@@ -283,16 +319,17 @@ absl::optional<ParsedLocality> LocalityParse(
   for (size_t i = 0; i < size; ++i) {
     ValidationErrors::ScopedField field(errors,
                                         absl::StrCat(".lb_endpoints[", i, "]"));
-    auto address = ServerAddressParse(lb_endpoints[i], errors);
-    if (address.has_value()) {
-      bool inserted = address_set->insert(address->address()).second;
-      if (!inserted) {
-        errors->AddError(absl::StrCat(
-            "duplicate endpoint address \"",
-            grpc_sockaddr_to_uri(&address->address()).value_or("<unknown>"),
-            "\""));
+    auto endpoint = EndpointAddressesParse(lb_endpoints[i], errors);
+    if (endpoint.has_value()) {
+      for (const auto& address : endpoint->addresses()) {
+        bool inserted = address_set->insert(address).second;
+        if (!inserted) {
+          errors->AddError(absl::StrCat(
+              "duplicate endpoint address \"",
+              grpc_sockaddr_to_uri(&address).value_or("<unknown>"), "\""));
+        }
       }
-      parsed_locality.locality.endpoints.push_back(std::move(*address));
+      parsed_locality.locality.endpoints.push_back(std::move(*endpoint));
     }
   }
   // priority
@@ -353,12 +390,12 @@ void DropParseAndAppend(
   drop_config->AddCategory(std::move(category), numerator);
 }
 
-absl::StatusOr<XdsEndpointResource> EdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsEndpointResource>> EdsResourceParse(
     const XdsResourceType::DecodeContext& /*context*/,
     const envoy_config_endpoint_v3_ClusterLoadAssignment*
         cluster_load_assignment) {
   ValidationErrors errors;
-  XdsEndpointResource eds_resource;
+  auto eds_resource = std::make_shared<XdsEndpointResource>();
   // endpoints
   {
     ValidationErrors::ScopedField field(&errors, "endpoints");
@@ -374,11 +411,11 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
         GPR_ASSERT(parsed_locality->locality.lb_weight != 0);
         // Make sure prorities is big enough. Note that they might not
         // arrive in priority order.
-        if (eds_resource.priorities.size() < parsed_locality->priority + 1) {
-          eds_resource.priorities.resize(parsed_locality->priority + 1);
+        if (eds_resource->priorities.size() < parsed_locality->priority + 1) {
+          eds_resource->priorities.resize(parsed_locality->priority + 1);
         }
         auto& locality_map =
-            eds_resource.priorities[parsed_locality->priority].localities;
+            eds_resource->priorities[parsed_locality->priority].localities;
         auto it = locality_map.find(parsed_locality->locality.name.get());
         if (it != locality_map.end()) {
           errors.AddError(absl::StrCat(
@@ -391,8 +428,8 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
         }
       }
     }
-    for (size_t i = 0; i < eds_resource.priorities.size(); ++i) {
-      const auto& priority = eds_resource.priorities[i];
+    for (size_t i = 0; i < eds_resource->priorities.size(); ++i) {
+      const auto& priority = eds_resource->priorities[i];
       if (priority.localities.empty()) {
         errors.AddError(absl::StrCat("priority ", i, " empty"));
       } else {
@@ -412,7 +449,6 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     }
   }
   // policy
-  eds_resource.drop_config = MakeRefCounted<XdsEndpointResource::DropConfig>();
   const auto* policy = envoy_config_endpoint_v3_ClusterLoadAssignment_policy(
       cluster_load_assignment);
   if (policy != nullptr) {
@@ -421,10 +457,14 @@ absl::StatusOr<XdsEndpointResource> EdsResourceParse(
     const auto* const* drop_overload =
         envoy_config_endpoint_v3_ClusterLoadAssignment_Policy_drop_overloads(
             policy, &drop_size);
+    if (drop_size > 0) {
+      eds_resource->drop_config =
+          MakeRefCounted<XdsEndpointResource::DropConfig>();
+    }
     for (size_t i = 0; i < drop_size; ++i) {
       ValidationErrors::ScopedField field(
           &errors, absl::StrCat(".drop_overloads[", i, "]"));
-      DropParseAndAppend(drop_overload[i], eds_resource.drop_config.get(),
+      DropParseAndAppend(drop_overload[i], eds_resource->drop_config.get(),
                          &errors);
     }
   }
@@ -466,10 +506,9 @@ XdsResourceType::DecodeResult XdsEndpointResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed ClusterLoadAssignment %s: %s",
               context.client, result.name->c_str(),
-              eds_resource->ToString().c_str());
+              (*eds_resource)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsEndpointResource>(std::move(*eds_resource));
+    result.resource = std::move(*eds_resource);
   }
   return result;
 }

data/src/core/ext/xds/xds_endpoint.h

@@ -23,7 +23,6 @@
 
 #include <algorithm>
 #include <map>
-#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -41,7 +40,7 @@
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -50,7 +49,7 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
     struct Locality {
       RefCountedPtr<XdsLocalityName> name;
       uint32_t lb_weight;
-      ServerAddressList endpoints;
+      EndpointAddressesList endpoints;
 
       bool operator==(const Locality& other) const {
         return *name == *other.name && lb_weight == other.lb_weight &&
@@ -63,6 +62,7 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
     std::map<XdsLocalityName*, Locality, XdsLocalityName::Less> localities;
 
     bool operator==(const Priority& other) const;
+    bool operator!=(const Priority& other) const { return !(*this == other); }
     std::string ToString() const;
   };
   using PriorityList = std::vector<Priority>;
@@ -122,7 +122,10 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
   RefCountedPtr<DropConfig> drop_config;
 
   bool operator==(const XdsEndpointResource& other) const {
-    return priorities == other.priorities && *drop_config == *other.drop_config;
+    if (priorities != other.priorities) return false;
+    if (drop_config == nullptr) return other.drop_config == nullptr;
+    if (other.drop_config == nullptr) return false;
+    return *drop_config == *other.drop_config;
   }
   std::string ToString() const;
 };

data/src/core/ext/xds/xds_health_status.cc

@@ -18,6 +18,10 @@
 
 #include "src/core/ext/xds/xds_health_status.h"
 
+#include <string>
+
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
 #include "envoy/config/core/v3/health_check.upb.h"
 
 namespace grpc_core {
@@ -56,8 +60,16 @@ const char* XdsHealthStatus::ToString() const {
   }
 }
 
-bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2) {
-  return hs1.status() < hs2.status();
+std::string XdsHealthStatusSet::ToString() const {
+  std::vector<const char*> set;
+  set.reserve(3);
+  for (const auto& status :
+       {XdsHealthStatus::kUnknown, XdsHealthStatus::kHealthy,
+        XdsHealthStatus::kDraining}) {
+    const XdsHealthStatus health_status(status);
+    if (Contains(health_status)) set.push_back(health_status.ToString());
+  }
+  return absl::StrCat("{", absl::StrJoin(set, ", "), "}");
 }
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_health_status.h

@@ -25,7 +25,7 @@
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 
-#include "src/core/lib/resolver/server_address.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 // Channel arg key for xDS health status.
 // Value is an XdsHealthStatus::HealthStatus enum.
@@ -70,6 +70,8 @@ class XdsHealthStatusSet {
     return status_mask_ == other.status_mask_;
   }
 
+  bool Empty() const { return status_mask_ == 0; }
+
   void Clear() { status_mask_ = 0; }
 
   void Add(XdsHealthStatus status) { status_mask_ |= (0x1 << status.status()); }
@@ -78,12 +80,12 @@ class XdsHealthStatusSet {
     return status_mask_ & (0x1 << status.status());
   }
 
+  std::string ToString() const;
+
  private:
   int status_mask_ = 0;
 };
 
-bool operator<(const XdsHealthStatus& hs1, const XdsHealthStatus& hs2);
-
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_XDS_XDS_HEALTH_STATUS_H

data/src/core/ext/xds/xds_http_filters.cc

@@ -18,7 +18,6 @@
 
 #include "src/core/ext/xds/xds_http_filters.h"
 
-#include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ -29,7 +28,6 @@
 
 #include <grpc/support/log.h>
 
-#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_http_fault_filter.h"
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
 #include "src/core/ext/xds/xds_http_stateful_session_filter.h"
@@ -88,9 +86,7 @@ XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
     RegisterFilter(std::make_unique<XdsHttpRouterFilter>());
     RegisterFilter(std::make_unique<XdsHttpFaultFilter>());
     RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
-    if (XdsOverrideHostEnabled()) {
-      RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
-    }
+    RegisterFilter(std::make_unique<XdsHttpStatefulSessionFilter>());
   }
 }
 

data/src/core/ext/xds/xds_http_rbac_filter.cc

@@ -40,7 +40,7 @@
 #include "envoy/type/matcher/v3/string.upb.h"
 #include "envoy/type/v3/range.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/collections/map.h"
+#include "upb/message/map.h"
 
 #include <grpc/support/json.h>
 
@@ -486,8 +486,10 @@ Json ParseHttpRbacToJson(const XdsResourceType::DecodeContext& context,
           ValidationErrors::ScopedField field(errors, ".audit_condition");
           errors->AddError("invalid audit condition");
       }
-      if (envoy_config_rbac_v3_RBAC_AuditLoggingOptions_has_logger_configs(
-              audit_logging_options)) {
+      size_t size;
+      envoy_config_rbac_v3_RBAC_AuditLoggingOptions_logger_configs(
+          audit_logging_options, &size);
+      if (size != 0) {
         inner_rbac_json.emplace("audit_loggers",
                                 ParseAuditLoggerConfigsToJson(
                                     context, audit_logging_options, errors));

data/src/core/ext/xds/xds_http_stateful_session_filter.cc

@@ -77,7 +77,6 @@ Json::Object ValidateStatefulSession(
       envoy_extensions_filters_http_stateful_session_v3_StatefulSession_session_state(
           stateful_session);
   if (session_state == nullptr) {
-    errors->AddError("field not present");
     return {};
   }
   ValidationErrors::ScopedField field2(errors, ".typed_config");
@@ -188,9 +187,7 @@ XdsHttpStatefulSessionFilter::GenerateFilterConfigOverride(
     const auto* stateful_session =
         envoy_extensions_filters_http_stateful_session_v3_StatefulSessionPerRoute_stateful_session(
             stateful_session_per_route);
-    if (stateful_session == nullptr) {
-      errors->AddError("field not present");
-    } else {
+    if (stateful_session != nullptr) {
       config = ValidateStatefulSession(context, stateful_session, errors);
     }
   }

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -40,7 +40,7 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
 
 namespace grpc_core {
 

data/src/core/ext/xds/xds_listener.cc

@@ -20,7 +20,6 @@
 
 #include <stdint.h>
 
-#include <initializer_list>
 #include <set>
 #include <utility>
 
@@ -37,7 +36,6 @@
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/listener/v3/listener.upbdefs.h"
 #include "envoy/config/listener/v3/listener_components.upb.h"
-#include "envoy/config/rbac/v3/rbac.upb.h"
 #include "envoy/config/route/v3/route.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upb.h"
 #include "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.upbdefs.h"
@@ -45,7 +43,6 @@
 #include "google/protobuf/any.upb.h"
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/wrappers.upb.h"
-#include "upb/base/string_view.h"
 #include "upb/text/encode.h"
 
 #include <grpc/support/log.h>
@@ -60,6 +57,7 @@
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/matchers/matchers.h"
 
 namespace grpc_core {
 
@@ -74,8 +72,8 @@ std::string XdsListenerResource::HttpConnectionManager::ToString() const {
       [](const std::string& rds_name) {
         return absl::StrCat("rds_name=", rds_name);
       },
-      [](const XdsRouteConfigResource& route_config) {
-        return absl::StrCat("route_config=", route_config.ToString());
+      [](const std::shared_ptr<const XdsRouteConfigResource>& route_config) {
+        return absl::StrCat("route_config=", route_config->ToString());
       }));
   contents.push_back(absl::StrCat("http_max_stream_duration=",
                                   http_max_stream_duration.ToString()));
@@ -293,8 +291,9 @@ void MaybeLogHttpConnectionManager(
         envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_getmsgdef(
             context.symtab);
     char buf[10240];
-    upb_TextEncode(http_connection_manager_config, msg_type, nullptr, 0, buf,
-                   sizeof(buf));
+    upb_TextEncode(
+        reinterpret_cast<const upb_Message*>(http_connection_manager_config),
+        msg_type, nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] HttpConnectionManager: %s",
             context.client, buf);
   }
@@ -334,11 +333,15 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   }
   // original_ip_detection_extensions -- must be empty as per
   // https://github.com/grpc/proposal/blob/master/A41-xds-rbac.md
-  if (envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_has_original_ip_detection_extensions(
-          http_connection_manager_proto)) {
-    ValidationErrors::ScopedField field(errors,
-                                        ".original_ip_detection_extensions");
-    errors->AddError("must be empty");
+  {
+    size_t size;
+    envoy_extensions_filters_network_http_connection_manager_v3_HttpConnectionManager_original_ip_detection_extensions(
+        http_connection_manager_proto, &size);
+    if (size != 0) {
+      ValidationErrors::ScopedField field(errors,
+                                          ".original_ip_detection_extensions");
+      errors->AddError("must be empty");
+    }
   }
   // common_http_protocol_options
   const envoy_config_core_v3_HttpProtocolOptions* options =
@@ -490,17 +493,18 @@ XdsListenerResource::HttpConnectionManager HttpConnectionManagerParse(
   return http_connection_manager;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseClient(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseClient(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_ApiListener* api_listener) {
-  XdsListenerResource lds_update;
+  auto lds_update = std::make_shared<XdsListenerResource>();
   ValidationErrors errors;
   ValidationErrors::ScopedField field(&errors, "api_listener.api_listener");
   auto* api_listener_field =
       envoy_config_listener_v3_ApiListener_api_listener(api_listener);
   auto extension = ExtractXdsExtension(context, api_listener_field, &errors);
   if (extension.has_value()) {
-    lds_update.listener = HttpConnectionManagerParse(
+    lds_update->listener = HttpConnectionManagerParse(
         /*is_client=*/true, context, std::move(*extension), &errors);
   }
   if (!errors.ok()) {
@@ -991,9 +995,9 @@ XdsListenerResource::FilterChainMap BuildFilterChainMap(
   return BuildFromInternalFilterChainMap(&internal_filter_chain_map);
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
-    const XdsResourceType::DecodeContext& context,
-    const envoy_config_listener_v3_Listener* listener) {
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>>
+LdsResourceParseServer(const XdsResourceType::DecodeContext& context,
+                       const envoy_config_listener_v3_Listener* listener) {
   ValidationErrors errors;
   XdsListenerResource::TcpListener tcp_listener;
   // address
@@ -1054,12 +1058,12 @@ absl::StatusOr<XdsListenerResource> LdsResourceParseServer(
     return errors.status(absl::StatusCode::kInvalidArgument,
                          "errors validating server Listener");
   }
-  XdsListenerResource lds_update;
-  lds_update.listener = std::move(tcp_listener);
+  auto lds_update = std::make_shared<XdsListenerResource>();
+  lds_update->listener = std::move(tcp_listener);
   return lds_update;
 }
 
-absl::StatusOr<XdsListenerResource> LdsResourceParse(
+absl::StatusOr<std::shared_ptr<const XdsListenerResource>> LdsResourceParse(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_listener_v3_Listener* listener) {
   // Check whether it's a client or server listener.
@@ -1092,7 +1096,8 @@ void MaybeLogListener(const XdsResourceType::DecodeContext& context,
     const upb_MessageDef* msg_type =
         envoy_config_listener_v3_Listener_getmsgdef(context.symtab);
     char buf[10240];
-    upb_TextEncode(listener, msg_type, nullptr, 0, buf, sizeof(buf));
+    upb_TextEncode(reinterpret_cast<const upb_Message*>(listener), msg_type,
+                   nullptr, 0, buf, sizeof(buf));
     gpr_log(GPR_DEBUG, "[xds_client %p] Listener: %s", context.client, buf);
   }
 }
@@ -1127,10 +1132,9 @@ XdsResourceType::DecodeResult XdsListenerResourceType::Decode(
     if (GRPC_TRACE_FLAG_ENABLED(*context.tracer)) {
       gpr_log(GPR_INFO, "[xds_client %p] parsed Listener %s: %s",
               context.client, result.name->c_str(),
-              listener->ToString().c_str());
+              (*listener)->ToString().c_str());
     }
-    result.resource =
-        std::make_unique<XdsListenerResource>(std::move(*listener));
+    result.resource = std::move(*listener);
   }
   return result;
 }