grpc 1.81.1 → 1.83.0

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

@@ -45,16 +45,14 @@ constexpr int64_t kZero = 0;
 // 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) {
+    const chttp2::FlowControlAction& action, Http2Settings& local_settings) {
   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) {
+  if (action.preferred_rx_crypto_frame_size_update() != kNoActionNeeded) {
     local_settings.SetPreferredReceiveCryptoMessageSize(
         action.preferred_rx_crypto_frame_size());
   }

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

@@ -33,7 +33,7 @@
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // framing code
 
 using grpc_core::http2::Http2ErrorCode;
@@ -650,7 +650,6 @@ ValueOrHttp2Status<Http2Frame> ParseWindowUpdateFrame(
 
 ValueOrHttp2Status<Http2Frame> ParseSecurityFrame(
     const Http2FrameHeader& /*hdr*/, SliceBuffer& payload) {
-  // TODO(tjagtap) : [PH2][P3] : Add validations
   return ValueOrHttp2Status<Http2Frame>(Http2SecurityFrame{std::move(payload)});
 }
 
@@ -828,10 +827,18 @@ void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint32_t flags,
 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,
+                                const Http2FrameHeader& current_frame_header,
                                 const uint32_t last_stream_id,
                                 const bool is_client,
-                                const bool is_first_settings_processed) {
+                                const bool is_first_settings_processed,
+                                Http2FrameCountTracker& tracker,
+                                const uint32_t max_security_frame_size) {
+  const bool is_data_frame =
+      current_frame_header.type == static_cast<uint8_t>(FrameType::kData);
+  const bool is_continuation_frame =
+      current_frame_header.type ==
+      static_cast<uint8_t>(FrameType::kContinuation);
+
   if (GPR_UNLIKELY(!is_first_settings_processed)) {
     // This check works only because we pause the read loop after reading the
     // first SETTINGS frame.
@@ -854,11 +861,30 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
                      ", Current Size = ", current_frame_header.length,
                      ", Max Size = ", max_frame_size_setting));
   }
-  if (GPR_UNLIKELY(
-          incoming_header_in_progress &&
-          (current_frame_header.type !=
-               static_cast<uint8_t>(FrameType::kContinuation) ||
-           current_frame_header.stream_id != incoming_header_stream_id))) {
+
+  if (GPR_UNLIKELY(current_frame_header.type ==
+                       static_cast<uint8_t>(FrameType::kCustomSecurity) &&
+                   current_frame_header.length > max_security_frame_size)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(GrpcErrors::kSecurityFrameTooLarge,
+                     max_security_frame_size,
+                     ", Received size : ", current_frame_header.length));
+  }
+
+  // RFC 9113 (Section 6.10) requires that if a HEADERS frame does not have
+  // END_HEADERS set, it must be followed by a contiguous sequence of
+  // CONTINUATION frames for the same stream, ending with END_HEADERS. No other
+  // frame types or frames for other streams may be interleaved during this
+  // sequence.
+  const bool did_frame_violate_header_block_sequence =
+      (incoming_header_in_progress &&
+       (!is_continuation_frame ||
+        current_frame_header.stream_id != incoming_header_stream_id));
+  const bool did_receive_unexpected_continuation_frame =
+      (!incoming_header_in_progress && is_continuation_frame);
+  if (GPR_UNLIKELY(did_frame_violate_header_block_sequence ||
+                   did_receive_unexpected_continuation_frame)) {
     return Http2Status::Http2ConnectionError(
         Http2ErrorCode::kProtocolError,
         std::string(RFC9113::kAssemblerContiguousSequenceError));
@@ -868,13 +894,94 @@ Http2Status ValidateFrameHeader(const uint32_t max_frame_size_setting,
   // 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));
+  if (GPR_UNLIKELY(current_frame_header.stream_id > last_stream_id)) {
+    const bool is_metadata_frame =
+        current_frame_header.type == static_cast<uint8_t>(FrameType::kHeader) ||
+        is_continuation_frame;
+    if (GPR_UNLIKELY(is_client)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(RFC9113::kUnknownStreamId));
+    } else if (GPR_UNLIKELY(!is_metadata_frame)) {
+      // For servers, if the stream id is not known, it means the Headers have
+      // not been received for this stream yet. This means that the stream is
+      // still in idle state. A stream in idle state cannot receive any frames
+      // other than HEADERS or PRIORITY.
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          std::string(RFC9113::kIdleStreamError));
+    }
+  }
+
+  if (GPR_UNLIKELY(is_continuation_frame && current_frame_header.length == 0u &&
+                   (current_frame_header.flags & kFlagEndHeaders) == 0u)) {
+    tracker.noop_continuation_frames++;
+    if (GPR_UNLIKELY(tracker.noop_continuation_frames >=
+                     kMaxNoopContinuationFrames)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kTooManyZeroLengthContinuationFrames));
+    }
   }
