grpc 1.73.0 → 1.75.0

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

@@ -34,6 +34,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/util/useful.h"

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

@@ -32,7 +32,9 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/transport/bdp_estimator.h"
@@ -271,6 +273,11 @@ class TransportFlowControl final {
 
   FlowControlAction SetAckedInitialWindow(uint32_t value);
 
+  void set_target_initial_window_size(uint32_t value) {
+    target_initial_window_size_ =
+        std::min(value, Http2Settings::max_initial_window_size());
+  }
+
   // Getters
   int64_t remote_window() const { return remote_window_; }
   int64_t announced_window() const { return announced_window_; }
@@ -302,23 +309,22 @@ class TransportFlowControl final {
     double bdp_bw_est;
 
     std::string ToString() const;
-    Json::Object ToJsonObject() {
-      Json::Object object;
-      object["targetWindow"] = Json::FromNumber(target_window);
-      object["targetFrameSize"] = Json::FromNumber(target_frame_size);
-      object["targetPreferredRxCryptoFrameSize"] =
-          Json::FromNumber(target_preferred_rx_crypto_frame_size);
-      object["ackedInitWindow"] = Json::FromNumber(acked_init_window);
-      object["queuedInitWindow"] = Json::FromNumber(queued_init_window);
-      object["sentInitWindow"] = Json::FromNumber(sent_init_window);
-      object["remoteWindow"] = Json::FromNumber(remote_window);
-      object["announcedWindow"] = Json::FromNumber(announced_window);
-      object["announcedStreamTotalOverIncomingWindow"] =
-          Json::FromNumber(announced_stream_total_over_incoming_window);
-      object["bdpAccumulator"] = Json::FromNumber(bdp_accumulator);
-      object["bdpEstimate"] = Json::FromNumber(bdp_estimate);
-      object["bdpBwEst"] = Json::FromNumber(bdp_bw_est);
-      return object;
+    channelz::PropertyList ChannelzProperties() const {
+      return channelz::PropertyList()
+          .Set("target_window", target_window)
+          .Set("target_frame_size", target_frame_size)
+          .Set("target_preferred_rx_crypto_frame_size",
+               target_preferred_rx_crypto_frame_size)
+          .Set("acked_init_window", acked_init_window)
+          .Set("queued_init_window", queued_init_window)
+          .Set("sent_init_window", sent_init_window)
+          .Set("remote_window", remote_window)
+          .Set("announced_window", announced_window)
+          .Set("announced_stream_total_over_incoming_window",
+               announced_stream_total_over_incoming_window)
+          .Set("bdp_accumulator", bdp_accumulator)
+          .Set("bdp_estimate", bdp_estimate)
+          .Set("bdp_bw_est", bdp_bw_est);
     }
   };
 

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

@@ -24,20 +24,69 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/crash.h"
 
+// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// framing code
+
 using grpc_core::http2::Http2ErrorCode;
 using grpc_core::http2::Http2Status;
 using grpc_core::http2::ValueOrHttp2Status;
 
 namespace grpc_core {
 
+///////////////////////////////////////////////////////////////////////////////
+// Settings Frame Validations
+
+bool IsUnknownSetting(const uint16_t setting_id) {
+  // RFC9113 : An endpoint that receives a SETTINGS frame with any unknown
+  // or unsupported identifier MUST ignore that setting.
+  return setting_id < Http2Settings::kHeaderTableSizeWireId ||
+         setting_id > Http2Settings::kGrpcAllowSecurityFrameWireId ||
+         (setting_id > Http2Settings::kMaxHeaderListSizeWireId &&
+          setting_id < Http2Settings::kGrpcAllowTrueBinaryMetadataWireId);
+}
+
+Http2Status ValidateSettingsValues(
+    std::vector<Http2SettingsFrame::Setting>& list) {
+  for (const auto& setting : list) {
+    if (GPR_UNLIKELY(setting.id == Http2Settings::kInitialWindowSizeWireId &&
+                     setting.value > RFC9113::kMaxSize31Bit)) {
+      LOG(ERROR)
+          << "ValidateSettingsValues Invalid "
+             "Setting:{setting.id:kInitialWindowSizeWireId, setting.value: "
+          << setting.value << "}";
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kFlowControlError,
+          absl::StrCat(RFC9113::kIncorrectWindowSizeSetting,
+                       "Invalid Setting:{setting.id:kInitialWindowSizeWireId, "
+                       "setting.value: ",
+                       setting.value));
+    } else if (GPR_UNLIKELY(setting.id == Http2Settings::kMaxFrameSizeWireId &&
+                            (setting.value < RFC9113::kMinimumFrameSize ||
+                             setting.value > RFC9113::kMaximumFrameSize))) {
+      LOG(ERROR) << "ValidateSettingsValues Invalid "
+                    "Setting:{setting.id:kMaxFrameSizeWireId, setting.value: "
+                 << setting.value << "}";
+      return Http2Status::Http2ConnectionError(
+          Http2ErrorCode::kProtocolError,
+          absl::StrCat(RFC9113::kIncorrectFrameSizeSetting,
+                       "Invalid Setting:{setting.id:kMaxFrameSizeWireId, "
+                       "setting.value: ",
+                       setting.value));
+    }
+  }
+  DVLOG(2) << "Http2Transport ValidateSettingsValues Valid";
+  return Http2Status::Ok();
+}
+
 namespace {
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
-// framing code
+///////////////////////////////////////////////////////////////////////////////
+// HTTP2 Framing Code
 
 // HTTP2 Frame Types
 enum class FrameType : uint8_t {
@@ -431,7 +480,8 @@ ValueOrHttp2Status<Http2Frame> ParseSettingsFrame(const Http2FrameHeader& hdr,
           Http2ErrorCode::kFrameSizeError,
           absl::StrCat(RFC9113::kSettingsLength0, hdr.ToString()));
     }
-    return ValueOrHttp2Status<Http2Frame>(Http2SettingsFrame{true, {}});
+    return ValueOrHttp2Status<Http2Frame>(
+        Http2SettingsFrame{/*ack=*/true, /*settings=*/{}});
   }
 
   if (GPR_UNLIKELY(payload.Length() % 6 != 0)) {
@@ -440,13 +490,18 @@ ValueOrHttp2Status<Http2Frame> ParseSettingsFrame(const Http2FrameHeader& hdr,
         absl::StrCat(RFC9113::kSettingsLength6x, hdr.ToString()));
   }
 
-  Http2SettingsFrame frame{false, {}};
+  Http2SettingsFrame frame{/*ack=*/false, /*settings=*/{}};
   while (payload.Length() != 0) {
     uint8_t buffer[6];
     payload.MoveFirstNBytesIntoBuffer(6, buffer);
+    uint16_t setting_id = Read2b(buffer);
+    uint32_t setting_value = Read4b(buffer + 2);
+    if (GPR_UNLIKELY(IsUnknownSetting(setting_id))) {
+      continue;
+    }
     frame.settings.push_back({
-        Read2b(buffer),
-        Read4b(buffer + 2),
+        setting_id,
+        setting_value,
     });
   }
   return ValueOrHttp2Status<Http2Frame>(std::move(frame));
@@ -578,6 +633,7 @@ std::string Http2FrameTypeString(FrameType frame_type) {
   }
   return absl::StrCat("UNKNOWN(", static_cast<uint8_t>(frame_type), ")");
 }
+
 }  // namespace
 
 std::string Http2FrameHeader::ToString() const {
@@ -632,6 +688,19 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
   }
 }
 
