grpc 1.71.0 → 1.73.0

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

@@ -18,27 +18,41 @@
 #include <stddef.h>
 
 #include <cstdint>
+#include <string>
 #include <utility>
 
 #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 {
 
-constexpr uint8_t kFrameTypeData = 0;
-constexpr uint8_t kFrameTypeHeader = 1;
-constexpr uint8_t kFrameTypeContinuation = 9;
-constexpr uint8_t kFrameTypeRstStream = 3;
-constexpr uint8_t kFrameTypeSettings = 4;
-constexpr uint8_t kFrameTypePing = 6;
-constexpr uint8_t kFrameTypeGoaway = 7;
-constexpr uint8_t kFrameTypeWindowUpdate = 8;
-constexpr uint8_t kFrameTypePushPromise = 5;
-constexpr uint8_t kFrameTypeSecurity = 200;
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// framing code
+
+// HTTP2 Frame Types
+enum class FrameType : uint8_t {
+  kData = 0,
+  kHeader = 1,
+  // type 2 was Priority which has been deprecated.
+  kRstStream = 3,
+  kSettings = 4,
+  kPushPromise = 5,
+  kPing = 6,
+  kGoaway = 7,
+  kWindowUpdate = 8,
+  kContinuation = 9,
+  kCustomSecurity = 200,  // Custom Frame Type
+};
 
 constexpr uint8_t kFlagEndStream = 1;
 constexpr uint8_t kFlagAck = 1;
@@ -46,8 +60,6 @@ constexpr uint8_t kFlagEndHeaders = 4;
 constexpr uint8_t kFlagPadded = 8;
 constexpr uint8_t kFlagPriority = 0x20;
 
-constexpr size_t kFrameHeaderSize = 9;
-
 void Write2b(uint16_t x, uint8_t* output) {
   output[0] = static_cast<uint8_t>(x >> 8);
   output[1] = static_cast<uint8_t>(x);
@@ -69,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);
@@ -125,6 +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&) { return 0; }
 };
 
 class SerializeHeaderAndPayload {
@@ -135,9 +163,10 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2DataFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
-    Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeData,
-        MaybeFlag(frame.end_stream, kFlagEndStream), frame.stream_id}
+    Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
+                     static_cast<uint8_t>(FrameType::kData),
+                     MaybeFlag(frame.end_stream, kFlagEndStream),
+                     frame.stream_id}
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
@@ -146,7 +175,8 @@ class SerializeHeaderAndPayload {
   void operator()(Http2HeaderFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeHeader,
+        static_cast<uint32_t>(frame.payload.Length()),
+        static_cast<uint8_t>(FrameType::kHeader),
         static_cast<uint8_t>(MaybeFlag(frame.end_headers, kFlagEndHeaders) |
                              MaybeFlag(frame.end_stream, kFlagEndStream)),
         frame.stream_id}
@@ -158,7 +188,8 @@ class SerializeHeaderAndPayload {
   void operator()(Http2ContinuationFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{
-        static_cast<uint32_t>(frame.payload.Length()), kFrameTypeContinuation,
+        static_cast<uint32_t>(frame.payload.Length()),
+        static_cast<uint8_t>(FrameType::kContinuation),
         static_cast<uint8_t>(MaybeFlag(frame.end_headers, kFlagEndHeaders)),
         frame.stream_id}
         .Serialize(hdr.begin());
@@ -168,8 +199,9 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2RstStreamFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
-    Http2FrameHeader{4, kFrameTypeRstStream, 0, frame.stream_id}.Serialize(
-        hdr_and_payload.begin());
+    Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kRstStream), 0,
+                     frame.stream_id}
+        .Serialize(hdr_and_payload.begin());
     Write4b(frame.error_code, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
   }
@@ -179,7 +211,8 @@ class SerializeHeaderAndPayload {
     const size_t payload_size = 6 * frame.settings.size();
     auto hdr_and_payload =
         extra_bytes_.TakeFirst(kFrameHeaderSize + payload_size);
-    Http2FrameHeader{static_cast<uint32_t>(payload_size), kFrameTypeSettings,
+    Http2FrameHeader{static_cast<uint32_t>(payload_size),
+                     static_cast<uint8_t>(FrameType::kSettings),
                      MaybeFlag(frame.ack, kFlagAck), 0}
         .Serialize(hdr_and_payload.begin());
     size_t offset = kFrameHeaderSize;
@@ -193,7 +226,8 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2PingFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
-    Http2FrameHeader{8, kFrameTypePing, MaybeFlag(frame.ack, kFlagAck), 0}
+    Http2FrameHeader{8, static_cast<uint8_t>(FrameType::kPing),
+                     MaybeFlag(frame.ack, kFlagAck), 0}
         .Serialize(hdr_and_payload.begin());
     Write8b(frame.opaque, hdr_and_payload.begin() + kFrameHeaderSize);
     out_.AppendIndexed(Slice(std::move(hdr_and_payload)));
@@ -202,10 +236,14 @@ class SerializeHeaderAndPayload {
   void operator()(Http2GoawayFrame& frame) {
     auto hdr_and_fixed_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 8);
     Http2FrameHeader{static_cast<uint32_t>(8 + frame.debug_data.length()),
-                     kFrameTypeGoaway, 0, 0}
+                     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)));
@@ -214,16 +252,22 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2WindowUpdateFrame& frame) {
     auto hdr_and_payload = extra_bytes_.TakeFirst(kFrameHeaderSize + 4);
-    Http2FrameHeader{4, kFrameTypeWindowUpdate, 0, frame.stream_id}.Serialize(
-        hdr_and_payload.begin());
-    Write4b(frame.increment, hdr_and_payload.begin() + kFrameHeaderSize);
+    Http2FrameHeader{4, static_cast<uint8_t>(FrameType::kWindowUpdate), 0,
+                     frame.stream_id}
+        .Serialize(hdr_and_payload.begin());
+    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)));
   }
 
   void operator()(Http2SecurityFrame& frame) {
     auto hdr = extra_bytes_.TakeFirst(kFrameHeaderSize);
     Http2FrameHeader{static_cast<uint32_t>(frame.payload.Length()),
-                     kFrameTypeSecurity, 0, 0}
+                     static_cast<uint8_t>(FrameType::kCustomSecurity), 0, 0}
         .Serialize(hdr.begin());
     out_.AppendIndexed(Slice(std::move(hdr)));
     out_.TakeAndAppend(frame.payload);
