grpc 1.81.1 → 1.83.1

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

@@ -72,6 +72,7 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/context_list_entry.h"
 #include "src/core/telemetry/stats.h"
@@ -94,6 +95,9 @@
 //   bits being used for flags defined above)
 #define CLOSURE_BARRIER_FIRST_REF_BIT (1 << 16)
 
+constexpr uint32_t kMaxSecurityFrameSize = 16u * 1024u;
+constexpr int kMinMaxSecurityFrameSize = 0;
+
 // streams are kept in various linked lists depending on what things need to
 // happen to them... this enum labels each list
 typedef enum {
@@ -230,6 +234,9 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
 struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                                      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
@@ -458,6 +465,7 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   /// parser for goaway frames
   grpc_chttp2_goaway_parser goaway_parser;
   // parser for secure frames
+  uint32_t max_security_frame_size;
   grpc_chttp2_security_frame_parser security_frame_parser;
 
   grpc_core::chttp2::TransportFlowControl flow_control;
@@ -472,6 +480,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint8_t incoming_frame_flags = 0;
   uint8_t header_eof = 0;
   bool is_first_frame = true;
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
   uint32_t expect_continuation_stream_id = 0;
   uint32_t incoming_frame_size = 0;
 
@@ -618,6 +628,11 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
+
+  std::optional<uint32_t> max_recv_message_length;
+
+  // Current mitigation engine, retrieved once per connection.
+  grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
 
 typedef enum {
@@ -705,6 +720,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch trailing_metadata_buffer;
 
   grpc_slice_buffer frame_storage;  // protected by t combiner
+  size_t num_frames = 0;            // protected by t combiner
 
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
@@ -764,6 +780,9 @@ struct grpc_chttp2_stream {
   // The last time a stream window update was received.
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
+
+  bool message_size_limit_exceeded = false;
+  std::optional<uint32_t> max_recv_message_length;
 };
 
 /// Transport writing call flow:
@@ -878,6 +897,11 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s);
 #endif
 
 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id);
+grpc_error_handle grpc_chttp2_increase_num_pending_induced_frames(
+    grpc_chttp2_transport* t);
+
+void grpc_chttp2_close_transport_locked(grpc_chttp2_transport* t,
+                                        grpc_error_handle error);
 
 /// Sends GOAWAY with error code ENHANCE_YOUR_CALM and additional debug data
 /// resembling "too_many_pings" followed by immediately closing the connection.

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

@@ -39,7 +39,7 @@ namespace http2 {
 
 #define GRPC_MESSAGE_ASSEMBLER_DEBUG VLOG(2)
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // assembler and disassembler code
 
 constexpr uint32_t kOneGb = (1024u * 1024u * 1024u);
@@ -81,7 +81,6 @@ class GrpcMessageAssembler {
   ValueOrHttp2Status<MessageHandle> ExtractMessage() {
     const size_t current_len = message_buffer_.Length();
     if (current_len < kGrpcHeaderSizeInBytes) {
-      // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
     ValueOrHttp2Status<GrpcMessageHeader> header =

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

@@ -24,6 +24,7 @@
 #include <string.h>
 
 #include <atomic>
+#include <cstdint>
 #include <initializer_list>
 #include <limits>
 #include <memory>
@@ -61,6 +62,7 @@
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
@@ -428,6 +430,14 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
         t->incoming_frame_type));
   }
   t->is_first_frame = false;
+
+  if (grpc_core::IsPh2Perf01Enabled() &&
+      t->incoming_frame_size > t->settings.acked().max_frame_size()) {
+    return GRPC_ERROR_CREATE(absl::StrFormat(
+        "Frame size %d is larger than max frame size %d",
+        t->incoming_frame_size, t->settings.acked().max_frame_size()));
+  }
+
   if (t->expect_continuation_stream_id != 0) {
     if (t->incoming_frame_type != GRPC_CHTTP2_FRAME_CONTINUATION) {
       return GRPC_ERROR_CREATE(
@@ -440,6 +450,22 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
           "grpc_chttp2_stream %08x",
           t->expect_continuation_stream_id, t->incoming_stream_id));
     }
+    if (GPR_UNLIKELY(grpc_core::IsOptimization02Enabled() &&
+                     t->incoming_frame_size == 0u &&
+                     (t->incoming_frame_flags &
+                      GRPC_CHTTP2_DATA_FLAG_END_HEADERS) == 0u)) {
+      t->noop_continuation_frames++;
+      if (GPR_UNLIKELY(t->noop_continuation_frames >=
+                       kMaxNoopContinuationFrames)) {
+        return grpc_error_set_int(
+            GRPC_ERROR_CREATE(
+                "Too many zero length continuation frames without "
+                "end_headers flag set"),
+            grpc_core::StatusIntProperty::kHttp2Error,
+            static_cast<intptr_t>(Http2ErrorCode::kInternalError));
+      }
+    }
+
     return init_header_frame_parser(t, 1, requests_started);
   }
   switch (t->incoming_frame_type) {
@@ -517,7 +543,8 @@ static grpc_error_handle init_header_skip_frame_parser(
       /*metadata_size_hard_limit=*/
       t->settings.acked().max_header_list_size(),
       hpack_boundary_type(t, is_eoh), priority_type,
-      hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow));
+      hpack_parser_log_info(t, HPackParser::LogInfo::kDontKnow),
+      t->mitigation_engine.get());
   return absl::OkStatus();
 }
 