+http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code) {
+  if (GPR_UNLIKELY(error_code > http2::GetMaxHttp2ErrorCode())) {
+    LOG(ERROR) << "Http2ErrorCodeFromRstFrameErrorCode: Invalid error code "
+                  "received from RST_STREAM frame: "
+               << error_code;
+    return http2::Http2ErrorCode::kInternalError;
+  }
+  return static_cast<http2::Http2ErrorCode>(error_code);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GRPC Header
+
 GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload) {
   CHECK_GE(payload.Length(), kGrpcHeaderSizeInBytes);
   uint8_t buffer[kGrpcHeaderSizeInBytes];
@@ -649,4 +718,28 @@ void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
   Write4b(length, frame_hdr + 1);
 }
 
+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) {
+  if (GPR_UNLIKELY(current_frame_header.length > max_frame_size_setting)) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kFrameSizeError,
+        absl::StrCat(RFC9113::kFrameSizeLargerThanMaxFrameSizeSetting,
+                     ", 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))) {
+    return Http2Status::Http2ConnectionError(
+        Http2ErrorCode::kProtocolError,
+        std::string(RFC9113::kAssemblerContiguousSequenceError));
+  }
+  // TODO(tjagtap) : [PH2][P2]:Consider validating MAX_CONCURRENT_STREAMS here
+  return Http2Status::Ok();
+}
+
 }  // namespace grpc_core

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_settings.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"
@@ -237,6 +238,8 @@ http2::ValueOrHttp2Status<Http2Frame> ParseFramePayload(
 // move things out of frames)
 void Serialize(absl::Span<Http2Frame> frames, SliceBuffer& out);
 
+http2::Http2ErrorCode Http2ErrorCodeFromRstFrameErrorCode(uint32_t error_code);
+
 ///////////////////////////////////////////////////////////////////////////////
 // GRPC Header
 
@@ -255,6 +258,20 @@ GrpcMessageHeader ExtractGrpcHeader(SliceBuffer& payload);
 void AppendGrpcHeaderToSliceBuffer(SliceBuffer& payload, const uint8_t flags,
                                    const uint32_t length);
 
+///////////////////////////////////////////////////////////////////////////////
+// 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);
+
+///////////////////////////////////////////////////////////////////////////////
+// RFC9113 Related Strings and Consts
+
 namespace RFC9113 {
 // RFC9113: 5.1.1.
 inline constexpr absl::string_view kStreamIdMustBeOdd =
@@ -314,6 +331,18 @@ inline constexpr absl::string_view kNoPushPromise =
     "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 "
+    "of frames, with no interleaved frames of any other type or from any "
+    "other stream.";
+inline constexpr absl::string_view kHalfClosedRemoteState =
+    "RFC9113: half-closed (remote): If an endpoint receives additional frames, "
+    "other than WINDOW_UPDATE, PRIORITY, or RST_STREAM, for a stream that is "
+    "in this state, it MUST respond with a stream error of type STREAM_CLOSED.";
+inline constexpr absl::string_view kFrameSizeLargerThanMaxFrameSizeSetting =
+    "RFC9113: An endpoint MUST send an error code of FRAME_SIZE_ERROR if a "
+    "frame exceeds the size defined in SETTINGS_MAX_FRAME_SIZE";
+
 inline constexpr absl::string_view kFrameParserIncorrectPadding =
     "Incorrect length of padding in frame";
 inline constexpr absl::string_view kIncorrectFrame = "Incorrect Frame";
@@ -321,9 +350,18 @@ 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 absl::string_view kIncorrectWindowSizeSetting =
+    "RFC9113: Values above the maximum flow-control window size of (2^31)-1 "
+    "MUST be treated as a connection error of type FLOW_CONTROL_ERROR.";
+inline constexpr absl::string_view kIncorrectFrameSizeSetting =
+    "RFC9113: The initial value is 2^14 (16,384) octets. The value advertised"
+    " by an endpoint MUST be between this initial value and the maximum allowed"
+    " frame size (2^24)-1 or 16,777,215 octets), inclusive. ";
+
 inline constexpr uint32_t kMaxStreamId31Bit = 0x7fffffffu;
+inline constexpr uint32_t kMaxSize31Bit = 0x7fffffffu;
+inline constexpr uint32_t kMinimumFrameSize = 16384;
+inline constexpr uint32_t kMaximumFrameSize = 16777215;
 
 }  // namespace RFC9113
 }  // namespace grpc_core

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

