grpc 1.42.0 → 1.45.0

data/src/core/lib/uri/uri_parser.cc

@@ -1,20 +1,18 @@
-/*
- *
- * 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.
- *
- */
+//
+// 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.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -34,44 +32,129 @@
 #include "src/core/lib/gpr/string.h"
 
 namespace grpc_core {
+
 namespace {
 
-// Similar to `grpc_permissive_percent_decode_slice`, this %-decodes all valid
-// triplets, and passes through the rest verbatim.
-std::string PercentDecode(absl::string_view str) {
-  if (str.empty() || !absl::StrContains(str, "%")) {
-    return std::string(str);
+// Returns true for any sub-delim character, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-2.2
+bool IsSubDelimChar(char c) {
+  switch (c) {
+    case '!':
+    case '$':
+    case '&':
+    case '\'':
+    case '(':
+    case ')':
+    case '*':
+    case '+':
+    case ',':
+    case ';':
+    case '=':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any unreserved character, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-2.3
+bool IsUnreservedChar(char c) {
+  if (absl::ascii_isalnum(c)) return true;
+  switch (c) {
+    case '-':
+    case '.':
+    case '_':
+    case '~':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character in scheme, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+bool IsSchemeChar(char c) {
+  if (absl::ascii_isalnum(c)) return true;
+  switch (c) {
+    case '+':
+    case '-':
+    case '.':
+      return true;
   }
+  return false;
+}
+
+// Returns true for any character in authority, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2
+bool IsAuthorityChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '[':
+    case ']':
+    case '@':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character in pchar, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+bool IsPChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '@':
+      return true;
+  }
+  return false;
+}
+
+// Returns true for any character allowed in a URI path, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
+bool IsPathChar(char c) { return IsPChar(c) || c == '/'; }
+
+// Returns true for any character allowed in a URI query or fragment,
+// as defined in:
+// See https://tools.ietf.org/html/rfc3986#section-3.4
+bool IsQueryOrFragmentChar(char c) {
+  return IsPChar(c) || c == '/' || c == '?';
+}
+
+// Same as IsQueryOrFragmentChar(), but excludes '&' and '='.
+bool IsQueryKeyOrValueChar(char c) {
+  return c != '&' && c != '=' && IsQueryOrFragmentChar(c);
+}
+
+// Returns a copy of str, percent-encoding any character for which
+// is_allowed_char() returns false.
+std::string PercentEncode(absl::string_view str,
+                          std::function<bool(char)> is_allowed_char) {
   std::string out;
-  std::string unescaped;
-  out.reserve(str.size());
-  for (size_t i = 0; i < str.length(); i++) {
-    unescaped = "";
-    if (str[i] != '%') {
-      out += str[i];
-      continue;
-    }
-    if (i + 3 >= str.length() ||
-        !absl::CUnescape(absl::StrCat("\\x", str.substr(i + 1, 2)),
-                         &unescaped) ||
-        unescaped.length() > 1) {
-      out += str[i];
+  for (char c : str) {
+    if (!is_allowed_char(c)) {
+      std::string hex = absl::BytesToHexString(absl::string_view(&c, 1));
+      GPR_ASSERT(hex.size() == 2);
+      // BytesToHexString() returns lower case, but
+      // https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1 says
+      // to prefer upper-case.
+      absl::AsciiStrToUpper(&hex);
+      out.push_back('%');
+      out.append(hex);
     } else {
-      out += unescaped[0];
-      i += 2;
+      out.push_back(c);
     }
   }
   return out;
 }
 
-// Checks if this string is made up of pchars, '/', '?', and '%' exclusively.
+// Checks if this string is made up of query/fragment chars and '%' exclusively.
 // See https://tools.ietf.org/html/rfc3986#section-3.4
-bool IsPCharString(absl::string_view str) {
-  return (str.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                "abcdefghijklmnopqrstuvwxyz"
-                                "0123456789"
-                                "?/:@\\-._~!$&'()*+,;=%") ==
-          absl::string_view::npos);
+bool IsQueryOrFragmentString(absl::string_view str) {
+  for (char c : str) {
+    if (!IsQueryOrFragmentChar(c) && c != '%') return false;
+  }
+  return true;
 }
 
 absl::Status MakeInvalidURIStatus(absl::string_view part_name,
@@ -80,17 +163,50 @@ absl::Status MakeInvalidURIStatus(absl::string_view part_name,
   return absl::InvalidArgumentError(absl::StrFormat(
       "Could not parse '%s' from uri '%s'. %s", part_name, uri, extra));
 }
+
 }  // namespace
 
+std::string URI::PercentEncodeAuthority(absl::string_view str) {
+  return PercentEncode(str, IsAuthorityChar);
+}
+
+std::string URI::PercentEncodePath(absl::string_view str) {
+  return PercentEncode(str, IsPathChar);
+}
+
+// Similar to `grpc_permissive_percent_decode_slice`, this %-decodes all valid
+// triplets, and passes through the rest verbatim.
+std::string URI::PercentDecode(absl::string_view str) {
+  if (str.empty() || !absl::StrContains(str, "%")) {
+    return std::string(str);
+  }
+  std::string out;
+  std::string unescaped;
+  out.reserve(str.size());
+  for (size_t i = 0; i < str.length(); i++) {
+    unescaped = "";
+    if (str[i] == '%' && i + 3 <= str.length() &&
+        absl::CUnescape(absl::StrCat("\\x", str.substr(i + 1, 2)),
+                        &unescaped) &&
+        unescaped.length() == 1) {
+      out += unescaped[0];
+      i += 2;
+    } else {
+      out += str[i];
+    }
+  }
+  return out;
+}
+
 absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   absl::StatusOr<std::string> decoded;
   absl::string_view remaining = uri_text;
   // parse scheme
-  size_t idx = remaining.find(':');
-  if (idx == remaining.npos || idx == 0) {
+  size_t offset = remaining.find(':');
+  if (offset == remaining.npos || offset == 0) {
     return MakeInvalidURIStatus("scheme", uri_text, "Scheme not found.");
   }
-  std::string scheme(remaining.substr(0, idx));
+  std::string scheme(remaining.substr(0, offset));
   if (scheme.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                "abcdefghijklmnopqrstuvwxyz"
                                "0123456789+-.") != std::string::npos) {
@@ -102,30 +218,38 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
         "scheme", uri_text,
         "Scheme must begin with an alpha character [A-Za-z].");
   }
-  remaining.remove_prefix(scheme.length() + 1);
+  remaining.remove_prefix(offset + 1);
   // parse authority
   std::string authority;
-  if (absl::StartsWith(remaining, "//")) {
-    remaining.remove_prefix(2);
-    authority =
-        PercentDecode(remaining.substr(0, remaining.find_first_of("/?#")));
-    remaining.remove_prefix(authority.length());
+  if (absl::ConsumePrefix(&remaining, "//")) {
+    offset = remaining.find_first_of("/?#");
+    authority = PercentDecode(remaining.substr(0, offset));
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   // parse path
   std::string path;
   if (!remaining.empty()) {
-    path = PercentDecode(remaining.substr(0, remaining.find_first_of("?#")));
-    remaining.remove_prefix(path.length());
+    offset = remaining.find_first_of("?#");
+    path = PercentDecode(remaining.substr(0, offset));
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   // parse query
   std::vector<QueryParam> query_param_pairs;
-  if (!remaining.empty() && remaining[0] == '?') {
-    remaining.remove_prefix(1);
-    absl::string_view tmp_query = remaining.substr(0, remaining.find('#'));
+  if (absl::ConsumePrefix(&remaining, "?")) {
+    offset = remaining.find('#');
+    absl::string_view tmp_query = remaining.substr(0, offset);
     if (tmp_query.empty()) {
       return MakeInvalidURIStatus("query", uri_text, "Invalid query string.");
     }
-    if (!IsPCharString(tmp_query)) {
+    if (!IsQueryOrFragmentString(tmp_query)) {
       return MakeInvalidURIStatus("query string", uri_text,
                                   "Query string contains invalid characters.");
     }
@@ -136,12 +260,15 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
       query_param_pairs.push_back({PercentDecode(possible_kv.first),
                                    PercentDecode(possible_kv.second)});
     }
-    remaining.remove_prefix(tmp_query.length());
+    if (offset == remaining.npos) {
+      remaining = "";
+    } else {
+      remaining.remove_prefix(offset);
+    }
   }
   std::string fragment;
-  if (!remaining.empty() && remaining[0] == '#') {
-    remaining.remove_prefix(1);
-    if (!IsPCharString(remaining)) {
+  if (absl::ConsumePrefix(&remaining, "#")) {
+    if (!IsQueryOrFragmentString(remaining)) {
       return MakeInvalidURIStatus("fragment", uri_text,
                                   "Fragment contains invalid characters.");
     }
@@ -151,6 +278,18 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
              std::move(query_param_pairs), std::move(fragment));
 }
 
+absl::StatusOr<URI> URI::Create(std::string scheme, std::string authority,
+                                std::string path,
+                                std::vector<QueryParam> query_parameter_pairs,
+                                std::string fragment) {
+  if (!authority.empty() && !path.empty() && path[0] != '/') {
+    return absl::InvalidArgumentError(
+        "if authority is present, path must start with a '/'");
+  }
+  return URI(std::move(scheme), std::move(authority), std::move(path),
+             std::move(query_parameter_pairs), std::move(fragment));
+}
+
 URI::URI(std::string scheme, std::string authority, std::string path,
          std::vector<QueryParam> query_parameter_pairs, std::string fragment)
     : scheme_(std::move(scheme)),
@@ -188,4 +327,39 @@ URI& URI::operator=(const URI& other) {
   }
   return *this;
 }
+
+namespace {
+
+// A pair formatter for use with absl::StrJoin() for formatting query params.
+struct QueryParameterFormatter {
+  void operator()(std::string* out, const URI::QueryParam& query_param) const {
+    out->append(
+        absl::StrCat(PercentEncode(query_param.key, IsQueryKeyOrValueChar), "=",
+                     PercentEncode(query_param.value, IsQueryKeyOrValueChar)));
+  }
+};
+
+}  // namespace
+
+std::string URI::ToString() const {
+  std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
+  if (!authority_.empty()) {
+    parts.emplace_back("//");
+    parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
+  }
+  if (!path_.empty()) {
+    parts.emplace_back(PercentEncode(path_, IsPathChar));
+  }
+  if (!query_parameter_pairs_.empty()) {
+    parts.push_back("?");
+    parts.push_back(
+        absl::StrJoin(query_parameter_pairs_, "&", QueryParameterFormatter()));
+  }
+  if (!fragment_.empty()) {
+    parts.push_back("#");
+    parts.push_back(PercentEncode(fragment_, IsQueryOrFragmentChar));
+  }
+  return absl::StrJoin(parts, "");
+}
+
 }  // namespace grpc_core

data/src/core/lib/uri/uri_parser.h

@@ -1,20 +1,18 @@
-/*
- *
- * 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.
- *
- */
+//
+// 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_URI_URI_PARSER_H
 #define GRPC_CORE_LIB_URI_URI_PARSER_H
@@ -40,15 +38,23 @@ class URI {
     bool operator==(const QueryParam& other) const {
       return key == other.key && value == other.value;
     }
+    bool operator<(const QueryParam& other) const {
+      int c = key.compare(other.key);
+      if (c != 0) return c < 0;
+      return value < other.value;
+    }
   };
 
-  // Creates an instance of GrpcURI by parsing an rfc3986 URI string. Returns
-  // an IllegalArgumentError on failure.
+  // Creates a URI by parsing an rfc3986 URI string. Returns an
+  // InvalidArgumentError on failure.
   static absl::StatusOr<URI> Parse(absl::string_view uri_text);
-  // Explicit construction by individual URI components
-  URI(std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment_);
+  // Creates a URI from components. Returns an InvalidArgumentError on failure.
+  static absl::StatusOr<URI> Create(
+      std::string scheme, std::string authority, std::string path,
+      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+
   URI() = default;
+
   // Copy construction and assignment
   URI(const URI& other);
   URI& operator=(const URI& other);
@@ -56,6 +62,11 @@ class URI {
   URI(URI&&) = default;
   URI& operator=(URI&&) = default;
 
+  static std::string PercentEncodeAuthority(absl::string_view str);
+  static std::string PercentEncodePath(absl::string_view str);
+
+  static std::string PercentDecode(absl::string_view str);
+
   const std::string& scheme() const { return scheme_; }
   const std::string& authority() const { return authority_; }
   const std::string& path() const { return path_; }
@@ -74,7 +85,12 @@ class URI {
   }
   const std::string& fragment() const { return fragment_; }
 
+  std::string ToString() const;
+
  private:
+  URI(std::string scheme, std::string authority, std::string path,
+      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+
   std::string scheme_;
   std::string authority_;
   std::string path_;
@@ -84,4 +100,4 @@ class URI {
 };
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_URI_URI_PARSER_H */
+#endif  // GRPC_CORE_LIB_URI_URI_PARSER_H

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -23,14 +23,12 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/surface/builtins.h"
 
+extern void grpc_register_extra_plugins(void);
+
 void grpc_chttp2_plugin_init(void);
 void grpc_chttp2_plugin_shutdown(void);
 void grpc_client_channel_init(void);
 void grpc_client_channel_shutdown(void);
-void grpc_inproc_plugin_init(void);
-void grpc_inproc_plugin_shutdown(void);
-void grpc_resolver_fake_init(void);
-void grpc_resolver_fake_shutdown(void);
 void grpc_lb_policy_grpclb_init(void);
 void grpc_lb_policy_grpclb_shutdown(void);
 void grpc_lb_policy_priority_init(void);
@@ -43,64 +41,17 @@ void grpc_lb_policy_round_robin_init(void);
 void grpc_lb_policy_round_robin_shutdown(void);
 void grpc_resolver_dns_ares_init(void);
 void grpc_resolver_dns_ares_shutdown(void);
-void grpc_resolver_dns_native_init(void);
-void grpc_resolver_dns_native_shutdown(void);
-void grpc_resolver_sockaddr_init(void);
-void grpc_resolver_sockaddr_shutdown(void);
-void grpc_message_size_filter_init(void);
-void grpc_message_size_filter_shutdown(void);
 namespace grpc_core {
-void FaultInjectionFilterInit(void);
-void FaultInjectionFilterShutdown(void);
 void GrpcLbPolicyRingHashInit(void);
 void GrpcLbPolicyRingHashShutdown(void);
 #ifndef GRPC_NO_RLS
 void RlsLbPluginInit();
 void RlsLbPluginShutdown();
 #endif  // !GRPC_NO_RLS
-void ServiceConfigParserInit(void);
-void ServiceConfigParserShutdown(void);
-}  // namespace grpc_core
-
-#ifndef GRPC_NO_XDS
-namespace grpc_core {
-void XdsClientGlobalInit();
-void XdsClientGlobalShutdown();
-}  // namespace grpc_core
-void grpc_certificate_provider_registry_init(void);
-void grpc_certificate_provider_registry_shutdown(void);
-namespace grpc_core {
-void FileWatcherCertificateProviderInit();
-void FileWatcherCertificateProviderShutdown();
-}  // namespace grpc_core
-void grpc_lb_policy_cds_init(void);
-void grpc_lb_policy_cds_shutdown(void);
-void grpc_lb_policy_xds_cluster_impl_init(void);
-void grpc_lb_policy_xds_cluster_impl_shutdown(void);
-void grpc_lb_policy_xds_cluster_resolver_init(void);
-void grpc_lb_policy_xds_cluster_resolver_shutdown(void);
-void grpc_lb_policy_xds_cluster_manager_init(void);
-void grpc_lb_policy_xds_cluster_manager_shutdown(void);
-void grpc_resolver_xds_init(void);
-void grpc_resolver_xds_shutdown(void);
-namespace grpc_core {
-void GoogleCloud2ProdResolverInit();
-void GoogleCloud2ProdResolverShutdown();
 }  // namespace grpc_core
-#endif
-
-#ifdef GPR_SUPPORT_BINDER_TRANSPORT
-void grpc_resolver_binder_init(void);
-void grpc_resolver_binder_shutdown(void);
-#endif
 
 void grpc_register_built_in_plugins(void) {
-  grpc_register_plugin(grpc_chttp2_plugin_init, grpc_chttp2_plugin_shutdown);
-  grpc_register_plugin(grpc_core::ServiceConfigParserInit,
-                       grpc_core::ServiceConfigParserShutdown);
   grpc_register_plugin(grpc_client_channel_init, grpc_client_channel_shutdown);
-  grpc_register_plugin(grpc_inproc_plugin_init, grpc_inproc_plugin_shutdown);
-  grpc_register_plugin(grpc_resolver_fake_init, grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
 #ifndef GRPC_NO_RLS
@@ -119,37 +70,7 @@ void grpc_register_built_in_plugins(void) {
                        grpc_core::GrpcLbPolicyRingHashShutdown);
   grpc_register_plugin(grpc_resolver_dns_ares_init,
                        grpc_resolver_dns_ares_shutdown);
-  grpc_register_plugin(grpc_resolver_dns_native_init,
-                       grpc_resolver_dns_native_shutdown);
-  grpc_register_plugin(grpc_resolver_sockaddr_init,
-                       grpc_resolver_sockaddr_shutdown);
-  grpc_register_plugin(grpc_message_size_filter_init,
-                       grpc_message_size_filter_shutdown);
-  grpc_register_plugin(grpc_core::FaultInjectionFilterInit,
-                       grpc_core::FaultInjectionFilterShutdown);
-#ifndef GRPC_NO_XDS
-  grpc_register_plugin(grpc_core::XdsClientGlobalInit,
-                       grpc_core::XdsClientGlobalShutdown);
-  grpc_register_plugin(grpc_certificate_provider_registry_init,
-                       grpc_certificate_provider_registry_shutdown);
-  grpc_register_plugin(grpc_core::FileWatcherCertificateProviderInit,
-                       grpc_core::FileWatcherCertificateProviderShutdown);
-  grpc_register_plugin(grpc_lb_policy_cds_init, grpc_lb_policy_cds_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_impl_init,
-                       grpc_lb_policy_xds_cluster_impl_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_resolver_init,
-                       grpc_lb_policy_xds_cluster_resolver_shutdown);
-  grpc_register_plugin(grpc_lb_policy_xds_cluster_manager_init,
-                       grpc_lb_policy_xds_cluster_manager_shutdown);
-  grpc_register_plugin(grpc_resolver_xds_init, grpc_resolver_xds_shutdown);
-  grpc_register_plugin(grpc_core::GoogleCloud2ProdResolverInit,
-                       grpc_core::GoogleCloud2ProdResolverShutdown);
-#endif
-
-#ifdef GPR_SUPPORT_BINDER_TRANSPORT
-  grpc_register_plugin(grpc_resolver_binder_init,
-                       grpc_resolver_binder_shutdown);
-#endif
+  grpc_register_extra_plugins();
 }
 
 namespace grpc_core {
@@ -169,9 +90,15 @@ extern void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder);
 extern void RegisterSecurityFilters(CoreConfiguration::Builder* builder);
 extern void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder);
-#ifndef GRPC_NO_XDS
-extern void RegisterXdsChannelStackModifier(
-    CoreConfiguration::Builder* builder);
+extern void RegisterExtraFilters(CoreConfiguration::Builder* builder);
+extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
+extern void FaultInjectionFilterRegister(CoreConfiguration::Builder* builder);
+extern void RegisterNativeDnsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterAresDnsResolver(CoreConfiguration::Builder* builder);
+extern void RegisterSockaddrResolver(CoreConfiguration::Builder* builder);
+extern void RegisterFakeResolver(CoreConfiguration::Builder* builder);
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+extern void RegisterBinderResolver(CoreConfiguration::Builder* builder);
 #endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
@@ -185,12 +112,19 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterDeadlineFilter(builder);
   RegisterMessageSizeFilter(builder);
   RegisterServiceConfigChannelArgFilter(builder);
-  #ifndef GRPC_NO_XDS
-  RegisterXdsChannelStackModifier(builder);
-  #endif
+  RegisterResourceQuota(builder);
+  FaultInjectionFilterRegister(builder);
+  RegisterAresDnsResolver(builder);
+  RegisterNativeDnsResolver(builder);
+  RegisterSockaddrResolver(builder);
+  RegisterFakeResolver(builder);
+#ifdef GPR_SUPPORT_BINDER_TRANSPORT
+  RegisterBinderResolver(builder);
+#endif
   // Run last so it gets a consistent location.
   // TODO(ctiller): Is this actually necessary?
   RegisterSecurityFilters(builder);
+  RegisterExtraFilters(builder);
   RegisterBuiltins(builder);
 }