+
+  if (GPR_UNLIKELY(is_data_frame && current_frame_header.length == 0u &&
+                   (current_frame_header.flags & kFlagEndStream) == 0u)) {
+    tracker.noop_data_frames++;
+    if (GPR_UNLIKELY(tracker.noop_data_frames >= kMaxNoopDataFrames)) {
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kTooManyZeroLengthDataFrames));
+    }
+  }
+
   // TODO(tjagtap) : [PH2][P2]:Consider validating MAX_CONCURRENT_STREAMS here
   // for server.
   return Http2Status::Ok();
 }
 }  // namespace grpc_core
+
+/*
+A note on Security Frames
+
+Security Frame is a custom frame defined by gRPC.
+
+SECURITY Frame
+
+   The SECURITY frame (type=200) is used to transmit out-of-band security and
+   transport-level privacy information between peers.
+
+   Both peers MUST agree to allow SECURITY frames.
+
+    +------------------------+
+    |     Payload Length     |
+    |          (24)          |
+    +--------+--------+------+
+    |  Type  | Flags  |
+    |  (200) |  (8)   |
+    +-+------+--------+---------------+
+    |R|       Stream Identifier       |
+    | |             (31)              |
+    +=+===============================+
+    |      Security Payload (*)     ...
+    +---------------------------------+
+
+   The SECURITY frame payload contains opaque data intended for the registered
+   transport framing endpoint extension.
+
+   The SECURITY frame does not define flags.
+
+Payload Size Limits and Chunking
+
+   The current implementation of the SECURITY frame has a HARD limit of 16,384
+   bytes (16 KB) for its payload.
+
+   This strict 16 KB limit is enforced because 16,384 bytes is the minimum
+   valid value for SETTINGS_MAX_FRAME_SIZE (the smallest maximum frame size an
+   HTTP/2 peer is allowed to advertise). Currently, the SECURITY frame does not
+   support chunking. Therefore, if a peer attempts to send a SECURITY payload
+   larger than the receiver's advertised SETTINGS_MAX_FRAME_SIZE, the endpoint
+   MUST treat this as a CONNECTION ERROR of type FRAME_SIZE_ERROR. By enforcing
+a hard 16 KB upper bound, we guarantee that the frame will safely fit within any
+compliant peer's single-frame receive buffer without requiring payload chunking.
+
+*/

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

@@ -269,18 +269,39 @@ http2::ValueOrHttp2Status<GrpcMessageHeader> ExtractGrpcHeader(
 void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, uint32_t flags,
                                    uint32_t length);
 
+///////////////////////////////////////////////////////////////////////////////
+// Frame limits
+
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
+struct Http2FrameCountTracker {
+  void OnLastContinuationFrame() { noop_continuation_frames = 0u; }
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "{ noop_continuation_frames : ", noop_continuation_frames,
+        ", noop_data_frames : ", noop_data_frames, "}");
+  }
+
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Validations
 
 http2::Http2Status ValidateSettingsValues(
     std::vector<Http2SettingsFrame::Setting>& list);
 
