grpc 1.72.0 → 1.73.0

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

@@ -24,13 +24,21 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/crash.h"
 
+using grpc_core::http2::Http2ErrorCode;
+using grpc_core::http2::Http2Status;
+using grpc_core::http2::ValueOrHttp2Status;
+
 namespace grpc_core {
 
 namespace {
 
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// framing code
+
 // HTTP2 Frame Types
 enum class FrameType : uint8_t {
   kData = 0,
@@ -73,6 +81,21 @@ uint32_t Read3b(const uint8_t* input) {
          static_cast<uint32_t>(input[1]) << 8 | static_cast<uint32_t>(input[2]);
 }
 
+constexpr uint32_t k8BitMask = 0x7f;
+
+void Write31bits(uint32_t x, uint8_t* output) {
+  output[0] = static_cast<uint8_t>(k8BitMask & (x >> 24));
+  output[1] = static_cast<uint8_t>(x >> 16);
+  output[2] = static_cast<uint8_t>(x >> 8);
+  output[3] = static_cast<uint8_t>(x);
+}
+
+uint32_t Read31bits(const uint8_t* input) {
+  return (k8BitMask & static_cast<uint32_t>(input[0])) << 24 |
+         static_cast<uint32_t>(input[1]) << 16 |
+         static_cast<uint32_t>(input[2]) << 8 | static_cast<uint32_t>(input[3]);
+}
+
 void Write4b(uint32_t x, uint8_t* output) {
   output[0] = static_cast<uint8_t>(x >> 24);
   output[1] = static_cast<uint8_t>(x >> 16);
@@ -129,7 +152,7 @@ class SerializeExtraBytesRequired {
   size_t operator()(const Http2WindowUpdateFrame&) { return 4; }
   size_t operator()(const Http2SecurityFrame&) { return 0; }
   size_t operator()(const Http2UnknownFrame&) { Crash("unreachable"); }
-  size_t operator()(const Http2EmptyFrame&) { Crash("unreachable"); }
+  size_t operator()(const Http2EmptyFrame&) { return 0; }
 };
 
 class SerializeHeaderAndPayload {
@@ -215,8 +238,12 @@ class SerializeHeaderAndPayload {
     Http2FrameHeader{static_cast<uint32_t>(8 + frame.debug_data.length()),
                      static_cast<uint8_t>(FrameType::kGoaway), 0, 0}
         .Serialize(hdr_and_fixed_payload.begin());
-    Write4b(frame.last_stream_id,
-            hdr_and_fixed_payload.begin() + kFrameHeaderSize);
+    if (GPR_UNLIKELY(frame.last_stream_id > RFC9113::kMaxStreamId31Bit)) {
+      LOG(ERROR) << "Stream ID will be truncated. The MSB will be set to 0 "
+                 << frame.last_stream_id;
+    }
+    Write31bits(frame.last_stream_id,
+                hdr_and_fixed_payload.begin() + kFrameHeaderSize);
     Write4b(frame.error_code,
             hdr_and_fixed_payload.begin() + kFrameHeaderSize + 4);
     out_.AppendIndexed(Slice(std::move(hdr_and_fixed_payload)));
@@ -228,7 +255,12 @@ class SerializeHeaderAndPayload {
     Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kWindowUpdate), 0,
                      frame.stream_id}
         .Serialize(hdr_and_payload.begin());
-    Write4b(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
+    if (GPR_UNLIKELY(frame.increment > RFC9113::kMaxStreamId31Bit)) {
+      LOG(ERROR) << "Http2WindowUpdateFrame increment will be truncated to 31 "
+                    "bits. The MSB will be set to 0 "
+                 << frame.increment;
+    }
+    Write31bits(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
   }
 
@@ -250,109 +282,162 @@ class SerializeHeaderAndPayload {
   MutableSlice extra_bytes_;
 };
 
-absl::Status StripPadding(SliceBuffer& payload) {
-  if (payload.Length() < 1) {
-    return absl::InternalError("padding flag set but no padding byte");
+Http2Status StripPadding(const Http2FrameHeader& hdr, SliceBuffer& payload) {
+  if (GPR_UNLIKELY(payload.Length() < 1)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kFrameParserIncorrectPadding, hdr.ToString()));
   }
+  const size_t payload_size = payload.Length();
   uint8_t padding_bytes;
   payload.MoveFirstNBytesIntoBuffer(1, &padding_bytes);
-  if (payload.Length() < padding_bytes) {
-    return absl::InternalError("padding flag set but not enough padding bytes");
+
+  if (GPR_UNLIKELY(payload_size <= padding_bytes)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kPaddingLengthLargerThanFrameLength,
+                     hdr.ToString()));
   }
+
+  // We dont check for padding being zero.
+  // No point checking bytes that will be discarded.
+  // RFC9113 : A receiver is not obligated to verify padding but MAY treat
+  // non-zero padding as a connection error of type PROTOCOL_ERROR.
   payload.RemoveLastNBytes(padding_bytes);
-  return absl::OkStatus();
+  return Http2Status::Ok();
 }
 
-absl::StatusOr<Http2DataFrame> ParseDataFrame(const Http2FrameHeader& hdr,
+ValueOrHttp2Status<Http2Frame> ParseDataFrame(const Http2FrameHeader& hdr,
                                               SliceBuffer& payload) {
-  if (hdr.stream_id == 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid stream id: ", hdr.ToString()));
+  if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
+    if ((hdr.stream_id == 0)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kDataStreamIdMustBeNonZero, hdr.ToString()));
+    } else {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kStreamIdMustBeOdd, hdr.ToString()));
+    }
   }
 
   if (hdr.flags & kFlagPadded) {
-    auto s = StripPadding(payload);
-    if (!s.ok()) return s;
+    Http2Status s = StripPadding(hdr, payload);
+    if (GPR_UNLIKELY(!s.IsOk())) {
+      return ValueOrHttp2Status<Http2Frame>(std::move(s));
+    }
   }
 
-  return Http2DataFrame{hdr.stream_id, ExtractFlag(hdr.flags, kFlagEndStream),
-                        std::move(payload)};
+  return ValueOrHttp2Status<Http2Frame>(
+      Http2DataFrame{hdr.stream_id, ExtractFlag(hdr.flags, kFlagEndStream),
+                     std::move(payload)});
 }
 
-absl::StatusOr<Http2HeaderFrame> ParseHeaderFrame(const Http2FrameHeader& hdr,
-                                                  SliceBuffer& payload) {
-  if (hdr.stream_id == 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid stream id: ", hdr.ToString()));
+ValueOrHttp2Status<Http2Frame> ParseHeaderFrame(const Http2FrameHeader& hdr,
+                                                SliceBuffer& payload) {
+  if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
+    if (hdr.stream_id == 0) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kHeaderStreamIdMustBeNonZero, hdr.ToString()));
+    } else {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kStreamIdMustBeOdd, hdr.ToString()));
+    }
   }
 
   if (hdr.flags & kFlagPadded) {
-    auto s = StripPadding(payload);
-    if (!s.ok()) return s;
+    Http2Status s = StripPadding(hdr, payload);
+    if (GPR_UNLIKELY(!s.IsOk())) {
+      return ValueOrHttp2Status<Http2Frame>(std::move(s));
+    }
   }
 
