grpc 1.76.0 → 1.78.0.pre1

data/src/core/ext/transport/chttp2/transport/frame.cc

@@ -20,15 +20,18 @@
 #include <cstdint>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
+#include "src/core/call/message.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/lib/debug/trace_impl.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/memory_usage.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 
 // TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
 // framing code
@@ -39,6 +42,9 @@ using grpc_core::http2::ValueOrHttp2Status;
 
 namespace grpc_core {
 
+#define GRPC_HTTP2_FRAME_DLOG \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 ///////////////////////////////////////////////////////////////////////////////
 // Settings Frame Validations
 
@@ -214,6 +220,11 @@ class SerializeHeaderAndPayload {
         serialize_return_(serialize_return) {}
 
   void operator()(Http2DataFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2DataFrame Type:0 { stream_id:"
+        << frame.stream_id << ", end_stream:" << frame.end_stream
+        << ", payload_length:" << frame.payload.Length()
+        << ", payload:" << MaybeTruncatePayload(frame.payload) << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
                      static_cast<uint8_t>(FrameType::kData),
@@ -226,6 +237,12 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2HeaderFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2HeaderFrame Type:1 { stream_id:"
+        << frame.stream_id << ", end_headers:" << frame.end_headers
+        << ", end_stream:" << frame.end_stream
+        << ", payload_length:" << frame.payload.Length()
+        << ", payload:" << MaybeTruncatePayload(frame.payload) << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
         static_cast<uint32_t>(frame.payload.Length()),
@@ -240,6 +257,13 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2ContinuationFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG << "SerializeHeaderAndPayload Http2ContinuationFrame "
+                             "Type:9 { stream_id:"
+                          << frame.stream_id
+                          << ", end_headers:" << frame.end_headers
+                          << ", payload_length:" << frame.payload.Length()
+                          << ", payload:" << MaybeTruncatePayload(frame.payload)
+                          << "}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
         static_cast<uint32_t>(frame.payload.Length()),
@@ -253,6 +277,9 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2RstStreamFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2RstStreamFrame Type:3 { stream_id:"
+        << frame.stream_id << ", error_code:" << frame.error_code << "}";
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
     Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kRstStream), 0,
                      frame.stream_id}
@@ -262,6 +289,10 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2SettingsFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2SettingsFrame Type:4 { ack:"
+        << frame.ack << ", length:" << frame.settings.size() << ", settings:["
+        << DebugStringSettings(frame.settings) << "] }";
     // Six bytes per setting (u16 id, u32 value)
     const size_t payload_size = 6 * frame.settings.size();
     auto hdr_and_payload =
@@ -280,6 +311,9 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2PingFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2PingFrame Type:6 { ack:" << frame.ack
+        << ", opaque:" << frame.opaque << "}";
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
     Http2FrameHeader{8, static_cast<uint8_t>(FrameType::kPing),
                      MaybeFlag(frame.ack, kFlagAck), 0}
@@ -289,6 +323,10 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2GoawayFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG
+        << "SerializeHeaderAndPayload Http2GoawayFrame Type:7 { last_stream_id:"
+        << frame.last_stream_id << ", error_code:" << frame.error_code
+        << ", debug_data:" << frame.debug_data.as_string_view() << "}";
     auto hdr_and_fixed_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
     Http2FrameHeader{static_cast<uint32_t>(8 + frame.debug_data.length()),
                      static_cast<uint8_t>(FrameType::kGoaway), 0, 0}
@@ -306,6 +344,10 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2WindowUpdateFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG << "SerializeHeaderAndPayload Http2WindowUpdateFrame "
+                             "Type:8 { stream_id:"
+                          << frame.stream_id
+                          << ", increment:" << frame.increment << "}";
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
     Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kWindowUpdate), 0,
                      frame.stream_id}
@@ -321,6 +363,9 @@ class SerializeHeaderAndPayload {
   }
 
   void operator()(Http2SecurityFrame& frame) {
+    GRPC_HTTP2_FRAME_DLOG << "SerializeHeaderAndPayload Http2SecurityFrame "
+                             "Type:200 { payload_length:"
+                          << frame.payload.Length() << ", payload: redacted}";
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
                      static_cast<uint8_t>(FrameType::kCustomSecurity), 0, 0}
@@ -331,9 +376,21 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2UnknownFrame&) { Crash("unreachable"); }
 
-  void operator()(Http2EmptyFrame&) {}
+  void operator()(Http2EmptyFrame&) {
+    GRPC_HTTP2_FRAME_DLOG << "SerializeHeaderAndPayload Http2EmptyFrame {}";
+  }
 
  private:
+  std::string DebugStringSettings(
+      const std::vector<Http2SettingsFrame::Setting>& settings) {
+    std::string settings_str;
+    for (const auto& setting : settings) {
+      absl::StrAppend(&settings_str, " {id:", setting.id,
+                      ", value:", setting.value, "}");
+    }
+    return settings_str;
+  }
+
   SliceBuffer& out_;
   MutableSlice extra_bytes_;
   SerializeReturn& serialize_return_;
@@ -390,6 +447,8 @@ ValueOrHttp2Status<Http2Frame> ParseDataFrame(const Http2FrameHeader& hdr,
                      std::move(payload)});
 }
 
+// This function MUST NOT return a Http2StreamError. Doing this will cause the
+// HPACK state to be corrupted.
 ValueOrHttp2Status<Http2Frame> ParseHeaderFrame(const Http2FrameHeader& hdr,
                                                 SliceBuffer& payload) {
   if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
@@ -426,6 +485,8 @@ ValueOrHttp2Status<Http2Frame> ParseHeaderFrame(const Http2FrameHeader& hdr,
       ExtractFlag(hdr.flags, kFlagEndStream), std::move(payload)});
 }
 
