grpc 1.41.1 → 1.44.0.pre2

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,46 @@ 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::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 +214,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 +256,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 +274,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 +323,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,10 @@ class URI {
   URI(URI&&) = default;
   URI& operator=(URI&&) = default;
 
+  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 +84,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 +99,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

@@ -21,17 +21,12 @@
 #include <grpc/grpc.h>
 
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/surface/builtins.h"
 
-void grpc_http_filters_init(void);
-void grpc_http_filters_shutdown(void);
 void grpc_chttp2_plugin_init(void);
 void grpc_chttp2_plugin_shutdown(void);
-void grpc_deadline_filter_init(void);
-void grpc_deadline_filter_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);
@@ -50,27 +45,25 @@ 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_client_idle_filter_init(void);
-void grpc_client_idle_filter_shutdown(void);
-void grpc_max_age_filter_init(void);
-void grpc_max_age_filter_shutdown(void);
 void grpc_message_size_filter_init(void);
 void grpc_message_size_filter_shutdown(void);
-void grpc_service_config_channel_arg_filter_init(void);
-void grpc_service_config_channel_arg_filter_shutdown(void);
-void grpc_client_authority_filter_init(void);
-void grpc_client_authority_filter_shutdown(void);
-void grpc_workaround_cronet_compression_filter_init(void);
-void grpc_workaround_cronet_compression_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 RbacFilterInit(void);
+void RbacFilterShutdown(void);
 void XdsClientGlobalInit();
 void XdsClientGlobalShutdown();
 }  // namespace grpc_core
@@ -93,24 +86,26 @@ 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_http_filters_init,
-                       grpc_http_filters_shutdown);
-  grpc_register_plugin(grpc_chttp2_plugin_init,
-                       grpc_chttp2_plugin_shutdown);
-  grpc_register_plugin(grpc_deadline_filter_init,
-                       grpc_deadline_filter_shutdown);
-  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_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_resolver_fake_init, grpc_resolver_fake_shutdown);
   grpc_register_plugin(grpc_lb_policy_grpclb_init,
                        grpc_lb_policy_grpclb_shutdown);
+#ifndef GRPC_NO_RLS
+  grpc_register_plugin(grpc_core::RlsLbPluginInit,
+                       grpc_core::RlsLbPluginShutdown);
+#endif  // !GRPC_NO_RLS
   grpc_register_plugin(grpc_lb_policy_priority_init,
                        grpc_lb_policy_priority_shutdown);
   grpc_register_plugin(grpc_lb_policy_weighted_target_init,
@@ -127,50 +122,79 @@ void grpc_register_built_in_plugins(void) {
                        grpc_resolver_dns_native_shutdown);
   grpc_register_plugin(grpc_resolver_sockaddr_init,
                        grpc_resolver_sockaddr_shutdown);
-  grpc_register_plugin(grpc_client_idle_filter_init,
-                       grpc_client_idle_filter_shutdown);
-  grpc_register_plugin(grpc_max_age_filter_init,
-                       grpc_max_age_filter_shutdown);
   grpc_register_plugin(grpc_message_size_filter_init,
                        grpc_message_size_filter_shutdown);
   grpc_register_plugin(grpc_core::FaultInjectionFilterInit,
                        grpc_core::FaultInjectionFilterShutdown);
-  grpc_register_plugin(grpc_service_config_channel_arg_filter_init,
-                       grpc_service_config_channel_arg_filter_shutdown);
-  grpc_register_plugin(grpc_client_authority_filter_init,
-                       grpc_client_authority_filter_shutdown);
-  grpc_register_plugin(grpc_workaround_cronet_compression_filter_init,
-                       grpc_workaround_cronet_compression_filter_shutdown);
 #ifndef GRPC_NO_XDS
+  // rbac_filter is being guarded with GRPC_NO_XDS to avoid a dependency on the re2 library by default
+  grpc_register_plugin(grpc_core::RbacFilterInit, grpc_core::RbacFilterShutdown);
   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_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_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
 }
 
 namespace grpc_core {
 
-extern void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder);
-extern void SecurityRegisterHandshakerFactories(CoreConfiguration::Builder* builder);
+extern void BuildClientChannelConfiguration(
+    CoreConfiguration::Builder* builder);
+extern void SecurityRegisterHandshakerFactories(
+    CoreConfiguration::Builder* builder);
+extern void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder);
+extern void RegisterClientIdleFilter(CoreConfiguration::Builder* builder);
+extern void RegisterDeadlineFilter(CoreConfiguration::Builder* builder);
+extern void RegisterGrpcLbLoadReportingFilter(
+    CoreConfiguration::Builder* builder);
+extern void RegisterHttpFilters(CoreConfiguration::Builder* builder);
+extern void RegisterMaxAgeFilter(CoreConfiguration::Builder* builder);
+extern void RegisterMessageSizeFilter(CoreConfiguration::Builder* builder);
+extern void RegisterSecurityFilters(CoreConfiguration::Builder* builder);
+extern void RegisterServiceConfigChannelArgFilter(
+    CoreConfiguration::Builder* builder);
+extern void RegisterResourceQuota(CoreConfiguration::Builder* builder);
+#ifndef GRPC_NO_XDS
+extern void RegisterXdsChannelStackModifier(
+    CoreConfiguration::Builder* builder);
+#endif
 
 void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);
+  RegisterClientAuthorityFilter(builder);
+  RegisterClientIdleFilter(builder);
+  RegisterGrpcLbLoadReportingFilter(builder);
+  RegisterHttpFilters(builder);
+  RegisterMaxAgeFilter(builder);
+  RegisterDeadlineFilter(builder);
+  RegisterMessageSizeFilter(builder);
+  RegisterServiceConfigChannelArgFilter(builder);
+  RegisterResourceQuota(builder);
+#ifndef GRPC_NO_XDS
+  RegisterXdsChannelStackModifier(builder);
+#endif
+  // Run last so it gets a consistent location.
+  // TODO(ctiller): Is this actually necessary?
+  RegisterSecurityFilters(builder);
+  RegisterBuiltins(builder);
 }
 
 }  // namespace grpc_core

data/src/core/tsi/alts/crypt/aes_gcm.cc

@@ -559,7 +559,9 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_decrypt_iovec(
   if (!EVP_DecryptFinal_ex(aes_gcm_crypter->ctx, nullptr,
                            &bytes_written_temp)) {
     aes_gcm_format_errors("Checking tag failed.", error_details);
-    memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
+    if (plaintext_vec.iov_base != nullptr) {
+      memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
+    }
     return GRPC_STATUS_FAILED_PRECONDITION;
   }
   if (bytes_written_temp != 0) {