-  if (hdr.flags & kFlagPriority) {
-    if (payload.Length() < 5) {
-      return absl::InternalError(
-          absl::StrCat("invalid priority payload: ", hdr.ToString()));
+  if (GPR_UNLIKELY(hdr.flags & kFlagPriority)) {
+    if (GPR_UNLIKELY(payload.Length() < 5)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kIncorrectFrame, hdr.ToString()));
     }
     uint8_t trash[5];
     payload.MoveFirstNBytesIntoBuffer(5, trash);
   }
 
-  return Http2HeaderFrame{
+  return ValueOrHttp2Status<Http2Frame>(Http2HeaderFrame{
       hdr.stream_id, ExtractFlag(hdr.flags, kFlagEndHeaders),
-      ExtractFlag(hdr.flags, kFlagEndStream), std::move(payload)};
+      ExtractFlag(hdr.flags, kFlagEndStream), std::move(payload)});
 }
 
-absl::StatusOr<Http2ContinuationFrame> ParseContinuationFrame(
+ValueOrHttp2Status<Http2Frame> ParseContinuationFrame(
     const Http2FrameHeader& hdr, SliceBuffer& payload) {
-  if (hdr.stream_id == 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid stream id: ", hdr.ToString()));
+  if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
+    if (hdr.stream_id == 0) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kContinuationStreamIdMustBeNonZero,
+                       hdr.ToString()));
+    } else {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kStreamIdMustBeOdd, hdr.ToString()));
+    }
   }
 