@@ -556,20 +583,32 @@ static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
   }
   grpc_chttp2_stream* s =
       grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
-  absl::Status status;
-  grpc_core::chttp2::FlowControlAction action;
-  if (s == nullptr) {
-    grpc_core::chttp2::TransportFlowControl::IncomingUpdateContext upd(
-        &t->flow_control);
-    status = upd.RecvData(t->incoming_frame_size);
-    action = upd.MakeAction();
-  } else {
-    grpc_core::chttp2::StreamFlowControl::IncomingUpdateContext upd(
-        &s->flow_control);
-    status = upd.RecvData(t->incoming_frame_size);
-    action = upd.MakeAction();
+  absl::Status status = absl::OkStatus();
+  if (!grpc_core::IsOptimization01Enabled() || t->incoming_frame_size > 0u) {
+    // Received data frame with size 0 can happen when the peer wants to send an
+    // END_STREAM. It is a legitimate data frame.
+    grpc_core::chttp2::FlowControlAction action;
+    if (s == nullptr) {
+      grpc_core::chttp2::TransportFlowControl::IncomingUpdateContext upd(
+          &t->flow_control);
+      status = upd.RecvData(t->incoming_frame_size);
+      action = upd.MakeAction();
+    } else {
+      grpc_core::chttp2::StreamFlowControl::IncomingUpdateContext upd(
+          &s->flow_control);
+      status = upd.RecvData(t->incoming_frame_size);
+      action = upd.MakeAction();
+    }
+    grpc_chttp2_act_on_flowctl_action(action, t, s);
+  } else if (grpc_core::IsOptimization02Enabled() &&
+             t->incoming_frame_size == 0u &&
+             (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_STREAM) ==
+                 0u) {
+    t->noop_data_frames++;
+    if (t->noop_data_frames >= kMaxNoopDataFrames) {
+      return GRPC_ERROR_CREATE("Too many zero length data frames");
+    }
   }
-  grpc_chttp2_act_on_flowctl_action(action, t, s);
   if (!status.ok()) {
     goto error_handler;
   }
@@ -594,10 +633,11 @@ error_handler:
     // handle stream errors by closing the stream
     grpc_chttp2_mark_stream_closed(t, s, true, false,
                                    absl_status_to_grpc_error(status));
-    grpc_chttp2_add_rst_stream_to_next_write(
+    grpc_error_handle rst_error = grpc_chttp2_add_rst_stream_to_next_write(
         t, t->incoming_stream_id,
         static_cast<uint32_t>(Http2ErrorCode::kProtocolError),
         &s->call_tracer_wrapper);
+    if (GPR_UNLIKELY(!rst_error.ok())) return rst_error;
     return init_non_header_skip_frame_parser(t);
   } else {
     return absl_status_to_grpc_error(status);
@@ -615,6 +655,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
 
   if (is_eoh) {
     t->expect_continuation_stream_id = 0;
+    t->noop_continuation_frames = 0;
   } else {
     t->expect_continuation_stream_id = t->incoming_stream_id;
   }
@@ -663,7 +704,10 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(t->stream_map.size() + t->extra_streams >=
                             t->settings.acked().max_concurrent_streams())) {
-      ++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(
                         t->incoming_stream_id,
@@ -677,7 +721,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       // by refusing this stream.
       t->memory_owner.telemetry_storage()->Increment(
           grpc_core::ResourceQuotaDomain::kCallsRejected);
-      ++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(
                         t->incoming_stream_id,
@@ -694,7 +742,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                t->max_deallocating_streams))) {
       // We have more streams allocated than we'd like, so apply some pushback
       // by refusing this stream.
-      ++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(
                         t->incoming_stream_id,
@@ -711,7 +763,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
       // We are under the limit of max concurrent streams for the current
       // setting, but are over the next value that will be advertised.
       // Apply some backpressure by randomly not accepting new streams.
-      ++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(
                         t->incoming_stream_id,
@@ -738,7 +794,11 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           << " rejecting grpc_chttp2_stream id=" << t->incoming_stream_id
           << ", last grpc_chttp2_stream id=" << t->last_new_stream_id
           << " before settings have been acknowledged";
-      ++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(
                         t->incoming_stream_id,
@@ -834,7 +894,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                              /*metadata_size_hard_limit=*/
                              t->settings.acked().max_header_list_size(),
                              hpack_boundary_type(t, is_eoh), priority_type,
-                             hpack_parser_log_info(t, frame_type));
+                             hpack_parser_log_info(t, frame_type),
+                             t->mitigation_engine.get());
   return absl::OkStatus();
 }
 
@@ -931,8 +992,9 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
 }
 
 static grpc_error_handle init_security_frame_parser(grpc_chttp2_transport* t) {
-  grpc_error_handle err =
-      grpc_chttp2_security_frame_parser_begin_frame(&t->security_frame_parser);
+  grpc_error_handle err = grpc_chttp2_security_frame_parser_begin_frame(
+      &t->security_frame_parser, t->incoming_frame_size,
+      t->max_security_frame_size);
   if (!err.ok()) return err;
   t->parser = grpc_chttp2_transport::Parser{
       "security_frame", grpc_chttp2_security_frame_parser_parse,
@@ -977,11 +1039,16 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
   grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(sp);
   grpc_chttp2_transport* t = s->t.get();
   if (!s->write_closed) {
-    grpc_chttp2_add_rst_stream_to_next_write(
+    grpc_error_handle rst_error = grpc_chttp2_add_rst_stream_to_next_write(
         t, s->id, static_cast<uint32_t>(Http2ErrorCode::kNoError),
         &s->call_tracer_wrapper);
-    grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
-    grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
+    if (GPR_UNLIKELY(!rst_error.ok())) {
+      grpc_chttp2_close_transport_locked(t, rst_error);
+    } else {
+      grpc_chttp2_initiate_write(t,
+                                 GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
+      grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
+    }
   }
   GRPC_CHTTP2_STREAM_UNREF(s, "final_rst");
 }

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

@@ -115,7 +115,7 @@ std::optional<Duration> PingManager::MaybeGetSerializedPingFrames(
                       << " next_allowed_ping_interval: "
                       << next_allowed_ping_interval;
   GRPC_DCHECK(!opaque_data_.has_value());
-  frame_sender.ReserveRegularFrames(pending_ping_acks_.size() + 1);
+  frame_sender.ReserveRegularFrames(pending_ping_acks_.size());
 
   // Get the serialized ping acks if needed.
   for (uint64_t opaque_data : pending_ping_acks_) {

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

@@ -58,17 +58,11 @@ void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
 Chttp2PingRatePolicy::RequestSendPingResult
 Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
                                       size_t inflight_pings) const {
-  if (max_inflight_pings_ > 0) {
-    if (!IsMaxInflightPingsStrictLimitEnabled()) {
-      if (inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
-        return TooManyRecentPings{};
-      }
-    } else {
-      if (inflight_pings >= static_cast<size_t>(max_inflight_pings_)) {
-        return TooManyRecentPings{};
-      }
-    }
+  if (max_inflight_pings_ > 0 &&
+      inflight_pings >= static_cast<size_t>(max_inflight_pings_)) {
+    return TooManyRecentPings{};
   }
+
   const Timestamp next_allowed_ping =
       last_ping_sent_time_ + next_allowed_ping_interval;
   const Timestamp now = Timestamp::Now();