grpc 1.75.0 → 1.78.1

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

@@ -0,0 +1,105 @@
+//
+//
+// Copyright 2025 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_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FLOW_CONTROL_MANAGER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FLOW_CONTROL_MANAGER_H
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include "src/core/ext/transport/chttp2/transport/flow_control.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/util/grpc_check.h"
+#include "absl/container/flat_hash_map.h"
+
+namespace grpc_core {
+namespace http2 {
+
+constexpr chttp2::FlowControlAction::Urgency kNoActionNeeded =
+    chttp2::FlowControlAction::Urgency::NO_ACTION_NEEDED;
+constexpr chttp2::FlowControlAction::Urgency kUpdateImmediately =
+    chttp2::FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
+constexpr int64_t kZero = 0;
+
+#define GRPC_HTTP2_FLOW_CONTROL_HELPERS \
+  DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
+// Function to update local settings based on FlowControlAction.
+// This function does the settings related tasks equivalent to
+// grpc_chttp2_act_on_flowctl_action in chttp2_transport.cc
+inline void ActOnFlowControlActionSettings(
+    const chttp2::FlowControlAction& action, Http2Settings& local_settings,
+    const bool enable_preferred_rx_crypto_frame_advertisement) {
+  if (action.send_initial_window_update() != kNoActionNeeded) {
+    local_settings.SetInitialWindowSize(action.initial_window_size());
+  }
+  if (action.send_max_frame_size_update() != kNoActionNeeded) {
+    local_settings.SetMaxFrameSize(action.max_frame_size());
+  }
+  if (enable_preferred_rx_crypto_frame_advertisement &&
+      action.preferred_rx_crypto_frame_size_update() != kNoActionNeeded) {
+    local_settings.SetPreferredReceiveCryptoMessageSize(
+        action.preferred_rx_crypto_frame_size());
+  }
+}
+
+// RFC9113 : A sender MUST NOT allow a flow-control window to exceed ((2^31)-1)
+// octets. If a sender receives a WINDOW_UPDATE that causes a flow-control
+// window to exceed this maximum, it MUST terminate either the stream or the
+// connection, as appropriate.
+// While the return value is int64_t for compatibility with CHTTP2 flow control,
+// we dont expect this value to exceed ((2^31)-1) i.e kMaxSize31Bit
+inline int64_t GetStreamFlowControlTokens(
+    chttp2::StreamFlowControl& stream_flow_control,
+    const Http2Settings& peer_settings) {
+  GRPC_DCHECK(stream_flow_control.remote_window_delta() +
+                  peer_settings.initial_window_size() <=
+              RFC9113::kMaxSize31Bit);
+  return std::max(kZero, stream_flow_control.remote_window_delta() +
+                             peer_settings.initial_window_size());
+}
+
+inline uint32_t GetMaxPermittedDequeue(
+    chttp2::TransportFlowControl& transport_flow_control,
+    chttp2::StreamFlowControl& stream_flow_control, const size_t upper_limit,
+    const Http2Settings& peer_settings) {
+  const int64_t flow_control_tokens =
+      std::min(transport_flow_control.remote_window(),
+               GetStreamFlowControlTokens(stream_flow_control, peer_settings));
+  uint32_t max_dequeue = 0;
+  if (flow_control_tokens > 0) {
+    max_dequeue = static_cast<uint32_t>(
+        std::min({static_cast<size_t>(flow_control_tokens), upper_limit,
+                  static_cast<size_t>(RFC9113::kMaxSize31Bit - 1)}));
+  }
+  GRPC_HTTP2_FLOW_CONTROL_HELPERS
+      << "GetFlowControlTokens flow_control_tokens = " << flow_control_tokens
+      << " upper_limit = " << upper_limit << " max_dequeue = " << max_dequeue;
+  return max_dequeue;
+}
+
+// TODO(tjagtap) [PH2][P4] : Ensure that the total transport flow control window
+// or stream flow control window does not exceed the max permitted limit of
+// 2^31-1
+
+}  // namespace http2
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FLOW_CONTROL_MANAGER_H

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

@@ -20,14 +20,18 @@
 #include <cstdint>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "absl/log/check.h"
-#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
@@ -38,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
 
@@ -119,7 +126,7 @@ uint16_t Read2b(const uint8_t* input) {
 }
 
 void Write3b(uint32_t x, uint8_t* output) {
-  CHECK_LT(x, 16777216u);
+  GRPC_CHECK_LT(x, 16777216u);
   output[0] = static_cast<uint8_t>(x >> 16);
   output[1] = static_cast<uint8_t>(x >> 8);
   output[2] = static_cast<uint8_t>(x);
@@ -206,11 +213,18 @@ class SerializeExtraBytesRequired {
 
 class SerializeHeaderAndPayload {
  public:
-  SerializeHeaderAndPayload(size_t extra_bytes, SliceBuffer& out)
+  SerializeHeaderAndPayload(size_t extra_bytes, SliceBuffer& out,
+                            SerializeReturn& serialize_return)
       : out_(out),
-        extra_bytes_(MutableSlice::CreateUninitialized(extra_bytes)) {}
+        extra_bytes_(MutableSlice::CreateUninitialized(extra_bytes)),
+        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),
@@ -219,9 +233,16 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   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()),
@@ -232,9 +253,17 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   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()),
@@ -244,9 +273,13 @@ class SerializeHeaderAndPayload {
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   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}
@@ -256,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 =
@@ -274,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}
@@ -283,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}
@@ -300,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}
@@ -311,9 +359,13 @@ class SerializeHeaderAndPayload {
     }
     Write31bits(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
+    serialize_return_.should_reset_ping_clock = true;
   }
 
   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}