-http2::Http2Status ValidateFrameHeader(uint32_t max_frame_size_setting,
-                                       bool incoming_header_in_progress,
-                                       uint32_t incoming_header_stream_id,
-                                       Http2FrameHeader& current_frame_header,
-                                       uint32_t last_stream_id, bool is_client,
-                                       bool is_first_settings_processed);
+// The checks in this function MUST be done before the frame payload is read.
+http2::Http2Status ValidateFrameHeader(
+    const uint32_t max_frame_size_setting,
+    const bool incoming_header_in_progress,
+    const uint32_t incoming_header_stream_id,
+    const Http2FrameHeader& current_frame_header, const uint32_t last_stream_id,
+    const bool is_client, const bool is_first_settings_processed,
+    Http2FrameCountTracker& tracker, const uint32_t max_security_frame_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RFC9113 Related Strings and Consts
@@ -344,8 +365,7 @@ inline constexpr absl::string_view kPaddingLengthLargerThanFrameLength =
 // 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";
+    "setting of the peer endpoint is set to 0";
 
 inline constexpr absl::string_view kAssemblerContiguousSequenceError =
     "RFC9113 : Field blocks MUST be transmitted as a contiguous sequence "
@@ -389,6 +409,11 @@ inline constexpr absl::string_view kFirstSettingsFrameServer =
     "empty. Clients and servers MUST treat an invalid connection preface as a "
     "connection error of type PROTOCOL_ERROR.";
 
+inline constexpr absl::string_view kIdleStreamError =
+    "Stream Idle : Receiving any frame other than HEADERS or PRIORITY on a "
+    "stream in this state MUST be treated 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;
@@ -400,12 +425,34 @@ 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.";
+    "gRPC Transport Error : DATA frames must follow initial metadata and "
+    "precede trailing metadata.";
+inline constexpr absl::string_view kTooManyZeroLengthContinuationFrames =
+    "gRPC Transport Error : Received too many zero length CONTINUATION frames "
+    "without end_headers flag set";
+inline constexpr absl::string_view kTooManyZeroLengthDataFrames =
+    "gRPC Transport Error : Received too many zero length DATA frames";
+inline constexpr absl::string_view kUnsolicitedSettingsAck =
+    "gRPC Transport Error : Received unsolicited SETTINGS ACK.";
+inline constexpr absl::string_view kFailedToEnqueueStream =
+    "gRPC Transport Error : Failed to enqueue stream to writable stream list";
+inline constexpr absl::string_view kStreamCreationFailed =
+    "gRPC Transport Error : Stream creation failed";
+
+inline constexpr uint32_t kDefaultMaxPendingInducedFrames = 10000u;
+
+// Security frame related limits and errors
+inline constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+inline constexpr int kMinMaxSecurityFrameSize = 0;
+inline constexpr absl::string_view kSecurityFrameTooLarge =
+    "gRPC Transport Error : Security frame is larger than the maximum allowed "
+    "size : ";
+
 }  // namespace GrpcErrors
 
 }  // namespace grpc_core

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

@@ -115,13 +115,16 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
             << "CLIENT[" << t << "]: received ping " << p->opaque_8bytes;
       }
       if (t->ack_pings) {
+        grpc_error_handle error =
+            grpc_chttp2_increase_num_pending_induced_frames(t);
+        if (GPR_UNLIKELY(!error.ok())) return error;
+
         if (t->ping_ack_count == t->ping_ack_capacity) {
           t->ping_ack_capacity =
               std::max(t->ping_ack_capacity * 3 / 2, size_t{3});
           t->ping_acks = static_cast<uint64_t*>(gpr_realloc(
               t->ping_acks, t->ping_ack_capacity * sizeof(*t->ping_acks)));
         }
-        t->num_pending_induced_frames++;
         t->ping_acks[t->ping_ack_count++] = p->opaque_8bytes;
         grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_PING_RESPONSE);
       }

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

@@ -74,13 +74,18 @@ grpc_slice grpc_chttp2_rst_stream_create(
   return slice;
 }
 