+// This function MUST NOT return a Http2StreamError. Doing this will cause the
+// HPACK state to be corrupted.
 ValueOrHttp2Status<Http2Frame> ParseContinuationFrame(
     const Http2FrameHeader& hdr, SliceBuffer& payload) {
   if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
@@ -577,15 +638,14 @@ ValueOrHttp2Status<Http2Frame> ParseWindowUpdateFrame(
   payload.CopyToBuffer(buffer);
   const uint32_t window_size_increment = Read31bits(buffer);
   if (GPR_UNLIKELY(window_size_increment == 0)) {
-    if (hdr.stream_id == 0) {
-      return Http2Status::Http2ConnectionError(
-          Http2ErrorCode::kProtocolError,
-          absl::StrCat(RFC9113::kWindowSizeIncrement, hdr.ToString()));
-    } else {
-      return Http2Status::Http2StreamError(
-          Http2ErrorCode::kProtocolError,
-          absl::StrCat(RFC9113::kWindowSizeIncrement, hdr.ToString()));
-    }
+    // According to RFC9113, if window_size_increment == 0, and (stream id != 0)
+    // the receiver MUST treat this as a stream error of type PROTOCOL_ERROR.
+    // However we will be treating this too as a connection error
+    // 1. To be consistent with CHTTP2 transport
+    // 2. To be less lenient as compared to the RFC9113 for security reasons.
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kWindowSizeIncrement, hdr.ToString()));
   }
   return ValueOrHttp2Status<Http2Frame>(
       Http2WindowUpdateFrame{hdr.stream_id, window_size_increment});
@@ -699,10 +759,10 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
   }
 }
 