@@ -324,11 +376,24 @@ 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_;
 };
 
 Http2Status StripPadding(const Http2FrameHeader& hdr, SliceBuffer& payload) {
@@ -382,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)) {
@@ -418,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)) {
@@ -569,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});
@@ -642,23 +710,26 @@ std::string Http2FrameHeader::ToString() const {
                       ", length=", length, "}");
 }
 
-void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
+SerializeReturn Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
   size_t buffer_needed = 0;
+  SerializeReturn serialize_return{/*should_reset_ping_clock=*/false};
   for (auto& frame : frames) {
     // Bytes needed for framing
     buffer_needed += kFrameHeaderSize;
     // Bytes needed for frame payload
     buffer_needed += std::visit(SerializeExtraBytesRequired(), frame);
   }
-  SerializeHeaderAndPayload serialize(buffer_needed, out);
+  SerializeHeaderAndPayload serialize(buffer_needed, out, serialize_return);
   for (auto& frame : frames) {
     std::visit(serialize, frame);
   }
+
+  return serialize_return;
 }
 
 http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
     const Http2FrameHeader& hdr, SliceBuffer payload) {
-  CHECK(payload.Length() == hdr.length);
+  GRPC_CHECK(payload.Length() == hdr.length);
 
   switch (static_cast<FrameType>(hdr.type)) {
     case FrameType::kData:
@@ -688,9 +759,10 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
   }
 }
 
-http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
+http2::Http2ErrorCode FrameErrorCodeToHttp2ErrorCode(
+    const uint32_t error_code) {
   if (GPR_UNLIKELY(error_code > http2::GetMaxHttp2ErrorCode())) {
-    LOG(ERROR) << "Http2ErrorCodeFromRstFrameErrorCode: Invalid error code "
+    LOG(ERROR) << "FrameErrorCodeToHttp2ErrorCode: Invalid error code "
                   "received from RST_STREAM frame: "
                << error_code;
     return http2::Http2ErrorCode::kInternalError;
@@ -698,30 +770,86 @@ http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
   return static_cast<http2::Http2ErrorCode>(error_code);
 }
 
+uint32_t Http2ErrorCodeToFrameErrorCode(
+    const http2::Http2ErrorCode error_code) {
+  GRPC_DCHECK_LE(static_cast<uint8_t>(error_code),
+                 http2::GetMaxHttp2ErrorCode());
+  return static_cast<uint32_t>(error_code);
+}
+
+size_t GetFrameMemoryUsage(const Http2Frame& frame) {
+  return MemoryUsageOf(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) {
-  CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
+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,
@@ -738,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
 //
@@ -224,6 +228,10 @@ struct Http2FrameHeader {
 ///////////////////////////////////////////////////////////////////////////////
 // Parsing & serialization
 
+struct SerializeReturn {
+  bool should_reset_ping_clock;
+};
+
 // Given a frame header and a payload, parse the payload into a frame and
 // return it.
 // If this function returns an error, that should be considered a connection
@@ -236,27 +244,34 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
 
 // Serialize frame and append to out, leaves frames in an unknown state (may
 // move things out of frames)
-void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
+SerializeReturn Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
+
+http2::Http2ErrorCode FrameErrorCodeToHttp2ErrorCode(uint32_t error_code);
+uint32_t Http2ErrorCodeToFrameErrorCode(http2::Http2ErrorCode error_code);
 
-http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code);
+// Returns approximate memory usage of the frame.
+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
@@ -267,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
@@ -301,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 =
@@ -357,13 +377,41 @@ inline constexpr absl::string_view kIncorrectFrameSizeSetting =
     "RFC9113: The initial value is 2^14 (16,384) octets. The value advertised"
     " by an endpoint MUST be between this initial value and the maximum allowed"
     " frame size (2^24)-1 or 16,777,215 octets), inclusive. ";
+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;
 inline constexpr uint32_t kMinimumFrameSize = 16384;
 inline constexpr uint32_t kMaximumFrameSize = 16777215;
 
+// Default Initial Window Size as per RFC 9113 Section 6.5.2
+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,9 +22,6 @@
 #include <grpc/support/port_platform.h>
 #include <stdlib.h>
 
-#include "absl/log/check.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"
@@ -32,7 +29,10 @@
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/transport.h"
 #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,
@@ -63,7 +63,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   hdr = GRPC_SLICE_MALLOC(header_size);
   p = GRPC_SLICE_START_PTR(hdr);
-  CHECK(write_bytes < (1 << 24));
+  GRPC_CHECK(write_bytes < (1 << 24));
   *p++ = static_cast<uint8_t>(write_bytes >> 16);
   *p++ = static_cast<uint8_t>(write_bytes >> 8);
   *p++ = static_cast<uint8_t>(write_bytes);