-  return Http2ContinuationFrame{hdr.stream_id,
-                                ExtractFlag(hdr.flags, kFlagEndHeaders),
-                                std::move(payload)};
+  return ValueOrHttp2Status<Http2Frame>(Http2ContinuationFrame{
+      hdr.stream_id, ExtractFlag(hdr.flags, kFlagEndHeaders),
+      std::move(payload)});
 }
 
-absl::StatusOr<Http2RstStreamFrame> ParseRstStreamFrame(
-    const Http2FrameHeader& hdr, SliceBuffer& payload) {
-  if (payload.Length() != 4) {
-    return absl::InternalError(
-        absl::StrCat("invalid rst stream payload: ", hdr.ToString()));
-  }
-
-  if (hdr.stream_id == 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid stream id: ", hdr.ToString()));
+ValueOrHttp2Status<Http2Frame> ParseRstStreamFrame(const Http2FrameHeader& hdr,
+                                                   SliceBuffer& payload) {
+  if (GPR_UNLIKELY(payload.Length() != 4)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kRstStreamLength4, hdr.ToString()));
+  }
+
+  if (GPR_UNLIKELY((hdr.stream_id % 2) == 0)) {
+    if ((hdr.stream_id == 0)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kRstStreamStreamIdMustBeNonZero,
+                       hdr.ToString()));
+    } else {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kStreamIdMustBeOdd, hdr.ToString()));
+    }
   }
 
   uint8_t buffer[4];
   payload.CopyToBuffer(buffer);
 
-  return Http2RstStreamFrame{hdr.stream_id, Read4b(buffer)};
+  return ValueOrHttp2Status<Http2Frame>(
+      Http2RstStreamFrame{hdr.stream_id, Read4b(buffer)});
 }
 
-absl::StatusOr<Http2SettingsFrame> ParseSettingsFrame(
-    const Http2FrameHeader& hdr, SliceBuffer& payload) {
-  if (hdr.stream_id != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid stream id: ", hdr.ToString()));
-  }
-  if (hdr.flags == kFlagAck) {
-    if (payload.Length() != 0) {
-      return absl::InternalError(
-          absl::StrCat("invalid settings ack length: ", hdr.ToString()));
+ValueOrHttp2Status<Http2Frame> ParseSettingsFrame(const Http2FrameHeader& hdr,
+                                                  SliceBuffer& payload) {
+  if (GPR_UNLIKELY(hdr.stream_id != 0)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kSettingsStreamIdMustBeZero, hdr.ToString()));
+  }
+
+  if (hdr.flags & kFlagAck) {
+    if (GPR_UNLIKELY(payload.Length() != 0)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kFrameSizeError,
+          absl::StrCat(RFC9113::kSettingsLength0, hdr.ToString()));
     }
-    return Http2SettingsFrame{true, {}};
+    return ValueOrHttp2Status<Http2Frame>(Http2SettingsFrame{true, {}});
   }
 
-  if (payload.Length() % 6 != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid settings payload: ", hdr.ToString(),
-                     " -- settings must be multiples of 6 bytes long"));
+  if (GPR_UNLIKELY(payload.Length() % 6 != 0)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kSettingsLength6x, hdr.ToString()));
   }
 
   Http2SettingsFrame frame{false, {}};
@@ -364,19 +449,21 @@ absl::StatusOr<Http2SettingsFrame> ParseSettingsFrame(
         Read4b(buffer + 2),
     });
   }
-  return std::move(frame);
+  return ValueOrHttp2Status<Http2Frame>(std::move(frame));
 }
 
