grpc 1.82.0 → 1.83.0.pre1

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

@@ -294,13 +294,14 @@ struct Http2FrameCountTracker {
 http2::Http2Status ValidateSettingsValues(
     std::vector<Http2SettingsFrame::Setting>& list);
 
+// 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);
+    Http2FrameCountTracker& tracker, const uint32_t max_security_frame_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 // RFC9113 Related Strings and Consts
@@ -424,6 +425,7 @@ 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.";
@@ -441,6 +443,16 @@ 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_rst_stream.cc

@@ -132,10 +132,8 @@ 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));
     }

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/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.

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

@@ -996,6 +996,15 @@ class HPackParser::Parser {
       }
     }
     auto value_slice = value.value.Take();
+    if (IsOptimization05Enabled() && !state_.is_binary_header &&
+        state_.field_error.ok()) {
+      auto r =
+          ValidateNonBinaryHeaderValueIsLegal(value_slice.as_string_view());
+      if (r != ValidateMetadataResult::kOk) {
+        input_->SetErrorAndContinueParsing(
+            HpackParseResult::InvalidMetadataError(r, key_string));
+      }
+    }
     const auto transport_size =
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     if (state_.mitigation_engine != nullptr) {