@@ -80,7 +80,7 @@ void grpc_chttp2_encode_data(uint32_t id, grpc_slice_buffer* inbuf,
 
   grpc_slice_buffer_move_first_no_ref(inbuf, write_bytes, outbuf);
 
-  grpc_core::global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
+  grpc_core::http2_global_stats().IncrementHttp2WriteDataFrameSize(write_bytes);
   call_tracer->RecordOutgoingBytes({header_size, 0, 0});
 }
 

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

@@ -108,19 +108,18 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
           if (is_last) {
             grpc_core::Http2Settings* target_settings =
                 parser->incoming_settings.get();
-            grpc_core::global_stats().IncrementHttp2HeaderTableSize(
+            t->http2_stats->IncrementHttp2HeaderTableSize(
                 target_settings->header_table_size());
-            grpc_core::global_stats().IncrementHttp2InitialWindowSize(
+            t->http2_stats->IncrementHttp2InitialWindowSize(
                 target_settings->initial_window_size());
-            grpc_core::global_stats().IncrementHttp2MaxConcurrentStreams(
+            t->http2_stats->IncrementHttp2MaxConcurrentStreams(
                 target_settings->max_concurrent_streams());
-            grpc_core::global_stats().IncrementHttp2MaxFrameSize(
+            t->http2_stats->IncrementHttp2MaxFrameSize(
                 target_settings->max_frame_size());
-            grpc_core::global_stats().IncrementHttp2MaxHeaderListSize(
+            t->http2_stats->IncrementHttp2MaxHeaderListSize(
                 target_settings->max_header_list_size());
-            grpc_core::global_stats()
-                .IncrementHttp2PreferredReceiveCryptoMessageSize(
-                    target_settings->preferred_receive_crypto_message_size());
+            t->http2_stats->IncrementHttp2PreferredReceiveCryptoMessageSize(
+                target_settings->preferred_receive_crypto_message_size());
             t->http2_ztrace_collector.Append([parser]() {
               grpc_core::H2SettingsTrace<true> settings{false, {}};
               // TODO(ctiller): produce actual wire settings here, not a

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

@@ -109,15 +109,14 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
       if (s != nullptr) {
         grpc_core::Timestamp now = grpc_core::Timestamp::Now();
         if (s->last_window_update_time != grpc_core::Timestamp::InfPast()) {
-          grpc_core::global_stats().IncrementHttp2StreamWindowUpdatePeriod(
+          t->http2_stats->IncrementHttp2StreamWindowUpdatePeriod(
               (now - s->last_window_update_time).millis());
         }
         s->last_window_update_time = now;
         grpc_core::chttp2::StreamFlowControl::OutgoingUpdateContext(
             &s->flow_control)
             .RecvUpdate(received_update);
-        grpc_core::global_stats().IncrementHttp2StreamRemoteWindowUpdate(
-            received_update);
+        t->http2_stats->IncrementHttp2StreamRemoteWindowUpdate(received_update);
         if (grpc_chttp2_list_remove_stalled_by_stream(t, s)) {
           grpc_chttp2_mark_stream_writable(t, s);
           grpc_chttp2_initiate_write(
@@ -129,11 +128,11 @@ grpc_error_handle grpc_chttp2_window_update_parser_parse(
           &t->flow_control);
       grpc_core::Timestamp now = grpc_core::Timestamp::Now();
       if (t->last_window_update_time != grpc_core::Timestamp::InfPast()) {
-        grpc_core::global_stats().IncrementHttp2TransportWindowUpdatePeriod(
+        t->http2_stats->IncrementHttp2TransportWindowUpdatePeriod(
             (now - t->last_window_update_time).millis());
       }
       t->last_window_update_time = now;
-      grpc_core::global_stats().IncrementHttp2TransportRemoteWindowUpdate(
+      t->http2_stats->IncrementHttp2TransportRemoteWindowUpdate(
           received_update);
       upd.RecvUpdate(received_update);
       if (upd.Finish() == grpc_core::chttp2::StallEdge::kUnstalled) {