-void grpc_chttp2_add_rst_stream_to_next_write(
+grpc_error_handle grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer) {
-  t->num_pending_induced_frames++;
+  grpc_error_handle error = grpc_chttp2_increase_num_pending_induced_frames(t);
+  if (GPR_UNLIKELY(!error.ok())) {
+    return error;
+  }
+
   grpc_slice_buffer_add(
       &t->qbuf, grpc_chttp2_rst_stream_create(id, code, call_tracer,
                                               &t->http2_ztrace_collector));
+  return absl::OkStatus();
 }
 
 grpc_error_handle grpc_chttp2_rst_stream_parser_begin_frame(
@@ -127,17 +132,18 @@ grpc_error_handle grpc_chttp2_rst_stream_parser_parse(void* parser,
     if (reason != static_cast<uint32_t>(Http2ErrorCode::kNoError) ||
         s->trailing_metadata_buffer.empty()) {
       error = grpc_error_set_int(
-          grpc_error_set_str(
-              GRPC_ERROR_CREATE("RST_STREAM"),
-              grpc_core::StatusStrProperty::kGrpcMessage,
-              absl::StrCat("Received RST_STREAM with error code ", reason)),
+          GRPC_ERROR_CREATE(absl::StrCat(
+              "RST_STREAM (Received RST_STREAM with error code ", reason, ")")),
           grpc_core::StatusIntProperty::kHttp2Error,
           static_cast<intptr_t>(reason));
     }
     grpc_core::SharedBitGen g;
     if (!t->is_client &&
         absl::Bernoulli(g, t->ping_on_rst_stream_percent / 100.0)) {
-      ++t->num_pending_induced_frames;
+      grpc_error_handle error =
+          grpc_chttp2_increase_num_pending_induced_frames(t);
+      if (GPR_UNLIKELY(!error.ok())) return error;
+
       t->ping_callbacks.RequestPing();
       grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_KEEPALIVE_PING);
     }

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

@@ -41,7 +41,7 @@ grpc_slice grpc_chttp2_rst_stream_create(
 // Adds RST_STREAM frame to t->qbuf (buffer for the next write). Should be
 // called when we want to add RST_STREAM and we are not in
 // write_action_begin_locked.
-void grpc_chttp2_add_rst_stream_to_next_write(
+grpc_error_handle grpc_chttp2_add_rst_stream_to_next_write(
     grpc_chttp2_transport* t, uint32_t id, uint32_t code,
     grpc_core::CallTracerInterface* call_tracer);
 

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

@@ -27,6 +27,7 @@
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
 #include "src/core/util/grpc_check.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
                                                      grpc_chttp2_transport* t,
@@ -52,7 +53,15 @@ absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
 }
 
 absl::Status grpc_chttp2_security_frame_parser_begin_frame(
-    grpc_chttp2_security_frame_parser* parser) {
+    grpc_chttp2_security_frame_parser* parser, const uint32_t length,
+    const uint32_t max_frame_size) {
+  if (GPR_UNLIKELY(length > max_frame_size &&
+                   grpc_core::IsCustomFrameCheckEnabled())) {
+    return GRPC_ERROR_CREATE(absl::StrCat(
+        "gRPC Transport Error : Security frame is larger than the maximum "
+        "allowed size : ",
+        max_frame_size, ", Received size : ", length));
+  }
   parser->payload.Clear();
   return absl::OkStatus();
 }

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

@@ -35,7 +35,8 @@ void grpc_chttp2_security_frame_create(grpc_slice_buffer* payload,
                                        grpc_slice_buffer* frame);
 
 absl::Status grpc_chttp2_security_frame_parser_begin_frame(
-    grpc_chttp2_security_frame_parser* parser);
+    grpc_chttp2_security_frame_parser* parser, uint32_t length,
+    uint32_t max_frame_size);
 
 grpc_error_handle grpc_chttp2_security_frame_parser_parse(
     void* parser, grpc_chttp2_transport* t, grpc_chttp2_stream* s,

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

@@ -136,7 +136,10 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
                 []() { return grpc_core::H2SettingsTrace<false>{true, {}}; });
             *parser->target_settings = *parser->incoming_settings;
             t->MaybeNotifyStateWatcherOfPeerMaxConcurrentStreamsLocked();
-            t->num_pending_induced_frames++;
+            grpc_error_handle error =
+                grpc_chttp2_increase_num_pending_induced_frames(t);
+            if (GPR_UNLIKELY(!error.ok())) return error;
+
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());
             grpc_chttp2_initiate_write(t,
                                        GRPC_CHTTP2_INITIATE_WRITE_SETTINGS_ACK);

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