-absl::StatusOr<Http2PingFrame> ParsePingFrame(const Http2FrameHeader& hdr,
+ValueOrHttp2Status<Http2Frame> ParsePingFrame(const Http2FrameHeader& hdr,
                                               SliceBuffer& payload) {
-  if (payload.Length() != 8) {
-    return absl::InternalError(
-        absl::StrCat("invalid ping payload: ", hdr.ToString()));
+  if (GPR_UNLIKELY(payload.Length() != 8)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kPingLength8, hdr.ToString()));
   }
 
-  if (hdr.stream_id != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid ping stream id: ", hdr.ToString()));
+  if (GPR_UNLIKELY(hdr.stream_id != 0)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kPingStreamIdMustBeZero, hdr.ToString()));
   }
 
   // RFC9113 : Unused flags MUST be ignored on receipt and MUST be left unset
@@ -386,49 +473,65 @@ absl::StatusOr<Http2PingFrame> ParsePingFrame(const Http2FrameHeader& hdr,
   uint8_t buffer[8];
   payload.CopyToBuffer(buffer);
 
-  return Http2PingFrame{ack, Read8b(buffer)};
+  return ValueOrHttp2Status<Http2Frame>(Http2PingFrame{ack, Read8b(buffer)});
 }
 
-absl::StatusOr<Http2GoawayFrame> ParseGoawayFrame(const Http2FrameHeader& hdr,
-                                                  SliceBuffer& payload) {
-  if (payload.Length() < 8) {
-    return absl::InternalError(
-        absl::StrCat("invalid goaway payload: ", hdr.ToString(),
-                     " -- must be at least 8 bytes"));
+ValueOrHttp2Status<Http2Frame> ParseGoawayFrame(const Http2FrameHeader& hdr,
+                                                SliceBuffer& payload) {
+  if (GPR_UNLIKELY(payload.Length() < 8)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kGoAwayLength8, hdr.ToString()));
   }
 
-  if (hdr.stream_id != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid goaway stream id: ", hdr.ToString()));
+  if (GPR_UNLIKELY(hdr.stream_id != 0)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kGoAwayStreamIdMustBeZero, hdr.ToString()));
   }
 
   uint8_t buffer[8];
   payload.MoveFirstNBytesIntoBuffer(8, buffer);
-  return Http2GoawayFrame{Read4b(buffer), Read4b(buffer + 4),
-                          payload.JoinIntoSlice()};
+  return ValueOrHttp2Status<Http2Frame>(Http2GoawayFrame{
+      /*Last-Stream-ID (31)*/ Read31bits(buffer),
+      /*Error Code (32)*/ Read4b(buffer + 4),
+      /*Additional Debug Data(variable)*/ payload.JoinIntoSlice()});
 }
 
-absl::StatusOr<Http2WindowUpdateFrame> ParseWindowUpdateFrame(
+ValueOrHttp2Status<Http2Frame> ParseWindowUpdateFrame(
     const Http2FrameHeader& hdr, SliceBuffer& payload) {
-  if (payload.Length() != 4) {
-    return absl::InternalError(
-        absl::StrCat("invalid window update payload: ", hdr.ToString(),
-                     " -- must be 4 bytes"));
+  if (GPR_UNLIKELY(payload.Length() != 4)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kWindowUpdateLength4, hdr.ToString()));
   }
-
-  if (hdr.flags != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid window update flags: ", hdr.ToString()));
+  if (GPR_UNLIKELY(hdr.stream_id > 0u && (hdr.stream_id % 2) == 0)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        absl::StrCat(RFC9113::kStreamIdMustBeOdd, hdr.ToString()));
   }
-
   uint8_t buffer[4];
   payload.CopyToBuffer(buffer);
-  return Http2WindowUpdateFrame{hdr.stream_id, Read4b(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()));
+    }
+  }
+  return ValueOrHttp2Status<Http2Frame>(
+      Http2WindowUpdateFrame{hdr.stream_id, window_size_increment});
 }
 
-absl::StatusOr<Http2SecurityFrame> ParseSecurityFrame(
+ValueOrHttp2Status<Http2Frame> ParseSecurityFrame(
     const Http2FrameHeader& /*hdr*/, SliceBuffer& payload) {
-  return Http2SecurityFrame{std::move(payload)};
+  // TODO(tjagtap) : [PH2][P3] : Add validations
+  return ValueOrHttp2Status<Http2Frame>(Http2SecurityFrame{std::move(payload)});
 }
 
 }  // namespace
