grpc 1.82.0 → 1.83.0.pre1

data/src/core/xds/grpc/xds_common_types.cc

@@ -17,11 +17,16 @@
 #include "src/core/xds/grpc/xds_common_types.h"
 
 #include <string>
+#include <utility>
 
+#include "src/core/call/metadata_batch.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/util/match.h"
 #include "src/core/util/string.h"
-#include "src/core/util/time.h"
+#include "absl/status/status.h"
 #include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
@@ -115,43 +120,6 @@ bool CommonTlsContext::Empty() const {
          certificate_validation_context.Empty();
 }
 
-//
-// XdsGrpcService
-//
-
-std::string XdsGrpcService::ToString() const {
-  std::string result = "{";
-  bool is_first = true;
-  if (server_target != nullptr) {
-    StrAppend(result, "server_target=");
-    StrAppend(result, server_target->Key());
-    is_first = false;
-  }
-  if (timeout != Duration::Zero()) {
-    if (!is_first) StrAppend(result, ", ");
-    StrAppend(result, "timeout=");
-    StrAppend(result, timeout.ToString());
-    is_first = false;
-  }
-  if (!initial_metadata.empty()) {
-    if (!is_first) StrAppend(result, ", ");
-    StrAppend(result, "initial_metadata=[");
-    bool is_first_metadata = true;
-    for (const auto& metadata : initial_metadata) {
-      if (!is_first_metadata) StrAppend(result, ", ");
-      StrAppend(result, "{key=");
-      StrAppend(result, metadata.first);
-      StrAppend(result, ", value=");
-      StrAppend(result, metadata.second);
-      StrAppend(result, "}");
-      is_first_metadata = false;
-    }
-    StrAppend(result, "]");
-  }
-  StrAppend(result, "}");
-  return result;
-}
-
 //
 // HeaderMutationRules
 //
@@ -210,4 +178,92 @@ std::string HeaderMutationRules::ToString() const {
   return result;
 }
 