-http2::Http2ErrorCode RstFrameErrorCodeToHttp2ErrorCode(
+http2::Http2ErrorCode FrameErrorCodeToHttp2ErrorCode(
     const uint32_t error_code) {
   if (GPR_UNLIKELY(error_code > http2::GetMaxHttp2ErrorCode())) {
-    LOG(ERROR) << "RstFrameErrorCodeToHttp2ErrorCode: Invalid error code "
+    LOG(ERROR) << "FrameErrorCodeToHttp2ErrorCode: Invalid error code "
                   "received from RST_STREAM frame: "
                << error_code;
     return http2::Http2ErrorCode::kInternalError;
@@ -710,9 +770,10 @@ http2::Http2ErrorCode RstFrameErrorCodeToHttp2ErrorCode(
   return static_cast<http2::Http2ErrorCode>(error_code);
 }
 
-uint32_t Http2ErrorCodeToRstFrameErrorCode(
+uint32_t Http2ErrorCodeToFrameErrorCode(
     const http2::Http2ErrorCode error_code) {
-  DCHECK_LE(static_cast<uint8_t>(error_code), http2::GetMaxHttp2ErrorCode());
+  GRPC_DCHECK_LE(static_cast<uint8_t>(error_code),
+                 http2::GetMaxHttp2ErrorCode());
   return static_cast<uint32_t>(error_code);
 }
 
@@ -722,28 +783,73 @@ size_t GetFrameMemoryUsage(const Http2Frame& frame) {
 
 ///////////////////////////////////////////////////////////////////////////////
 // GRPC Header
+namespace {
+ValueOrHttp2Status<uint32_t> ParseGrpcMessageFlags(const uint8_t flags) {
+  switch (flags) {
+    case kGrpcMessageHeaderNoFlags:
+      return 0u;
+    case kGrpcMessageHeaderWriteInternalCompress:
+      return GRPC_WRITE_INTERNAL_COMPRESS;
+    default:
+      LOG(ERROR) << "Invalid gRPC header flags: "
+                 << static_cast<uint32_t>(flags);
+      return Http2Status::Http2StreamError(
+          Http2ErrorCode::kInternalError,
+          absl::StrCat("Invalid gRPC header flags: ", flags));
+  }
+}
 
-GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
+uint8_t SerializeGrpcMessageFlags(const uint32_t flags) {
+  return (flags & GRPC_WRITE_INTERNAL_COMPRESS)
+             ? kGrpcMessageHeaderWriteInternalCompress
+             : kGrpcMessageHeaderNoFlags;
+}
+}  // namespace
+
+ValueOrHttp2Status<GrpcMessageHeader> ExtractGrpcHeader(SliceBuffer& payload) {
   GRPC_CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
   uint8_t buffer[kGrpcHeaderSizeInBytes];
   payload.CopyFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
   GrpcMessageHeader header;
-  header.flags = buffer[0];
+  ValueOrHttp2Status<uint32_t> message_flags = ParseGrpcMessageFlags(buffer[0]);
+  if (!message_flags.IsOk()) {
+    return message_flags.TakeStatus(std::move(message_flags));
+  }
+
+  header.flags = message_flags.value();
   header.length = Read4b(buffer + 1);
   return header;
 }
 
-void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint32_t flags,
                                    const uint32_t length) {
   uint8_t* frame_hdr = payload.AddTiny(kGrpcHeaderSizeInBytes);
-  frame_hdr[0] = flags;
+  frame_hdr[0] = SerializeGrpcMessageFlags(flags);
   Write4b(length, frame_hdr + 1);
 }
 
 Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                                 const bool incoming_header_in_progress,
                                 const uint32_t incoming_header_stream_id,
-                                Http2FrameHeader& current_frame_header) {
+                                Http2FrameHeader& current_frame_header,
+                                const uint32_t last_stream_id,
+                                const bool is_client,
+                                const bool is_first_settings_processed) {
+  if (GPR_UNLIKELY(!is_first_settings_processed)) {
+    // This check works only because we pause the read loop after reading the
+    // first SETTINGS frame.
+    const bool is_settings_frame =
+        (current_frame_header.type ==
+             static_cast<uint8_t>(FrameType::kSettings) &&
+         !ExtractFlag(current_frame_header.flags, kFlagAck));
+    if (GPR_UNLIKELY(!is_settings_frame)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(is_client ? RFC9113::kFirstSettingsFrameClient
+                                : RFC9113::kFirstSettingsFrameServer));
+    }
+  }
+
   if (GPR_UNLIKELY(current_frame_header.length > max_frame_size_setting)) {
     return Http2Status::Http2ConnectionError(
         Http2ErrorCode::kFrameSizeError,
@@ -760,8 +866,28 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
         Http2ErrorCode::kProtocolError,
         std::string(RFC9113::kAssemblerContiguousSequenceError));
   }
+  // If a frame is received with a stream id larger than the last stream id sent
+  // by the transport, it is a protocol error. This condition holds for clients
+  // as in gRPC only clients can initiate a stream. last_stream_id is the stream
+  // id of the last stream created by the transport. If no streams were created
+  // by the transport, last_stream_id is 0.
+  // TODO(akshitpatel) : [PH2][P3] : Revisit this for server.
+  if (is_client && current_frame_header.stream_id > last_stream_id) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError, std::string(RFC9113::kUnknownStreamId));
+  }
   // TODO(tjagtap) : [PH2][P2]:Consider validating MAX_CONCURRENT_STREAMS here
+  // for server.
   return Http2Status::Ok();
 }
 
+std::string MaybeTruncatePayload(SliceBuffer& payload, const uint32_t length) {
+  if (payload.Length() <= length) {
+    return payload.JoinIntoString();
+  }
+  std::string result(length, '\0');
+  payload.CopyFirstNBytesIntoBuffer(length, result.data());
+  return absl::StrCat(result, "<clipped>");
+}
+
 }  // namespace grpc_core