@@ -441,7 +544,11 @@ void Http2FrameHeader::Serialize(uint8_t* output) const {
 }
 
 Http2FrameHeader Http2FrameHeader::Parse(const uint8_t* input) {
-  return Http2FrameHeader{Read3b(input), input[3], input[4], Read4b(input + 5)};
+  return Http2FrameHeader{
+      /* Length(24) */ Read3b(input),
+      /* Type(8) */ input[3],
+      /* Flags(8) */ input[4],
+      /* Reserved(1), Stream Identifier(31) */ Read31bits(input + 5)};
 }
 
 namespace {
@@ -493,9 +600,10 @@ void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
   }
 }
 
-absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
-                                             SliceBuffer payload) {
+http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
+    const Http2FrameHeader& hdr, SliceBuffer payload) {
   CHECK(payload.Length() == hdr.length);
+
   switch (static_cast<FrameType>(hdr.type)) {
     case FrameType::kData:
       return ParseDataFrame(hdr, payload);
@@ -514,20 +622,20 @@ absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
     case FrameType::kWindowUpdate:
       return ParseWindowUpdateFrame(hdr, payload);
     case FrameType::kPushPromise:
-      return absl::InternalError(
-          "push promise not supported (and SETTINGS_ENABLE_PUSH explicitly "
-          "disabled).");
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kNoPushPromise, hdr.ToString()));
     case FrameType::kCustomSecurity:
       return ParseSecurityFrame(hdr, payload);
     default:
-      return Http2UnknownFrame{};
+      return ValueOrHttp2Status<Http2Frame>(Http2UnknownFrame{});
   }
 }
 
 GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
   CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
   uint8_t buffer[kGrpcHeaderSizeInBytes];
-  payload.MoveFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
+  payload.CopyFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
   GrpcMessageHeader header;
   header.flags = buffer[0];
   header.length = Read4b(buffer + 1);

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

@@ -25,6 +25,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.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"
 
@@ -156,8 +157,8 @@ struct Http2GoawayFrame {
 
 // WINDOW_UPDATE frame
 struct Http2WindowUpdateFrame {
-  uint32_t stream_id;
-  uint32_t increment;
+  uint32_t stream_id = 0;
+  uint32_t increment = 0;
 
   bool operator==(const Http2WindowUpdateFrame& other) const {
     return stream_id == other.stream_id && increment == other.increment;
@@ -229,8 +230,8 @@ struct Http2FrameHeader {
 // If a frame should simply be ignored, this function returns a
 // Http2UnknownFrame.
 // It is expected that hdr.length == payload.Length().
-absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
-                                             SliceBuffer payload);
+http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
+    const Http2FrameHeader& hdr, SliceBuffer payload);
 
 // Serialize frame and append to out, leaves frames in an unknown state (may
 // move things out of frames)
@@ -242,8 +243,8 @@ void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 constexpr uint8_t kGrpcHeaderSizeInBytes = 5;
 
 struct GrpcMessageHeader {
-  uint8_t flags;
-  uint32_t length;
+  uint8_t flags = 0;
+  uint32_t length = 0;
 };
 
 // If the payload SliceBuffer is too small to hold a gRPC header, this function
@@ -254,6 +255,77 @@ GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload);
 void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
                                    const uint32_t length);
 
