grpc 1.31.1 → 1.32.0.pre1

data/src/core/lib/transport/static_metadata.h

@@ -36,7 +36,7 @@
 static_assert(
     std::is_trivially_destructible<grpc_core::StaticMetadataSlice>::value,
     "grpc_core::StaticMetadataSlice must be trivially destructible.");
-#define GRPC_STATIC_MDSTR_COUNT 108
+#define GRPC_STATIC_MDSTR_COUNT 110
 
 void grpc_init_static_metadata_ctx(void);
 void grpc_destroy_static_metadata_ctx(void);
@@ -132,154 +132,161 @@ inline const grpc_core::StaticMetadataSlice* grpc_static_slice_table() {
 /* "/envoy.service.load_stats.v2.LoadReportingService/StreamLoadStats" */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V2_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
   (grpc_static_slice_table()[35])
+/* "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats" */
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V3_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \
+  (grpc_static_slice_table()[36])
 /* "/grpc.health.v1.Health/Watch" */
 #define GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH \
-  (grpc_static_slice_table()[36])
+  (grpc_static_slice_table()[37])
 /* "/envoy.service.discovery.v2.AggregatedDiscoveryService/StreamAggregatedResources"
  */
 #define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V2_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
-  (grpc_static_slice_table()[37])
+  (grpc_static_slice_table()[38])
+/* "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources"
+ */
+#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V3_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \
+  (grpc_static_slice_table()[39])
 /* "deflate" */
-#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[38])
+#define GRPC_MDSTR_DEFLATE (grpc_static_slice_table()[40])
 /* "gzip" */
-#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[39])
+#define GRPC_MDSTR_GZIP (grpc_static_slice_table()[41])
 /* "stream/gzip" */
-#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[40])
+#define GRPC_MDSTR_STREAM_SLASH_GZIP (grpc_static_slice_table()[42])
 /* "GET" */
-#define GRPC_MDSTR_GET (grpc_static_slice_table()[41])
+#define GRPC_MDSTR_GET (grpc_static_slice_table()[43])
 /* "POST" */
-#define GRPC_MDSTR_POST (grpc_static_slice_table()[42])
+#define GRPC_MDSTR_POST (grpc_static_slice_table()[44])
 /* "/" */
-#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[43])
+#define GRPC_MDSTR_SLASH (grpc_static_slice_table()[45])
 /* "/index.html" */
-#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[44])
+#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML (grpc_static_slice_table()[46])
 /* "http" */
-#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[45])
+#define GRPC_MDSTR_HTTP (grpc_static_slice_table()[47])
 /* "https" */
-#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[46])
+#define GRPC_MDSTR_HTTPS (grpc_static_slice_table()[48])
 /* "200" */
-#define GRPC_MDSTR_200 (grpc_static_slice_table()[47])
+#define GRPC_MDSTR_200 (grpc_static_slice_table()[49])
 /* "204" */
-#define GRPC_MDSTR_204 (grpc_static_slice_table()[48])
+#define GRPC_MDSTR_204 (grpc_static_slice_table()[50])
 /* "206" */
-#define GRPC_MDSTR_206 (grpc_static_slice_table()[49])
+#define GRPC_MDSTR_206 (grpc_static_slice_table()[51])
 /* "304" */
-#define GRPC_MDSTR_304 (grpc_static_slice_table()[50])
+#define GRPC_MDSTR_304 (grpc_static_slice_table()[52])
 /* "400" */
-#define GRPC_MDSTR_400 (grpc_static_slice_table()[51])
+#define GRPC_MDSTR_400 (grpc_static_slice_table()[53])
 /* "404" */
-#define GRPC_MDSTR_404 (grpc_static_slice_table()[52])
+#define GRPC_MDSTR_404 (grpc_static_slice_table()[54])
 /* "500" */
-#define GRPC_MDSTR_500 (grpc_static_slice_table()[53])
+#define GRPC_MDSTR_500 (grpc_static_slice_table()[55])
 /* "accept-charset" */
-#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[54])
+#define GRPC_MDSTR_ACCEPT_CHARSET (grpc_static_slice_table()[56])
 /* "gzip, deflate" */
-#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[55])
+#define GRPC_MDSTR_GZIP_COMMA_DEFLATE (grpc_static_slice_table()[57])
 /* "accept-language" */
-#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[56])
+#define GRPC_MDSTR_ACCEPT_LANGUAGE (grpc_static_slice_table()[58])
 /* "accept-ranges" */
-#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[57])
+#define GRPC_MDSTR_ACCEPT_RANGES (grpc_static_slice_table()[59])
 /* "accept" */
-#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[58])
+#define GRPC_MDSTR_ACCEPT (grpc_static_slice_table()[60])
 /* "access-control-allow-origin" */
-#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[59])
+#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN (grpc_static_slice_table()[61])
 /* "age" */
-#define GRPC_MDSTR_AGE (grpc_static_slice_table()[60])
+#define GRPC_MDSTR_AGE (grpc_static_slice_table()[62])
 /* "allow" */
-#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[61])
+#define GRPC_MDSTR_ALLOW (grpc_static_slice_table()[63])
 /* "authorization" */
-#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[62])
+#define GRPC_MDSTR_AUTHORIZATION (grpc_static_slice_table()[64])
 /* "cache-control" */
-#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[63])
+#define GRPC_MDSTR_CACHE_CONTROL (grpc_static_slice_table()[65])
 /* "content-disposition" */
-#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[64])
+#define GRPC_MDSTR_CONTENT_DISPOSITION (grpc_static_slice_table()[66])
 /* "content-language" */
-#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[65])
+#define GRPC_MDSTR_CONTENT_LANGUAGE (grpc_static_slice_table()[67])
 /* "content-length" */
-#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[66])
+#define GRPC_MDSTR_CONTENT_LENGTH (grpc_static_slice_table()[68])
 /* "content-location" */
-#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[67])
+#define GRPC_MDSTR_CONTENT_LOCATION (grpc_static_slice_table()[69])
 /* "content-range" */
-#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[68])
+#define GRPC_MDSTR_CONTENT_RANGE (grpc_static_slice_table()[70])
 /* "cookie" */
-#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[69])
+#define GRPC_MDSTR_COOKIE (grpc_static_slice_table()[71])
 /* "date" */
-#define GRPC_MDSTR_DATE (grpc_static_slice_table()[70])
+#define GRPC_MDSTR_DATE (grpc_static_slice_table()[72])
 /* "etag" */
-#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[71])
+#define GRPC_MDSTR_ETAG (grpc_static_slice_table()[73])
 /* "expect" */
-#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[72])
+#define GRPC_MDSTR_EXPECT (grpc_static_slice_table()[74])
 /* "expires" */
-#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[73])
+#define GRPC_MDSTR_EXPIRES (grpc_static_slice_table()[75])
 /* "from" */
-#define GRPC_MDSTR_FROM (grpc_static_slice_table()[74])
+#define GRPC_MDSTR_FROM (grpc_static_slice_table()[76])
 /* "if-match" */
-#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[75])
+#define GRPC_MDSTR_IF_MATCH (grpc_static_slice_table()[77])
 /* "if-modified-since" */
-#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[76])
+#define GRPC_MDSTR_IF_MODIFIED_SINCE (grpc_static_slice_table()[78])
 /* "if-none-match" */
-#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[77])
+#define GRPC_MDSTR_IF_NONE_MATCH (grpc_static_slice_table()[79])
 /* "if-range" */
-#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[78])
+#define GRPC_MDSTR_IF_RANGE (grpc_static_slice_table()[80])
 /* "if-unmodified-since" */
-#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[79])
+#define GRPC_MDSTR_IF_UNMODIFIED_SINCE (grpc_static_slice_table()[81])
 /* "last-modified" */
-#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[80])
+#define GRPC_MDSTR_LAST_MODIFIED (grpc_static_slice_table()[82])
 /* "link" */
-#define GRPC_MDSTR_LINK (grpc_static_slice_table()[81])
+#define GRPC_MDSTR_LINK (grpc_static_slice_table()[83])
 /* "location" */
-#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[82])
+#define GRPC_MDSTR_LOCATION (grpc_static_slice_table()[84])
 /* "max-forwards" */
-#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[83])
+#define GRPC_MDSTR_MAX_FORWARDS (grpc_static_slice_table()[85])
 /* "proxy-authenticate" */
-#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[84])
+#define GRPC_MDSTR_PROXY_AUTHENTICATE (grpc_static_slice_table()[86])
 /* "proxy-authorization" */
-#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[85])
+#define GRPC_MDSTR_PROXY_AUTHORIZATION (grpc_static_slice_table()[87])
 /* "range" */
-#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[86])
+#define GRPC_MDSTR_RANGE (grpc_static_slice_table()[88])
 /* "referer" */
-#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[87])
+#define GRPC_MDSTR_REFERER (grpc_static_slice_table()[89])
 /* "refresh" */
-#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[88])
+#define GRPC_MDSTR_REFRESH (grpc_static_slice_table()[90])
 /* "retry-after" */
-#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[89])
+#define GRPC_MDSTR_RETRY_AFTER (grpc_static_slice_table()[91])
 /* "server" */
-#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[90])
+#define GRPC_MDSTR_SERVER (grpc_static_slice_table()[92])
 /* "set-cookie" */
-#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[91])
+#define GRPC_MDSTR_SET_COOKIE (grpc_static_slice_table()[93])
 /* "strict-transport-security" */
-#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[92])
+#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY (grpc_static_slice_table()[94])
 /* "transfer-encoding" */
-#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[93])
+#define GRPC_MDSTR_TRANSFER_ENCODING (grpc_static_slice_table()[95])
 /* "vary" */
-#define GRPC_MDSTR_VARY (grpc_static_slice_table()[94])
+#define GRPC_MDSTR_VARY (grpc_static_slice_table()[96])
 /* "via" */
-#define GRPC_MDSTR_VIA (grpc_static_slice_table()[95])
+#define GRPC_MDSTR_VIA (grpc_static_slice_table()[97])
 /* "www-authenticate" */
-#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[96])
+#define GRPC_MDSTR_WWW_AUTHENTICATE (grpc_static_slice_table()[98])
 /* "0" */
-#define GRPC_MDSTR_0 (grpc_static_slice_table()[97])
+#define GRPC_MDSTR_0 (grpc_static_slice_table()[99])
 /* "identity" */
-#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[98])
+#define GRPC_MDSTR_IDENTITY (grpc_static_slice_table()[100])
 /* "trailers" */
-#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[99])
+#define GRPC_MDSTR_TRAILERS (grpc_static_slice_table()[101])
 /* "application/grpc" */
-#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[100])
+#define GRPC_MDSTR_APPLICATION_SLASH_GRPC (grpc_static_slice_table()[102])
 /* "grpc" */
-#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[101])
+#define GRPC_MDSTR_GRPC (grpc_static_slice_table()[103])
 /* "PUT" */
-#define GRPC_MDSTR_PUT (grpc_static_slice_table()[102])
+#define GRPC_MDSTR_PUT (grpc_static_slice_table()[104])
 /* "lb-cost-bin" */
-#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[103])
+#define GRPC_MDSTR_LB_COST_BIN (grpc_static_slice_table()[105])
 /* "identity,deflate" */
-#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[104])
+#define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE (grpc_static_slice_table()[106])
 /* "identity,gzip" */
-#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[105])
+#define GRPC_MDSTR_IDENTITY_COMMA_GZIP (grpc_static_slice_table()[107])
 /* "deflate,gzip" */
-#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[106])
+#define GRPC_MDSTR_DEFLATE_COMMA_GZIP (grpc_static_slice_table()[108])
 /* "identity,deflate,gzip" */
 #define GRPC_MDSTR_IDENTITY_COMMA_DEFLATE_COMMA_GZIP \
-  (grpc_static_slice_table()[107])
+  (grpc_static_slice_table()[109])
 
 namespace grpc_core {
 struct StaticSliceRefcount;

data/src/core/lib/transport/transport.h

@@ -459,4 +459,11 @@ grpc_transport_op* grpc_make_transport_op(grpc_closure* on_consumed);
 grpc_transport_stream_op_batch* grpc_make_transport_stream_op(
     grpc_closure* on_consumed);
 
+namespace grpc_core {
+// This is the key to be used for loading/storing keepalive_throttling in the
+// absl::Status object.
+constexpr const char* kKeepaliveThrottlingKey =
+    "grpc.internal.keepalive_throttling";
+}  // namespace grpc_core
+
 #endif /* GRPC_CORE_LIB_TRANSPORT_TRANSPORT_H */

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

@@ -38,11 +38,12 @@
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
-static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
-                         bool suppress_errors) {
+static grpc_uri* bad_uri(absl::string_view uri_text, size_t pos,
+                         const char* section, bool suppress_errors) {
   if (!suppress_errors) {
     std::string line_prefix = absl::StrFormat("bad uri.%s: '", section);
-    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(), uri_text);
+    gpr_log(GPR_ERROR, "%s%s'", line_prefix.c_str(),
+            std::string(uri_text).c_str());
     size_t pfx_len = line_prefix.size() + pos;
     gpr_log(GPR_ERROR, "%s^ here", std::string(pfx_len, ' ').c_str());
   }
@@ -50,12 +51,12 @@ static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section,
 }
 
 /** Returns a copy of percent decoded \a src[begin, end) */
-static char* decode_and_copy_component(const char* src, size_t begin,
+static char* decode_and_copy_component(absl::string_view src, size_t begin,
                                        size_t end) {
   grpc_slice component =
       (begin == NOT_SET || end == NOT_SET)
           ? grpc_empty_slice()
-          : grpc_slice_from_copied_buffer(src + begin, end - begin);
+          : grpc_slice_from_copied_buffer(src.data() + begin, end - begin);
   grpc_slice decoded_component =
       grpc_permissive_percent_decode_slice(component);
   char* out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII);
@@ -72,7 +73,7 @@ static bool valid_hex(char c) {
 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
  * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
  * sign not followed by two hex digits), NOT_SET is returned. */
-static size_t parse_pchar(const char* uri_text, size_t i) {
+static size_t parse_pchar(absl::string_view uri_text, size_t i) {
   /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    * pct-encoded = "%" HEXDIG HEXDIG
@@ -105,7 +106,8 @@ static size_t parse_pchar(const char* uri_text, size_t i) {
     case '=':
       return 1;
     case '%': /* pct-encoded */
-      if (valid_hex(uri_text[i + 1]) && valid_hex(uri_text[i + 2])) {
+      if (uri_text.size() > i + 2 && valid_hex(uri_text[i + 1]) &&
+          valid_hex(uri_text[i + 2])) {
         return 2;
       }
       return NOT_SET;
@@ -114,9 +116,8 @@ static size_t parse_pchar(const char* uri_text, size_t i) {
 }
 
 /* *( pchar / "?" / "/" ) */
-static int parse_fragment_or_query(const char* uri_text, size_t* i) {
-  char c;
-  while ((c = uri_text[*i]) != 0) {
+static int parse_fragment_or_query(absl::string_view uri_text, size_t* i) {
+  while (uri_text.size() > *i) {
     const size_t advance = parse_pchar(uri_text, *i); /* pchar */
     switch (advance) {
       case 0: /* uri_text[i] isn't in pchar */
@@ -178,7 +179,7 @@ static void parse_query_parts(grpc_uri* uri) {
   }
 }
 
-grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
+grpc_uri* grpc_uri_parse(absl::string_view uri_text, bool suppress_errors) {
   grpc_uri* uri;
   size_t scheme_begin = 0;
   size_t scheme_end = NOT_SET;
@@ -192,7 +193,7 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
   size_t fragment_end = NOT_SET;
   size_t i;
 
-  for (i = scheme_begin; uri_text[i] != 0; i++) {
+  for (i = scheme_begin; i < uri_text.size(); ++i) {
     if (uri_text[i] == ':') {
       scheme_end = i;
       break;
@@ -211,15 +212,16 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
     return bad_uri(uri_text, i, "scheme", suppress_errors);
   }
 
-  if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') {
+  if (uri_text.size() > scheme_end + 2 && uri_text[scheme_end + 1] == '/' &&
+      uri_text[scheme_end + 2] == '/') {
     authority_begin = scheme_end + 3;
-    for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET;
+    for (i = authority_begin; uri_text.size() > i && authority_end == NOT_SET;
          i++) {
       if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
         authority_end = i;
       }
     }
-    if (authority_end == NOT_SET && uri_text[i] == 0) {
+    if (authority_end == NOT_SET && uri_text.size() == i) {
       authority_end = i;
     }
     if (authority_end == NOT_SET) {
@@ -231,34 +233,34 @@ grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors) {
     path_begin = scheme_end + 1;
   }
 
-  for (i = path_begin; uri_text[i] != 0; i++) {
+  for (i = path_begin; i < uri_text.size(); ++i) {
     if (uri_text[i] == '?' || uri_text[i] == '#') {
       path_end = i;
       break;
     }
   }
-  if (path_end == NOT_SET && uri_text[i] == 0) {
+  if (path_end == NOT_SET && uri_text.size() == i) {
     path_end = i;
   }
   if (path_end == NOT_SET) {
     return bad_uri(uri_text, i, "path", suppress_errors);
   }
 
-  if (uri_text[i] == '?') {
+  if (uri_text.size() > i && uri_text[i] == '?') {
     query_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i, "query", suppress_errors);
-    } else if (uri_text[i] != 0 && uri_text[i] != '#') {
+    } else if (uri_text.size() > i && uri_text[i] != '#') {
       /* We must be at the end or at the beginning of a fragment */
       return bad_uri(uri_text, i, "query", suppress_errors);
     }
     query_end = i;
   }
-  if (uri_text[i] == '#') {
+  if (uri_text.size() > i && uri_text[i] == '#') {
     fragment_begin = ++i;
     if (!parse_fragment_or_query(uri_text, &i)) {
       return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
-    } else if (uri_text[i] != 0) {
+    } else if (uri_text.size() > i) {
       /* We must be at the end */
       return bad_uri(uri_text, i, "fragment", suppress_errors);
     }

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/strings/string_view.h"
+
 #include <stddef.h>
 
 struct grpc_uri {
@@ -37,7 +39,7 @@ struct grpc_uri {
   char* fragment;
 };
 /** parse a uri, return NULL on failure */
-grpc_uri* grpc_uri_parse(const char* uri_text, bool suppress_errors);
+grpc_uri* grpc_uri_parse(absl::string_view uri_text, bool suppress_errors);
 
 /** return the part of a query string after the '=' in "?key=xxx&...", or NULL
  * if key is not present */

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -334,6 +334,28 @@ tsi_result alts_tsi_handshaker_result_create(grpc_gcp_HandshakerResp* resp,
                                                  local_service_account);
   grpc_gcp_AltsContext_set_peer_rpc_versions(
       context, const_cast<grpc_gcp_RpcProtocolVersions*>(peer_rpc_version));
+  grpc_gcp_Identity* peer_identity = const_cast<grpc_gcp_Identity*>(identity);
+  if (peer_identity == nullptr) {
+    gpr_log(GPR_ERROR, "Null peer identity in ALTS context.");
+    return TSI_FAILED_PRECONDITION;
+  }
+  if (grpc_gcp_Identity_has_attributes(identity)) {
+    size_t iter = UPB_MAP_BEGIN;
+    grpc_gcp_Identity_AttributesEntry* peer_attributes_entry =
+        grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
+    while (peer_attributes_entry != nullptr) {
+      upb_strview key = grpc_gcp_Identity_AttributesEntry_key(
+          const_cast<grpc_gcp_Identity_AttributesEntry*>(
+              peer_attributes_entry));
+      upb_strview val = grpc_gcp_Identity_AttributesEntry_value(
+          const_cast<grpc_gcp_Identity_AttributesEntry*>(
+              peer_attributes_entry));
+      grpc_gcp_AltsContext_peer_attributes_set(context, key, val,
+                                               context_arena.ptr());
+      peer_attributes_entry =
+          grpc_gcp_Identity_attributes_nextmutable(peer_identity, &iter);
+    }
+  }
   size_t serialized_ctx_length;
   char* serialized_ctx = grpc_gcp_AltsContext_serialize(
       context, context_arena.ptr(), &serialized_ctx_length);

data/src/core/tsi/ssl_transport_security.cc

@@ -1894,11 +1894,8 @@ tsi_result tsi_create_ssl_client_handshaker_factory_with_options(
 #else
   ssl_context = SSL_CTX_new(TLSv1_2_method());
 #endif
-  // TODO(mattstev): Re-enable TLS 1.3 by using |options.min_tls_version| and
-  // |options.max_tls_version|, rather than hardcoding in TLS 1.2 as the min and
-  // max.
   result = tsi_set_min_and_max_tls_versions(
-      ssl_context, tsi_tls_version::TSI_TLS1_2, tsi_tls_version::TSI_TLS1_2);
+      ssl_context, options->min_tls_version, options->max_tls_version);
   if (result != TSI_OK) return result;
   if (ssl_context == nullptr) {
     gpr_log(GPR_ERROR, "Could not create ssl context.");
@@ -2064,12 +2061,9 @@ tsi_result tsi_create_ssl_server_handshaker_factory_with_options(
 #else
       impl->ssl_contexts[i] = SSL_CTX_new(TLSv1_2_method());
 #endif
-      // TODO(mattstev): Re-enable TLS 1.3 by using |options.min_tls_version|
-      // and |options.max_tls_version|, rather than hardcoding in TLS 1.2 as the
-      // min and max.
       result = tsi_set_min_and_max_tls_versions(impl->ssl_contexts[i],
-                                                tsi_tls_version::TSI_TLS1_2,
-                                                tsi_tls_version::TSI_TLS1_2);
+                                                options->min_tls_version,
+                                                options->max_tls_version);
       if (result != TSI_OK) return result;
       if (impl->ssl_contexts[i] == nullptr) {
         gpr_log(GPR_ERROR, "Could not create ssl context.");