data/src/core/ext/transport/chttp2/transport/frame.h

@@ -22,16 +22,20 @@
 #include <variant>
 #include <vector>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/string_view.h"
-#include "absl/types/span.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/span.h"
 
 namespace grpc_core {
 
+// Prints the first `length` bytes of the payload. If the payload is longer than
+// `length`, it appends "<clipped>" to the output.
+std::string MaybeTruncatePayload(SliceBuffer& payload, uint32_t length = 15);
+
 ///////////////////////////////////////////////////////////////////////////////
 // Frame types
 //
@@ -242,8 +246,8 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
 // move things out of frames)
 SerializeReturn Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
-http2::Http2ErrorCode RstFrameErrorCodeToHttp2ErrorCode(uint32_t error_code);
-uint32_t Http2ErrorCodeToRstFrameErrorCode(http2::Http2ErrorCode error_code);
+http2::Http2ErrorCode FrameErrorCodeToHttp2ErrorCode(uint32_t error_code);
+uint32_t Http2ErrorCodeToFrameErrorCode(http2::Http2ErrorCode error_code);
 
 // Returns approximate memory usage of the frame.
 size_t GetFrameMemoryUsage(const Http2Frame& frame);
@@ -252,19 +256,22 @@ size_t GetFrameMemoryUsage(const Http2Frame& frame);
 // GRPC Header
 
 constexpr uint8_t kGrpcHeaderSizeInBytes = 5;
+constexpr uint8_t kGrpcMessageHeaderNoFlags = 0;
+constexpr uint8_t kGrpcMessageHeaderWriteInternalCompress = 1;
 
 struct GrpcMessageHeader {
-  uint8_t flags = 0;
+  uint32_t flags = 0;
   uint32_t length = 0;
 };
 
 // If the payload SliceBuffer is too small to hold a gRPC header, this function
 // will crash. The calling function MUST ensure that the payload SliceBuffer
 // has length greater than or equal to the gRPC header.
-GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload);
+http2::ValueOrHttp2Status<GrpcMessageHeader> ExtractGrpcHeader(
+    SliceBuffer& payload);
 
-void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
-                                   const uint32_t length);
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, uint32_t flags,
+                                   uint32_t length);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Validations
@@ -275,7 +282,9 @@ http2::Http2Status ValidateSettingsValues(
 http2::Http2Status ValidateFrameHeader(uint32_t max_frame_size_setting,
                                        bool incoming_header_in_progress,
                                        uint32_t incoming_header_stream_id,
-                                       Http2FrameHeader& current_frame_header);
+                                       Http2FrameHeader& current_frame_header,
+                                       uint32_t last_stream_id, bool is_client,
+                                       bool is_first_settings_processed);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RFC9113 Related Strings and Consts
@@ -309,6 +318,9 @@ inline constexpr absl::string_view kSettingsStreamIdMustBeZero =
     "RFC9113: If an endpoint receives a SETTINGS frame whose Stream "
     "Identifier field is anything other than 0x00, the endpoint MUST respond "
     "with a connection error";
+inline constexpr absl::string_view kUnknownStreamId =
+    "RFC9113: An endpoint that receives an unexpected stream identifier MUST "
+    "respond with a connection error";
 
 // Frame length related errors
 inline constexpr absl::string_view kRstStreamLength4 =
@@ -368,6 +380,18 @@ inline constexpr absl::string_view kIncorrectFrameSizeSetting =
 inline constexpr absl::string_view kSettingsTimeout =
     "Settings timeout. The HTTP2 settings frame was not ACKed within the "
     "timeout. Connection will be closed";
+inline constexpr absl::string_view kLastStreamClosed =
+    "Closing last stream and cannot create any more streams.";
+inline constexpr absl::string_view kFirstSettingsFrameClient =
+    "RFC9113: The server connection preface consists of a potentially empty "
+    "SETTINGS frame that MUST be the first frame the server sends in the "
+    "HTTP/2 connection. Clients and servers MUST treat an invalid connection "
+    "preface as a connection error of type PROTOCOL_ERROR.";
+inline constexpr absl::string_view kFirstSettingsFrameServer =
+    "RFC9113: The client connection preface starts with a sequence of 24 "
+    "octets. This sequence is followed by a SETTINGS frame, which MAY be "
+    "empty. Clients and servers MUST treat an invalid connection preface as a "
+    "connection error of type PROTOCOL_ERROR.";
 
 inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
 inline constexpr uint32_t kMaxSize31Bit = 0x7fffffffu;