@@ -231,114 +275,169 @@ class SerializeHeaderAndPayload {
 
   void operator()(Http2UnknownFrame&) { Crash("unreachable"); }
 
+  void operator()(Http2EmptyFrame&) {}
+
  private:
   SliceBuffer& out_;
   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, {}};
@@ -350,85 +449,89 @@ 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()));
   }
 
-  bool ack;
-  switch (hdr.flags) {
-    case 0:
-      ack = false;
-      break;
-    case kFlagAck:
-      ack = true;
-      break;
-    default:
-      return absl::InternalError(
-          absl::StrCat("invalid ping flags: ", hdr.ToString()));
-  }
+  // RFC9113 : Unused flags MUST be ignored on receipt and MUST be left unset
+  // (0x00) when sending.
+  bool ack = ((hdr.flags & kFlagAck) == kFlagAck);
 
   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"));
-  }
-
-  if (hdr.stream_id != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid goaway stream id: ", hdr.ToString()));
+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.flags != 0) {
-    return absl::InternalError(
-        absl::StrCat("invalid goaway flags: ", 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,38 +544,46 @@ 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 {
-std::string Http2FrameTypeString(uint8_t frame_type) {
+
+std::string Http2FrameTypeString(FrameType frame_type) {
   switch (frame_type) {
-    case kFrameTypeData:
+    case FrameType::kData:
       return "DATA";
-    case kFrameTypeHeader:
+    case FrameType::kHeader:
       return "HEADER";
-    case kFrameTypeContinuation:
-      return "CONTINUATION";
-    case kFrameTypeRstStream:
+    case FrameType::kRstStream:
       return "RST_STREAM";
-    case kFrameTypeSettings:
+    case FrameType::kSettings:
       return "SETTINGS";
-    case kFrameTypeGoaway:
+    case FrameType::kPushPromise:
+      return "PUSH_PROMISE";
+    case FrameType::kPing:
+      return "PING";
+    case FrameType::kGoaway:
       return "GOAWAY";
-    case kFrameTypeWindowUpdate:
+    case FrameType::kWindowUpdate:
       return "WINDOW_UPDATE";
-    case kFrameTypePing:
-      return "PING";
-    case kFrameTypeSecurity:
+    case FrameType::kContinuation:
+      return "CONTINUATION";
+    case FrameType::kCustomSecurity:
       return "SECURITY";
   }
-  return absl::StrCat("UNKNOWN(", frame_type, ")");
+  return absl::StrCat("UNKNOWN(", static_cast<uint8_t>(frame_type), ")");
 }
 }  // namespace
 
 std::string Http2FrameHeader::ToString() const {
-  return absl::StrCat("{", Http2FrameTypeString(type), ": flags=", flags,
-                      ", stream_id=", stream_id, ", length=", length, "}");
+  return absl::StrCat("{", Http2FrameTypeString(static_cast<FrameType>(type)),
+                      ": flags=", flags, ", stream_id=", stream_id,
+                      ", length=", length, "}");
 }
 
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out) {
@@ -489,35 +600,53 @@ 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 (hdr.type) {
-    case kFrameTypeData:
+
+  switch (static_cast<FrameType>(hdr.type)) {
+    case FrameType::kData:
       return ParseDataFrame(hdr, payload);
-    case kFrameTypeHeader:
+    case FrameType::kHeader:
       return ParseHeaderFrame(hdr, payload);
-    case kFrameTypeContinuation:
+    case FrameType::kContinuation:
       return ParseContinuationFrame(hdr, payload);
-    case kFrameTypeRstStream:
+    case FrameType::kRstStream:
       return ParseRstStreamFrame(hdr, payload);
-    case kFrameTypeSettings:
+    case FrameType::kSettings:
       return ParseSettingsFrame(hdr, payload);
-    case kFrameTypePing:
+    case FrameType::kPing:
       return ParsePingFrame(hdr, payload);
-    case kFrameTypeGoaway:
+    case FrameType::kGoaway:
       return ParseGoawayFrame(hdr, payload);
-    case kFrameTypeWindowUpdate:
+    case FrameType::kWindowUpdate:
       return ParseWindowUpdateFrame(hdr, payload);
-    case kFrameTypePushPromise:
-      return absl::InternalError(
-          "push promise not supported (and SETTINGS_ENABLE_PUSH explicitly "
-          "disabled).");
-    case kFrameTypeSecurity:
+    case FrameType::kPushPromise:
+      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.CopyFirstNBytesIntoBuffer(kGrpcHeaderSizeInBytes, buffer);
+  GrpcMessageHeader header;
+  header.flags = buffer[0];
+  header.length = Read4b(buffer + 1);
+  return header;
+}
+
+void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
+                                   const uint32_t length) {
+  uint8_t* frame_hdr = payload.AddTiny(kGrpcHeaderSizeInBytes);
+  frame_hdr[0] = flags;
+  Write4b(length, frame_hdr + 1);
+}
+
 }  // namespace grpc_core