@@ -32,6 +32,7 @@ GoawayManager::GoawayManager(std::unique_ptr<GoawayInterface> goaway_interface)
 std::optional<Http2Frame> GoawayManager::MaybeGetGoawayFrame() {
   switch (context_->goaway_state) {
     case GoawayState::kIdle:
+    case GoawayState::kInitialGracefulGoawaySent:
     case GoawayState::kDone:
       break;
     case GoawayState::kInitialGracefulGoawayScheduled: {
@@ -85,9 +86,16 @@ void GoawayManager::Context::SentGoawayTransition() {
                         << GoawayStateToString(goaway_state);
   switch (goaway_state) {
     case GoawayState::kIdle:
-    case GoawayState::kInitialGracefulGoawayScheduled:
+    case GoawayState::kInitialGracefulGoawaySent:
     case GoawayState::kDone:
       break;
+    case GoawayState::kInitialGracefulGoawayScheduled: {
+      GRPC_HTTP2_GOAWAY_LOG
+          << "Transitioning to kInitialGracefulGoawaySent from "
+          << GoawayStateToString(goaway_state);
+      goaway_state = GoawayState::kInitialGracefulGoawaySent;
+      break;
+    }
     case GoawayState::kFinalGracefulGoawayScheduled:
     case GoawayState::kImmediateGoawayRequested: {
       GRPC_HTTP2_GOAWAY_LOG << "Transitioning to kDone from "
@@ -109,6 +117,8 @@ std::string GoawayManager::Context::GoawayStateToString(
       return "kIdle";
     case GoawayState::kInitialGracefulGoawayScheduled:
       return "kInitialGracefulGoawayScheduled";
+    case GoawayState::kInitialGracefulGoawaySent:
+      return "kInitialGracefulGoawaySent";
     case GoawayState::kFinalGracefulGoawayScheduled:
       return "kFinalGracefulGoawayScheduled";
     case GoawayState::kImmediateGoawayRequested:

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

@@ -64,6 +64,8 @@ enum class GoawayState : uint8_t {
   // Initial graceful GOAWAY is scheduled to be sent in the next transport write
   // cycle.
   kInitialGracefulGoawayScheduled,
+  // Initial graceful GOAWAY has been written on the wire.
+  kInitialGracefulGoawaySent,
   // Final graceful GOAWAY is scheduled to be sent in the next transport write
   // cycle. Sending this GOAWAY frame completes the graceful GOAWAY process and
   // transitions the state to kDone.
@@ -161,6 +163,7 @@ class GoawayManager {
     absl::Status TriggerWriteCycle();
 
     GoawayState goaway_state = GoawayState::kIdle;
+    bool was_immediate = false;
     std::unique_ptr<GoawayInterface> goaway_interface;
     // TODO(akshitpatel) : [PH2][P4] : There is scope to make this
     // IntractivityWaker.
@@ -222,6 +225,7 @@ class GoawayManager {
                             << " -> "
                                "kImmediateGoawayRequested.";
 
+      ctx->was_immediate = true;
       ctx->goaway_state = GoawayState::kImmediateGoawayRequested;
       ctx->SetGoawayArgs(
           /*error_code=*/static_cast<uint32_t>(error_code),
@@ -275,6 +279,7 @@ class GoawayManager {
                                 << " -> "
                                    "kInitialGracefulGoawayScheduled.";
           GRPC_DCHECK(error_code == Http2ErrorCode::kNoError);
+          ctx->was_immediate = false;
           ctx->goaway_state = GoawayState::kInitialGracefulGoawayScheduled;
           ctx->SetGoawayArgs(
               /*error_code=*/static_cast<uint32_t>(Http2ErrorCode::kNoError),
@@ -290,7 +295,7 @@ class GoawayManager {
                               << "Ping resolved. Current state: "
                               << ctx->GoawayStateToString(ctx->goaway_state);
                           if (ctx->goaway_state ==
-                              GoawayState::kInitialGracefulGoawayScheduled) {
+                              GoawayState::kInitialGracefulGoawaySent) {
                             GRPC_HTTP2_GOAWAY_LOG
                                 << " [Graceful GOAWAY] state change "
                                 << ctx->GoawayStateToString(ctx->goaway_state)
@@ -349,6 +354,17 @@ class GoawayManager {
     return context_->goaway_state == GoawayState::kImmediateGoawayRequested;
   }
 
+  bool IsFinalGracefulGoawayScheduledOrSent() const {
+    return (context_->goaway_state ==
+            GoawayState::kFinalGracefulGoawayScheduled) ||
+           IsFinalGracefulGoawaySent();
+  }
+
+  bool IsFinalGracefulGoawaySent() const {
+    return context_->goaway_state == GoawayState::kDone &&
+           !context_->was_immediate;
+  }
+
   // Called from the transport write cycle to notify the GOAWAY manager that a
   // GOAWAY frame may have been sent. If a GOAWAY frame is sent in current
   // write cycle, this function handles the needed state transition.