@@ -378,6 +402,16 @@ inline constexpr uint32_t kMaximumFrameSize = 16777215;
 inline constexpr uint32_t kHttp2InitialWindowSize = 65535u;
 
 }  // namespace RFC9113
+
+namespace GrpcErrors {
+inline constexpr absl::string_view kTooManyMetadata =
+    "gRPC Error : A gRPC server can send upto 1 initial metadata followed by "
+    "upto 1 trailing metadata.";
+inline constexpr absl::string_view kOutOfOrderDataFrame =
+    "gRPC Error : DATA frames must follow initial metadata and precede "
+    "trailing metadata.";
+}  // namespace GrpcErrors
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

data/src/core/ext/transport/chttp2/transport/frame_data.cc

@@ -22,8 +22,6 @@
 #include <grpc/support/port_platform.h>
 #include <stdlib.h>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -33,6 +31,8 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
                                                  uint32_t stream_id,

data/src/core/ext/transport/chttp2/transport/frame_data.h

@@ -25,7 +25,6 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
-#include "absl/status/status.h"
 #include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/error.h"
@@ -33,6 +32,7 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "absl/status/status.h"
 
 // start processing a new data frame
 absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,

data/src/core/ext/transport/chttp2/transport/frame_goaway.cc

@@ -23,12 +23,12 @@
 #include <grpc/support/port_platform.h>
 #include <string.h>
 
+#include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/util/grpc_check.h"
 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/util/grpc_check.h"
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
   p->debug_data = nullptr;

data/src/core/ext/transport/chttp2/transport/frame_ping.cc

@@ -25,15 +25,15 @@
 
 #include <algorithm>
 
-#include "absl/container/flat_hash_map.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/util/grpc_check.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
   grpc_slice slice = GRPC_SLICE_MALLOC(9 + 8);

data/src/core/ext/transport/chttp2/transport/frame_rst_stream.cc

@@ -22,11 +22,6 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/log/log.h"
-#include "absl/random/distributions.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
@@ -38,6 +33,11 @@
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
+#include "absl/log/log.h"
+#include "absl/random/distributions.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 using grpc_core::http2::Http2ErrorCode;
 

data/src/core/ext/transport/chttp2/transport/frame_security.cc

@@ -19,13 +19,13 @@
 #include <cstddef>
 #include <cstdint>
 
-#include "absl/status/status.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "absl/status/status.h"
 
 absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
                                                      grpc_chttp2_transport* t,

data/src/core/ext/transport/chttp2/transport/frame_settings.cc

@@ -24,10 +24,6 @@
 
 #include <string>
 
-#include "absl/base/attributes.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
@@ -40,6 +36,10 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/useful.h"
+#include "absl/base/attributes.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
 
 using grpc_core::http2::Http2ErrorCode;
 
@@ -135,21 +135,13 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
             t->http2_ztrace_collector.Append(
                 []() { return grpc_core::H2SettingsTrace<false>{true, {}}; });
             *parser->target_settings = *parser->incoming_settings;
+            t->MaybeNotifyStateWatcherOfPeerMaxConcurrentStreamsLocked();
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
             grpc_chttp2_initiate_write(t,
                                        GRPC_CHTTP2_INITIATE_WRITE_SETTINGS_ACK);
-            if (t->notify_on_receive_settings != nullptr) {
-              if (t->interested_parties_until_recv_settings != nullptr) {
-                grpc_endpoint_delete_from_pollset_set(
-                    t->ep.get(), t->interested_parties_until_recv_settings);
-                t->interested_parties_until_recv_settings = nullptr;
-              }
-              grpc_core::ExecCtx::Run(DEBUG_LOCATION,
-                                      t->notify_on_receive_settings,
-                                      absl::OkStatus());
-              t->notify_on_receive_settings = nullptr;
-            }
+            t->MaybeNotifyOnReceiveSettingsLocked(
+                parser->target_settings->max_concurrent_streams());
           }
           return absl::OkStatus();
         }

data/src/core/ext/transport/chttp2/transport/frame_window_update.cc

@@ -21,9 +21,6 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
@@ -32,6 +29,9 @@
 #include "src/core/telemetry/stats.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/time.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 
 grpc_slice grpc_chttp2_window_update_create(
     uint32_t id, uint32_t window_delta,