+namespace RFC9113 {
+// RFC9113: 5.1.1.
+inline constexpr absl::string_view kStreamIdMustBeOdd =
+    "RFC9113: Streams initiated by a client MUST use odd-numbered stream "
+    "identifiers";  // gRPC streams are only initiated by a client.
+
+// 6.
+// Stream Identifier related errors
+// Non-Zero Stream Identifier
+inline constexpr absl::string_view kDataStreamIdMustBeNonZero =
+    "RFC9113: DATA frames MUST be associated with a stream";
+inline constexpr absl::string_view kHeaderStreamIdMustBeNonZero =
+    "RFC9113: HEADERS frames MUST be associated with a stream";
+inline constexpr absl::string_view kContinuationStreamIdMustBeNonZero =
+    "RFC9113: CONTINUATION frames MUST be associated with a stream";
+inline constexpr absl::string_view kRstStreamStreamIdMustBeNonZero =
+    "RFC9113: RST_STREAM frames frames MUST be associated with a stream";
+
+// Zero Stream Identifier
+inline constexpr absl::string_view kPingStreamIdMustBeZero =
+    "RFC9113: If a PING frame is received with a Stream Identifier field "
+    "value other than 0x00, the recipient MUST respond with a connection error";
+inline constexpr absl::string_view kGoAwayStreamIdMustBeZero =
+    "RFC9113: An endpoint MUST treat a GOAWAY frame with a stream identifier "
+    "other than 0x00 as a connection error";
+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";
+
+// Frame length related errors
+inline constexpr absl::string_view kRstStreamLength4 =
+    "RFC9113: A RST_STREAM frame with a length other than 4 octets MUST be "
+    "treated as a connection error";
+inline constexpr absl::string_view kSettingsLength0 =
+    "RFC9113: Receipt of a SETTINGS frame with the ACK flag set and a length "
+    "field value other than 0 MUST be treated as a connection error";
+inline constexpr absl::string_view kSettingsLength6x =
+    "RFC9113: SETTINGS frame with a length other than a multiple of 6 octets "
+    "MUST be treated as a connection error";
+inline constexpr absl::string_view kPingLength8 =
+    "RFC9113: Receipt of a PING frame with a length field value other than 8 "
+    "MUST be treated as a connection error";
+inline constexpr absl::string_view kWindowUpdateLength4 =
+    "RFC9113: A WINDOW_UPDATE frame with a length other than 4 octets MUST be "
+    "treated as a connection error";
+inline constexpr absl::string_view kWindowSizeIncrement =
+    "RFC9113: The legal range for the increment to the flow-control window is "
+    "1 to (2^31)-1";
+inline constexpr absl::string_view kPaddingLengthLargerThanFrameLength =
+    "RFC9113: If the length of the padding is the length of the frame payload "
+    "or greater, the recipient MUST treat this as a connection error";
+
+// Misc Errors
+inline constexpr absl::string_view kNoPushPromise =
+    "RFC9113: PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH "
+    "setting of the "
+    "peer endpoint is set to 0";
+
+inline constexpr absl::string_view kFrameParserIncorrectPadding =
+    "Incorrect length of padding in frame";
+inline constexpr absl::string_view kIncorrectFrame = "Incorrect Frame";
+inline constexpr absl::string_view kGoAwayLength8 =
+    "GOAWAY frame should have a Last-Stream-ID and Error Code making the "
+    "minimum length 8 octets";
+
+// TODO(tjagtap) : [PH2][P2] : Take care that our transport class does not make
+// stream id larger than this.
+inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
+
+}  // namespace RFC9113
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_H

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

@@ -55,6 +55,7 @@ absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              uint32_t write_bytes, int is_eof,
                              grpc_core::CallTracerInterface* call_tracer,
+                             grpc_core::Http2ZTraceCollector* ztrace_collector,
                              grpc_slice_buffer* outbuf) {
   grpc_slice hdr;
   uint8_t* p;
@@ -74,6 +75,9 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
   *p++ = static_cast<uint8_t>(id);
   grpc_slice_buffer_add(outbuf, hdr);
 
+  ztrace_collector->Append(
+      grpc_core::H2DataTrace<false>{id, is_eof != 0, write_bytes});
+
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
   grpc_core::global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
@@ -148,6 +152,12 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
   grpc_slice_buffer_add(&s->frame_storage, slice);
   grpc_chttp2_maybe_complete_recv_message(t, s);
 
+  if (is_last) {
+    t->http2_ztrace_collector.Append(grpc_core::H2DataTrace<true>{
+        t->incoming_stream_id,
+        (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) != 0,
+        t->incoming_frame_size});
+  }
   if (is_last && s->received_last_frame) {
     grpc_chttp2_mark_stream_closed(
         t, s, true, false,

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

@@ -26,6 +26,7 @@
 #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"
 #include "src/core/lib/promise/poll.h"
@@ -49,6 +50,7 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* parser,
 void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
                              uint32_t write_bytes, int is_eof,
                              grpc_core::CallTracerInterface* call_tracer,
+                             grpc_core::Http2ZTraceCollector* ztrace_collector,
                              grpc_slice_buffer* outbuf);
 
 grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(