+//
+// XdsHeaderValueOption
+//
+
+namespace {
+
+void ApplyHeaderValueOptionMutation(const XdsHeaderValueOption& header,
+                                    grpc_metadata_batch& md) {
+  auto& [header_key, header_value] = header.header;
+  std::string buffer;
+  auto existing_value = md.GetStringValue(header_key, &buffer);
+  switch (header.append_action) {
+    case XdsHeaderValueOption::AppendAction::kAppendIfExistsOrAdd: {
+      if (!existing_value.has_value()) {
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      } else if (!header_value.empty()) {
+        std::string concatenated_val =
+            absl::StrCat(*existing_value, ",", header_value);
+        md.Remove(absl::string_view(header_key));
+        md.Append(header_key,
+                  Slice::FromCopiedString(std::move(concatenated_val)),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kAddIfAbsent: {
+      if (!existing_value.has_value()) {
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kOverwriteIfExists: {
+      if (existing_value.has_value()) {
+        md.Remove(absl::string_view(header_key));
+        md.Append(header_key, Slice::FromCopiedString(header_value),
+                  [](absl::string_view, const Slice&) {});
+      }
+      break;
+    }
+    case XdsHeaderValueOption::AppendAction::kOverwriteIfExistsOrAdd: {
+      md.Remove(absl::string_view(header_key));
+      md.Append(header_key, Slice::FromCopiedString(header_value),
+                [](absl::string_view, const Slice&) {});
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+absl::Status ApplyXdsHeaderMutationsRemoval(absl::string_view remove_header,
+                                            const HeaderMutationRules* rules,
+                                            grpc_metadata_batch& md) {
+  bool allowed = true;
+  bool disallow_is_error = false;
+  if (rules != nullptr) {
+    allowed = rules->IsMutationAllowed(std::string(remove_header));
+    disallow_is_error = rules->disallow_is_error;
+  }
+  if (allowed) {
+    md.Remove(absl::string_view(remove_header));
+  } else if (disallow_is_error) {
+    return absl::InternalError(
+        absl::StrCat("Forbidden header removal: ", remove_header));
+  }
+  return absl::OkStatus();
+}
+
+absl::Status ApplyXdsHeaderMutationsAddition(
+    const XdsHeaderValueOption& set_header, const HeaderMutationRules* rules,
+    grpc_metadata_batch& md) {
+  bool allowed = true;
+  bool disallow_is_error = false;
+  if (rules != nullptr) {
+    allowed = rules->IsMutationAllowed(std::string(set_header.header.first));
+    disallow_is_error = rules->disallow_is_error;
+  }
+  if (allowed) {
+    ApplyHeaderValueOptionMutation(set_header, md);
+  } else if (disallow_is_error) {
+    return absl::InternalError(
+        absl::StrCat("Forbidden header mutation: ", set_header.header.first));
+  }
+  return absl::OkStatus();
+}
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_common_types.h

@@ -23,11 +23,11 @@
 #include <variant>
 #include <vector>
 
+#include "src/core/call/metadata_batch.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/matchers.h"
-#include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
-#include "src/core/xds/grpc/xds_server_grpc.h"
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
@@ -89,22 +89,6 @@ struct XdsExtension {
   std::vector<ValidationErrors::ScopedField> validation_fields;
 };
 
-struct XdsGrpcService {
-  std::unique_ptr<GrpcXdsServerTarget> server_target;
-  Duration timeout;
-  std::vector<std::pair<std::string, std::string>> initial_metadata;
-
-  bool operator==(const XdsGrpcService& other) const {
-    if (timeout != other.timeout) return false;
-    if (initial_metadata != other.initial_metadata) return false;
-    if (server_target == nullptr) return other.server_target == nullptr;
-    if (other.server_target == nullptr) return false;
-    return server_target->Equals(*other.server_target);
-  }
-
-  std::string ToString() const;
-};
-
 struct HeaderMutationRules {
   bool disallow_all = false;
   bool disallow_is_error = false;
@@ -129,6 +113,37 @@ struct HeaderMutationRules {
   }
 };
 
+struct XdsHeaderValueOption {
+  enum class AppendAction {
+    // If the header already exists in the metadata batch, comma-concatenate the
+    // new value.
+    // Otherwise, append a new metadata entry.
+    kAppendIfExistsOrAdd = 0,
+    // Add the header only if it is not currently present in the metadata batch.
+    kAddIfAbsent = 1,
+    // Discard any existing entries in the metadata batch and append the new
+    // value.
+    kOverwriteIfExistsOrAdd = 2,
+    // If the header already exists, discard existing entries and replace with
+    // the new value.
+    // If absent, do nothing.
+    kOverwriteIfExists = 3
+  };
+
+  // The targeted metadata key and value to apply during mutation.
+  std::pair<std::string, std::string> header;
+  // Rule specifying how to merge or overwrite existing metadata batch entries.
+  AppendAction append_action;
+};
+
+absl::Status ApplyXdsHeaderMutationsRemoval(absl::string_view remove_header,
+                                            const HeaderMutationRules* rules,
+                                            grpc_metadata_batch& md);
+
+absl::Status ApplyXdsHeaderMutationsAddition(
+    const XdsHeaderValueOption& set_header, const HeaderMutationRules* rules,
+    grpc_metadata_batch& md);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_H

data/src/core/xds/grpc/xds_common_types_parser.cc

@@ -26,6 +26,7 @@
 #include <string>
 #include <utility>
 
+#include "envoy/config/common/mutation_rules/v3/mutation_rules.upb.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/extensions/transport_sockets/tls/v3/common.upb.h"
@@ -39,11 +40,11 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/util/down_cast.h"
-#include "src/core/util/env.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/upb_utils.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/xds_client/xds_client.h"
 #include "upb/base/status.hpp"
 #include "upb/json/encode.h"
@@ -618,7 +619,7 @@ std::optional<XdsExtension> ExtractXdsExtension(
 }
 
 //
-// ParseXdsGrpcService()
+// ParseXdsHeader()
 //
 
 namespace {
@@ -645,7 +646,9 @@ std::optional<std::string> GetHeaderValue(upb_StringView upb_value,
   return std::string(value);
 }
 
-std::pair<std::string, std::string> ParseHeader(
+}  // namespace
+
+std::pair<std::string, std::string> ParseXdsHeader(
     const envoy_config_core_v3_HeaderValue* header_value,
     ValidationErrors* errors) {
   // key
@@ -682,35 +685,42 @@ std::pair<std::string, std::string> ParseHeader(
   return {std::string(key), value.has_value() ? std::move(*value) : ""};
 }
 
-}  // namespace
+//
+// ParseXdsGrpcService()
+//
 
-XdsGrpcService ParseXdsGrpcService(
+GrpcXdsServerTarget ParseXdsGrpcService(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_core_v3_GrpcService* grpc_service,
     ValidationErrors* errors) {
   if (grpc_service == nullptr) {
     errors->AddError("field not set");
-    return {};
+    return GrpcXdsServerTarget(/*server_uri=*/"",
+                               /*channel_creds_config=*/nullptr,
+                               /*call_creds_configs=*/{});
   }
-  XdsGrpcService xds_grpc_service;
   // timeout
-  if (auto* timeout = envoy_config_core_v3_GrpcService_timeout(grpc_service);
-      timeout != nullptr) {
+  Duration timeout = Duration::Zero();
+  if (auto* timeout_proto =
+          envoy_config_core_v3_GrpcService_timeout(grpc_service);
+      timeout_proto != nullptr) {
     ValidationErrors::ScopedField field(errors, ".timeout");
-    xds_grpc_service.timeout = ParseDuration(timeout, errors);
-    if (xds_grpc_service.timeout <= Duration::Zero()) {
+    timeout = ParseDuration(timeout_proto, errors);
+    if (timeout <= Duration::Zero()) {
       errors->AddError("duration must be positive");
     }
   }
   // initial_metadata
+  std::vector<std::pair<std::string, std::string>> initial_metadata;
   size_t initial_metadata_size;
-  auto* initial_metadata = envoy_config_core_v3_GrpcService_initial_metadata(
-      grpc_service, &initial_metadata_size);
+  auto* initial_metadata_proto =
+      envoy_config_core_v3_GrpcService_initial_metadata(grpc_service,
+                                                        &initial_metadata_size);
   for (size_t i = 0; i < initial_metadata_size; ++i) {
     ValidationErrors::ScopedField field(
         errors, absl::StrCat(".initial_metadata[", i, "]"));
-    xds_grpc_service.initial_metadata.push_back(
-        ParseHeader(initial_metadata[i], errors));
+    initial_metadata.push_back(
+        ParseXdsHeader(initial_metadata_proto[i], errors));
   }
   // google_grpc
   ValidationErrors::ScopedField field(errors, ".google_grpc");
@@ -718,103 +728,103 @@ XdsGrpcService ParseXdsGrpcService(
       envoy_config_core_v3_GrpcService_google_grpc(grpc_service);
   if (google_grpc == nullptr) {
     errors->AddError("field not set");
-  } else {
-    // target_uri
-    std::string target_uri = UpbStringToStdString(
-        envoy_config_core_v3_GrpcService_GoogleGrpc_target_uri(google_grpc));
-    if (!CoreConfiguration::Get().resolver_registry().IsValidTarget(
-            target_uri)) {
-      ValidationErrors::ScopedField field(errors, ".target_uri");
-      errors->AddError("invalid target URI");
-    }
-    // credentials
-    RefCountedPtr<const ChannelCredsConfig> channel_creds_config;
-    std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
-    if (DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
-      // Trusted xDS server.  Use credentials from the GoogleGrpc proto.
-      // First, look at channel creds.
-      {
-        ValidationErrors::ScopedField field(errors,
-                                            ".channel_credentials_plugin");
-        size_t size;
-        const auto* const* channel_creds_plugin =
-            envoy_config_core_v3_GrpcService_GoogleGrpc_channel_credentials_plugin(
-                google_grpc, &size);
-        if (size == 0) {
-          errors->AddError("field not set");
-        } else {
-          const auto& registry =
-              CoreConfiguration::Get().channel_creds_registry();
-          const auto& certificate_providers =
-              DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
-                  .certificate_providers();
-          for (size_t i = 0; i < size; ++i) {
-            ValidationErrors::ScopedField field(errors,
-                                                absl::StrCat("[", i, "]"));
-            absl::string_view type = UpbStringToAbsl(
-                google_protobuf_Any_type_url(channel_creds_plugin[i]));
-            if (!StripTypePrefix(type, errors)) continue;
-            if (!registry.IsProtoSupported(type)) continue;
-            ValidationErrors::ScopedField field2(errors, ".value");
-            absl::string_view serialized_config = UpbStringToAbsl(
-                google_protobuf_Any_value(channel_creds_plugin[i]));
-            channel_creds_config = registry.ParseProto(
-                type, serialized_config, certificate_providers, errors);
-            break;
-          }
-          if (channel_creds_config == nullptr) {
-            errors->AddError("no supported channel credentials type found");
-          }
-        }
-      }
-      // Now look at call creds.
-      {
-        ValidationErrors::ScopedField field(errors, ".call_credentials_plugin");
-        size_t size;
-        const auto* const* call_creds_plugin =
-            envoy_config_core_v3_GrpcService_GoogleGrpc_call_credentials_plugin(
-                google_grpc, &size);
-        const auto& registry = CoreConfiguration::Get().call_creds_registry();
+    return GrpcXdsServerTarget(/*server_uri=*/"",
+                               /*channel_creds_config=*/nullptr,
+                               /*call_creds_configs=*/{});
+  }
+  // target_uri
+  std::string target_uri = UpbStringToStdString(
+      envoy_config_core_v3_GrpcService_GoogleGrpc_target_uri(google_grpc));
+  if (!CoreConfiguration::Get().resolver_registry().IsValidTarget(target_uri)) {
+    ValidationErrors::ScopedField field(errors, ".target_uri");
+    errors->AddError("invalid target URI");
+  }
+  // credentials
+  RefCountedPtr<const ChannelCredsConfig> channel_creds_config;
+  std::vector<RefCountedPtr<const CallCredsConfig>> call_creds_configs;
+  if (DownCast<const GrpcXdsServer&>(context.server).TrustedXdsServer()) {
+    // Trusted xDS server.  Use credentials from the GoogleGrpc proto.
+    // First, look at channel creds.
+    {
+      ValidationErrors::ScopedField field(errors,
+                                          ".channel_credentials_plugin");
+      size_t size;
+      const auto* const* channel_creds_plugin =
+          envoy_config_core_v3_GrpcService_GoogleGrpc_channel_credentials_plugin(
+              google_grpc, &size);
+      if (size == 0) {
+        errors->AddError("field not set");
+      } else {
+        const auto& registry =
+            CoreConfiguration::Get().channel_creds_registry();
+        const auto& certificate_providers =
+            DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap())
+                .certificate_providers();
         for (size_t i = 0; i < size; ++i) {
           ValidationErrors::ScopedField field(errors,
                                               absl::StrCat("[", i, "]"));
           absl::string_view type = UpbStringToAbsl(
-              google_protobuf_Any_type_url(call_creds_plugin[i]));
+              google_protobuf_Any_type_url(channel_creds_plugin[i]));
           if (!StripTypePrefix(type, errors)) continue;
           if (!registry.IsProtoSupported(type)) continue;
           ValidationErrors::ScopedField field2(errors, ".value");
-          absl::string_view serialized_config =
-              UpbStringToAbsl(google_protobuf_Any_value(call_creds_plugin[i]));
-          call_creds_configs.push_back(
-              registry.ParseProto(type, serialized_config, errors));
+          absl::string_view serialized_config = UpbStringToAbsl(
+              google_protobuf_Any_value(channel_creds_plugin[i]));
+          channel_creds_config = registry.ParseProto(
+              type, serialized_config, certificate_providers, errors);
+          break;
+        }
+        if (channel_creds_config == nullptr) {
+          errors->AddError("no supported channel credentials type found");
         }
       }
-    } else {
-      // Not a trusted xDS server.  Do lookup in bootstrap.
-      const auto& bootstrap =
-          DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap());
-      auto& allowed_grpc_services = bootstrap.allowed_grpc_services();
-      auto it = allowed_grpc_services.find(target_uri);
-      if (it == allowed_grpc_services.end()) {
-        ValidationErrors::ScopedField field(errors, ".target_uri");
-        errors->AddError(
-            "service not present in \"allowed_grpc_services\" "
-            "in bootstrap config");
-      } else {
-        channel_creds_config = it->second.channel_creds_config;
-        call_creds_configs = it->second.call_creds_configs;
+    }
+    // Now look at call creds.
+    {
+      ValidationErrors::ScopedField field(errors, ".call_credentials_plugin");
+      size_t size;
+      const auto* const* call_creds_plugin =
+          envoy_config_core_v3_GrpcService_GoogleGrpc_call_credentials_plugin(
+              google_grpc, &size);
+      const auto& registry = CoreConfiguration::Get().call_creds_registry();
+      for (size_t i = 0; i < size; ++i) {
+        ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
+        absl::string_view type =
+            UpbStringToAbsl(google_protobuf_Any_type_url(call_creds_plugin[i]));
+        if (!StripTypePrefix(type, errors)) continue;
+        if (!registry.IsProtoSupported(type)) continue;
+        ValidationErrors::ScopedField field2(errors, ".value");
+        absl::string_view serialized_config =
+            UpbStringToAbsl(google_protobuf_Any_value(call_creds_plugin[i]));
+        call_creds_configs.push_back(
+            registry.ParseProto(type, serialized_config, errors));
       }
     }
-    xds_grpc_service.server_target = std::make_unique<GrpcXdsServerTarget>(
-        target_uri, std::move(channel_creds_config),
-        std::move(call_creds_configs));
+  } else {
+    // Not a trusted xDS server.  Do lookup in bootstrap.
+    const auto& bootstrap =
+        DownCast<const GrpcXdsBootstrap&>(context.client->bootstrap());
+    auto& allowed_grpc_services = bootstrap.allowed_grpc_services();
+    auto it = allowed_grpc_services.find(target_uri);
+    if (it == allowed_grpc_services.end()) {
+      ValidationErrors::ScopedField field(errors, ".target_uri");
+      errors->AddError(
+          "service not present in \"allowed_grpc_services\" "
+          "in bootstrap config");
+    } else {
+      channel_creds_config = it->second.channel_creds_config;
+      call_creds_configs = it->second.call_creds_configs;
+    }
   }
-  return xds_grpc_service;
+  return GrpcXdsServerTarget(target_uri, std::move(channel_creds_config),
+                             std::move(call_creds_configs),
+                             std::move(initial_metadata), timeout);
 }
 
 //
 // ParseHeaderMutationRules()
 //
+
 namespace {
 
 std::unique_ptr<RE2> ParseRegexMatcher(
@@ -842,13 +852,15 @@ HeaderMutationRules ParseHeaderMutationRules(
     return {};
   }
   HeaderMutationRules header_mutation_rules_config;
-  header_mutation_rules_config.disallow_all =
+  header_mutation_rules_config.disallow_all = ParseBoolValue(
       envoy_config_common_mutation_rules_v3_HeaderMutationRules_disallow_all(
-          header_mutation_rules);
-  header_mutation_rules_config.disallow_is_error =
+          header_mutation_rules));
+  const google_protobuf_BoolValue* disallow_is_error_proto =
       envoy_config_common_mutation_rules_v3_HeaderMutationRules_disallow_is_error(
           header_mutation_rules);
-  const auto* disallow_expression_proto =
+  header_mutation_rules_config.disallow_is_error =
+      ParseBoolValue(disallow_is_error_proto);
+  const envoy_type_matcher_v3_RegexMatcher* disallow_expression_proto =
       envoy_config_common_mutation_rules_v3_HeaderMutationRules_disallow_expression(
           header_mutation_rules);
   if (disallow_expression_proto != nullptr) {
@@ -857,7 +869,7 @@ HeaderMutationRules ParseHeaderMutationRules(
     header_mutation_rules_config.disallow_expression =
         ParseRegexMatcher(disallow_expression_proto, errors);
   }
-  const auto* allow_expression_proto =
+  const envoy_type_matcher_v3_RegexMatcher* allow_expression_proto =
       envoy_config_common_mutation_rules_v3_HeaderMutationRules_allow_expression(
           header_mutation_rules);
   if (allow_expression_proto != nullptr) {
@@ -869,4 +881,60 @@ HeaderMutationRules ParseHeaderMutationRules(
   return header_mutation_rules_config;
 }
 
+//
+// ParseXdsHeaderValueOption()
+//
+
+namespace {
+
+XdsHeaderValueOption::AppendAction ParseXdsHeaderValueOptionAppendAction(
+    int32_t header_value_option_append_action, ValidationErrors* errors) {
+  switch (header_value_option_append_action) {
+    case envoy_config_core_v3_HeaderValueOption_APPEND_IF_EXISTS_OR_ADD:
+      return XdsHeaderValueOption::AppendAction::kAppendIfExistsOrAdd;
+    case envoy_config_core_v3_HeaderValueOption_ADD_IF_ABSENT:
+      return XdsHeaderValueOption::AppendAction::kAddIfAbsent;
+    case envoy_config_core_v3_HeaderValueOption_OVERWRITE_IF_EXISTS_OR_ADD:
+      return XdsHeaderValueOption::AppendAction::kOverwriteIfExistsOrAdd;
+    case envoy_config_core_v3_HeaderValueOption_OVERWRITE_IF_EXISTS:
+      return XdsHeaderValueOption::AppendAction::kOverwriteIfExists;
+    default:
+      errors->AddError("unsupported append action");
+      return XdsHeaderValueOption::AppendAction::kAppendIfExistsOrAdd;
+  }
+}
+
+}  // namespace
+
+XdsHeaderValueOption ParseXdsHeaderValueOption(
+    const envoy_config_core_v3_HeaderValueOption* header_value_option_config,
+    ValidationErrors* errors) {
+  if (header_value_option_config == nullptr) {
+    errors->AddError("field is not present");
+    return {};
+  }
+  XdsHeaderValueOption header_value_option;
+  // parse header
+  {
+    ValidationErrors::ScopedField field(errors, ".header");
+    if (const auto* header = envoy_config_core_v3_HeaderValueOption_header(
+            header_value_option_config);
+        header != nullptr) {
+      header_value_option.header = ParseXdsHeader(header, errors);
+    } else {
+      errors->AddError("field not set");
+    }
+  }
+  // parse header_append_action
+  {
+    ValidationErrors::ScopedField field(errors, ".append_action");
+    int32_t header_append_action =
+        envoy_config_core_v3_HeaderValueOption_append_action(
+            header_value_option_config);
+    header_value_option.append_action =
+        ParseXdsHeaderValueOptionAppendAction(header_append_action, errors);
+  }
+  return header_value_option;
+}
+
 }  // namespace grpc_core

data/src/core/xds/grpc/xds_common_types_parser.h

@@ -17,6 +17,7 @@
 #ifndef GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H
 #define GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H
 
+#include <cstdint>
 #include <optional>
 
 #include "envoy/config/common/mutation_rules/v3/mutation_rules.upb.h"
@@ -34,6 +35,7 @@
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_server_grpc.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "xds/type/matcher/v3/string.upb.h"
 
@@ -90,7 +92,7 @@ std::optional<XdsExtension> ExtractXdsExtension(
     const XdsResourceType::DecodeContext& context,
     const google_protobuf_Any* any, ValidationErrors* errors);
 
-XdsGrpcService ParseXdsGrpcService(
+GrpcXdsServerTarget ParseXdsGrpcService(
     const XdsResourceType::DecodeContext& context,
     const envoy_config_core_v3_GrpcService* grpc_service,
     ValidationErrors* errors);
@@ -100,6 +102,21 @@ HeaderMutationRules ParseHeaderMutationRules(
         header_mutation_rules,
     ValidationErrors* errors);
 
+XdsHeaderValueOption ParseXdsHeaderValueOption(
+    const envoy_config_core_v3_HeaderValueOption* header_value_option_config,
+    ValidationErrors* errors);
+
+// TODO(roth): We would ideally like to use a Slice for the header value, but
+// Slice isn't copyable, which makes it problematic to store here. The down-side
+// of this approach is that we need to make a copy when we apply the header
+// value to each RPC rather than just taking a new ref to the slice. Consider
+// solving this problem by adding a new RefCountedSlice class to represent an
+// immutable, ref-counted slice that can be turned into a Slice and thus added
+// to RPC metadata without a copy.
+std::pair<std::string, std::string> ParseXdsHeader(
+    const envoy_config_core_v3_HeaderValue* header_value,
+    ValidationErrors* errors);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_XDS_GRPC_XDS_COMMON_TYPES_PARSER_H