grpc 1.68.1 → 1.69.0.pre1

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -42,6 +42,7 @@
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/handshaker/handshaker_registry.h"
@@ -49,7 +50,6 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_args_preconditioning.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/iomgr/endpoint.h"
@@ -248,8 +248,7 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
       ChannelArgs args) {
     auto* channel_credentials = args.GetObject<grpc_channel_credentials>();
     if (channel_credentials == nullptr) {
-      return absl::InternalError(
-          "channel credentials missing for secure channel");
+      return absl::InternalError("channel credentials missing for channel");
     }
     // Make sure security connector does not already exist in args.
     if (args.Contains(GRPC_ARG_SECURITY_CONNECTOR)) {
@@ -269,8 +268,7 @@ class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
                 /*call_creds=*/nullptr, authority->c_str(), &args);
     if (subchannel_security_connector == nullptr) {
       return absl::InternalError(absl::StrFormat(
-          "Failed to create secure subchannel for secure name '%s'",
-          *authority));
+          "Failed to create subchannel for secure name '%s'", *authority));
     }
     return args.SetObject(std::move(subchannel_security_connector));
   }
@@ -299,7 +297,7 @@ void FactoryInit() {
 
 }  // namespace
 
-// Create a secure client channel:
+// Create a client channel:
 //   Asynchronously: - resolve target
 //                   - connect to it (trying alternatives as presented)
 //                   - perform handshakes
@@ -308,8 +306,8 @@ grpc_channel* grpc_channel_create(const char* target,
                                   const grpc_channel_args* c_args) {
   grpc_core::ExecCtx exec_ctx;
   GRPC_TRACE_LOG(api, INFO)
-      << "grpc_secure_channel_create(target=" << target
-      << ", creds=" << (void*)creds << ", args=" << (void*)c_args << ")";
+      << "grpc_channel_create(target=" << target << ", creds=" << (void*)creds
+      << ", args=" << (void*)c_args << ")";
   grpc_channel* channel = nullptr;
   grpc_error_handle error;
   if (creds != nullptr) {
@@ -338,7 +336,7 @@ grpc_channel* grpc_channel_create(const char* target,
       status = static_cast<grpc_status_code>(integer);
     }
     channel = grpc_lame_client_channel_create(
-        target, status, "Failed to create secure client channel");
+        target, status, "Failed to create client channel");
   }
   return channel;
 }

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -47,6 +47,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
@@ -54,7 +55,6 @@
 #include "src/core/handshaker/handshaker_registry.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/event_engine/extensions/supports_fd.h"

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

@@ -96,7 +96,7 @@ size_t grpc_chttp2_base64_infer_length_after_decode(const grpc_slice& slice) {
                << " (without padding), which is invalid.\n";
     return 0;
   }
-  return tuples * 3 + tail_xtra[tail_case];
+  return (tuples * 3) + tail_xtra[tail_case];
 }
 
 bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
@@ -215,7 +215,8 @@ grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
                    input_length / 4 * 3 + tail_xtra[input_length % 4])) {
     LOG(ERROR) << "Base64 decoding failed, output_length " << output_length
                << " is longer than the max possible output length "
-               << (input_length / 4 * 3 + tail_xtra[input_length % 4]) << ".\n";
+               << ((input_length / 4 * 3) + tail_xtra[input_length % 4])
+               << ".\n";
     grpc_core::CSliceUnref(output);
     return grpc_empty_slice();
   }

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

@@ -51,7 +51,7 @@ grpc_slice grpc_chttp2_base64_encode(const grpc_slice& input) {
   size_t input_length = GRPC_SLICE_LENGTH(input);
   size_t input_triplets = input_length / 3;
   size_t tail_case = input_length % 3;
-  size_t output_length = input_triplets * 4 + tail_xtra[tail_case];
+  size_t output_length = (input_triplets * 4) + tail_xtra[tail_case];
   grpc_slice output = GRPC_SLICE_MALLOC(output_length);
   const uint8_t* in = GRPC_SLICE_START_PTR(input);
   char* out = reinterpret_cast<char*> GRPC_SLICE_START_PTR(output);
@@ -171,9 +171,9 @@ grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
   size_t input_length = GRPC_SLICE_LENGTH(input);
   size_t input_triplets = input_length / 3;
   size_t tail_case = input_length % 3;
-  size_t output_syms = input_triplets * 4 + tail_xtra[tail_case];
+  size_t output_syms = (input_triplets * 4) + tail_xtra[tail_case];
   size_t max_output_bits = 11 * output_syms;
-  size_t max_output_length = max_output_bits / 8 + (max_output_bits % 8 != 0);
+  size_t max_output_length = (max_output_bits / 8) + (max_output_bits % 8 != 0);
   grpc_slice output = GRPC_SLICE_MALLOC(max_output_length);
   const uint8_t* in = GRPC_SLICE_START_PTR(input);
   uint8_t* start_out = GRPC_SLICE_START_PTR(output);

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

@@ -32,6 +32,7 @@
 #include <algorithm>
 #include <atomic>
 #include <cstddef>
+#include <cstdint>
 #include <limits>
 #include <memory>
 #include <new>
@@ -54,12 +55,14 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
+#include "src/core/config/config_vars.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/frame_rst_stream.h"
+#include "src/core/ext/transport/chttp2/transport/frame_security.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
@@ -71,7 +74,6 @@
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/config/config_vars.h"
 #include "src/core/lib/event_engine/extensions/tcp_trace.h"
 #include "src/core/lib/event_engine/query_extensions.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -98,6 +100,7 @@
 #include "src/core/lib/transport/metadata_info.h"
 #include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
@@ -467,7 +470,7 @@ static void read_channel_args(grpc_chttp2_transport* t,
           .value_or(std::max(t->keepalive_timeout * 2,
                              grpc_core::Duration::Minutes(1)));
 
-  // Only send the prefered rx frame size http2 setting if we are instructed
+  // Only send the preferred rx frame size http2 setting if we are instructed
   // to auto size the buffers allocated at tcp level and we also can adjust
   // sending frame size.
   t->enable_preferred_rx_crypto_frame_advertisement =
@@ -548,6 +551,9 @@ static void read_channel_args(grpc_chttp2_transport* t,
     t->settings.mutable_local().SetPreferredReceiveCryptoMessageSize(INT_MAX);
   }
 
+  t->settings.mutable_local().SetAllowSecurityFrame(
+      channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
+
   t->ping_on_rst_stream_percent = grpc_core::Clamp(
       channel_args.GetInt(GRPC_ARG_HTTP2_PING_ON_RST_STREAM_PERCENT)
           .value_or(1),
@@ -556,6 +562,10 @@ static void read_channel_args(grpc_chttp2_transport* t,
   t->max_concurrent_streams_overload_protection =
       channel_args.GetBool(GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION)
           .value_or(true);
+
+  t->max_concurrent_streams_reject_on_client =
+      channel_args.GetBool(GRPC_ARG_MAX_CONCURRENT_STREAMS_REJECT_ON_CLIENT)
+          .value_or(false);
 }
 
 static void init_keepalive_pings_if_enabled_locked(
@@ -577,6 +587,35 @@ static void init_keepalive_pings_if_enabled_locked(
   }
 }
 
+// TODO(alishananda): add unit testing as part of chttp2 promise conversion work
+void grpc_chttp2_transport::WriteSecurityFrame(grpc_core::SliceBuffer* data) {
+  combiner->Run(grpc_core::NewClosure(
+                    [transport = Ref(), data](grpc_error_handle) mutable {
+                      transport->WriteSecurityFrameLocked(data);
+                    }),
+                absl::OkStatus());
+}
+
+void grpc_chttp2_transport::WriteSecurityFrameLocked(
+    grpc_core::SliceBuffer* data) {
+  if (data == nullptr) {
+    return;
+  }
+  if (!settings.peer().allow_security_frame()) {
+    close_transport_locked(
+        this,
+        grpc_error_set_int(
+            GRPC_ERROR_CREATE("Unexpected SECURITY frame scheduled for write"),
+            grpc_core::StatusIntProperty::kRpcStatus,
+            GRPC_STATUS_FAILED_PRECONDITION));
+  }
+  grpc_core::SliceBuffer security_frame;
+  grpc_chttp2_security_frame_create(data->c_slice_buffer(), data->Length(),
+                                    security_frame.c_slice_buffer());
+  grpc_slice_buffer_move_into(security_frame.c_slice_buffer(), &qbuf);
+  grpc_chttp2_initiate_write(this, GRPC_CHTTP2_INITIATE_WRITE_SEND_MESSAGE);
+}
+
 using grpc_event_engine::experimental::QueryExtension;
 using grpc_event_engine::experimental::TcpTraceExtension;
 
@@ -619,6 +658,17 @@ grpc_chttp2_transport::grpc_chttp2_transport(
     }
   }
 
+  if (channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false)) {
+    transport_framing_endpoint_extension = QueryExtension<
+        grpc_core::TransportFramingEndpointExtension>(
+        grpc_event_engine::experimental::grpc_get_wrapped_event_engine_endpoint(
+            ep.get()));
+    if (transport_framing_endpoint_extension != nullptr) {
+      transport_framing_endpoint_extension->SetSendFrameCallback(
+          [this](grpc_core::SliceBuffer* data) { WriteSecurityFrame(data); });
+    }
+  }
+
   CHECK(strlen(GRPC_CHTTP2_CLIENT_CONNECT_STRING) ==
         GRPC_CHTTP2_CLIENT_CONNECT_STRLEN);
 
@@ -1041,8 +1091,8 @@ static void write_action(grpc_chttp2_transport* t) {
     // to nullptr.
     cl = nullptr;
   }
-  // Choose max_frame_size as the prefered rx crypto frame size indicated by the
-  // peer.
+  // Choose max_frame_size as the preferred rx crypto frame size indicated by
+  // the peer.
   int max_frame_size =
       t->settings.peer().preferred_receive_crypto_message_size();
   // Note: max frame size is 0 if the remote peer does not support adjusting the
@@ -1381,8 +1431,24 @@ static void send_initial_metadata_locked(
     if (t->is_client) {
       if (t->closed_with_error.ok()) {
         CHECK_EQ(s->id, 0u);
-        grpc_chttp2_list_add_waiting_for_concurrency(t, s);
-        maybe_start_some_streams(t);
+        if (t->max_concurrent_streams_reject_on_client &&
+            t->stream_map.size() >=
+                t->settings.peer().max_concurrent_streams()) {
+          s->trailing_metadata_buffer.Set(
+              grpc_core::GrpcStreamNetworkState(),
+              grpc_core::GrpcStreamNetworkState::kNotSentOnWire);
+          grpc_chttp2_cancel_stream(
+              t, s,
+              grpc_error_set_int(
+                  GRPC_ERROR_CREATE_REFERENCING("Too many streams",
+                                                &t->closed_with_error, 1),
+                  grpc_core::StatusIntProperty::kRpcStatus,
+                  GRPC_STATUS_RESOURCE_EXHAUSTED),
+              false);
+        } else {
+          grpc_chttp2_list_add_waiting_for_concurrency(t, s);
+          maybe_start_some_streams(t);
+        }
       } else {
         s->trailing_metadata_buffer.Set(
             grpc_core::GrpcStreamNetworkState(),
@@ -1425,7 +1491,7 @@ static void send_message_locked(
       op->payload->send_message.send_message->Length());
   on_complete->next_data.scratch |= t->closure_barrier_may_cover_write;
   s->send_message_finished = add_closure_barrier(op->on_complete);
-  const uint32_t flags = op_payload->send_message.flags;
+  uint32_t flags = 0;
   if (s->write_closed) {
     op->payload->send_message.stream_write_closed = true;
     // We should NOT return an error here, so as to avoid a cancel OP being
@@ -1435,6 +1501,19 @@ static void send_message_locked(
                                       absl::OkStatus(),
                                       "fetching_send_message_finished");
   } else {
+    // Buffer hint is used to buffer the message in the transport until the
+    // write buffer size (specified through GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE) is
+    // reached. This is to batch writes sent down to tcp. However, if the memory
+    // pressure is high, disable the buffer hint to flush data down to tcp as
+    // soon as possible to avoid OOM.
+    if (grpc_core::IsDisableBufferHintOnHighMemoryPressureEnabled() &&
+        t->memory_owner.GetPressureInfo().pressure_control_value >= 0.8) {
+      // Disable write buffer hint if memory pressure is high. The value of 0.8
+      // is chosen to match the threshold used by the tcp endpoint (in
+      // allocating memory for socket reads).
+      op_payload->send_message.flags &= ~GRPC_WRITE_BUFFER_HINT;
+    }
+    flags = op_payload->send_message.flags;
     uint8_t* frame_hdr = grpc_slice_buffer_tiny_add(&s->flow_controlled_buffer,
                                                     GRPC_HEADER_SIZE_IN_BYTES);
     frame_hdr[0] = (flags & GRPC_WRITE_INTERNAL_COMPRESS) != 0;

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

@@ -87,7 +87,7 @@ class HuffDecoderCommon {
     return table1_emit_[i >> 6][emit];
   }
   static inline uint64_t GetOp13(size_t i) {
-    return table13_0_inner_[(i < 3 ? (i) : ((i - 3) / 12 + 3))];
+    return table13_0_inner_[(i < 3 ? (i) : (((i - 3) / 12) + 3))];
   }
   static inline uint64_t GetEmit13(size_t, size_t emit) {
     return (emit < 1 ? (((void)emit, 92)) : ((emit - 1) ? 208 : 195));
@@ -189,7 +189,7 @@ class HuffDecoderCommon {
   }
   static inline uint64_t GetEmit37(size_t, size_t emit) { return emit + 236; }
   static inline uint64_t GetOp36(size_t i) {
-    return table36_0_inner_[(i < 3 ? (i / 2 + 0) : ((i - 3) + 1))];
+    return table36_0_inner_[(i < 3 ? ((i / 2) + 0) : ((i - 3) + 1))];
   }
   static inline uint64_t GetEmit36(size_t, size_t emit) {
     return table36_0_emit_[emit];

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

@@ -182,7 +182,7 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
   // and a value t such that t_min <= t <= t_max, return the value on the line
   // segment at t.
   auto lerp = [](double t, double t_min, double t_max, double a, double b) {
-    return a + (b - a) * (t - t_min) / (t_max - t_min);
+    return a + ((b - a) * (t - t_min) / (t_max - t_min));
   };
   // We split memory pressure into three broad regions:
   // 1. Low memory pressure, the "anything goes" case - we assume no memory
@@ -295,7 +295,7 @@ FlowControlAction TransportFlowControl::PeriodicUpdate() {
       // Advertise PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to peer. By advertising
       // PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to the peer, we are informing the
       // peer that we have tcp frame size tuning enabled and we inform it of our
-      // prefered rx frame sizes. The prefered rx frame size is determined as:
+      // preferred rx frame sizes. The preferred rx frame size is determined as:
       // Clamp(target_frame_size_ * 2, 16384, 0x7fffffff). In the future, this
       // maybe updated to a different function of the memory pressure.
       UpdateSetting(

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

@@ -38,6 +38,7 @@ 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;
 
 constexpr uint8_t kFlagEndStream = 1;
 constexpr uint8_t kFlagAck = 1;
@@ -122,6 +123,7 @@ class SerializeExtraBytesRequired {
   size_t operator()(const Http2PingFrame&) { return 8; }
   size_t operator()(const Http2GoawayFrame&) { return 8; }
   size_t operator()(const Http2WindowUpdateFrame&) { return 4; }
+  size_t operator()(const Http2SecurityFrame&) { return 0; }
   size_t operator()(const Http2UnknownFrame&) { Crash("unreachable"); }
 };
 
@@ -218,6 +220,15 @@ class SerializeHeaderAndPayload {
     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}
+        .Serialize(hdr.begin());
+    out_.AppendIndexed(Slice(std::move(hdr)));
+    out_.TakeAndAppend(frame.payload);
+  }
+
   void operator()(Http2UnknownFrame&) { Crash("unreachable"); }
 
  private:
@@ -415,6 +426,11 @@ absl::StatusOr<Http2WindowUpdateFrame> ParseWindowUpdateFrame(
   return Http2WindowUpdateFrame{hdr.stream_id, Read4b(buffer)};
 }
 
+absl::StatusOr<Http2SecurityFrame> ParseSecurityFrame(
+    const Http2FrameHeader& /*hdr*/, SliceBuffer& payload) {
+  return Http2SecurityFrame{std::move(payload)};
+}
+
 }  // namespace
 
 void Http2FrameHeader::Serialize(uint8_t* output) const {
@@ -447,6 +463,8 @@ std::string Http2FrameTypeString(uint8_t frame_type) {
       return "WINDOW_UPDATE";
     case kFrameTypePing:
       return "PING";
+    case kFrameTypeSecurity:
+      return "SECURITY";
   }
   return absl::StrCat("UNKNOWN(", frame_type, ")");
 }
@@ -495,6 +513,8 @@ absl::StatusOr<Http2Frame> ParseFramePayload(const Http2FrameHeader& hdr,
       return absl::InternalError(
           "push promise not supported (and SETTINGS_ENABLE_PUSH explicitly "
           "disabled).");
+    case kFrameTypeSecurity:
+      return ParseSecurityFrame(hdr, payload);
     default:
       return Http2UnknownFrame{};
   }

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

@@ -151,6 +151,15 @@ struct Http2WindowUpdateFrame {
   }
 };
 
+// Security-related frame
+struct Http2SecurityFrame {
+  SliceBuffer payload;
+
+  bool operator==(const Http2SecurityFrame& other) const {
+    return payload.JoinIntoString() == other.payload.JoinIntoString();
+  }
+};
+
 // Type of frame was unknown (and should be ignored)
 struct Http2UnknownFrame {
   bool operator==(const Http2UnknownFrame&) const { return true; }
@@ -164,7 +173,8 @@ struct Http2UnknownFrame {
 using Http2Frame =
     absl::variant<Http2DataFrame, Http2HeaderFrame, Http2ContinuationFrame,
                   Http2RstStreamFrame, Http2SettingsFrame, Http2PingFrame,
-                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2UnknownFrame>;
+                  Http2GoawayFrame, Http2WindowUpdateFrame, Http2SecurityFrame,
+                  Http2UnknownFrame>;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Frame header

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

@@ -84,13 +84,16 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
   grpc_slice_buffer* slices = &s->frame_storage;
   grpc_error_handle error;
 
-  if (slices->length < 5) {
-    if (min_progress_size != nullptr) *min_progress_size = 5 - slices->length;
+  if (slices->length < GRPC_HEADER_SIZE_IN_BYTES) {
+    if (min_progress_size != nullptr) {
+      *min_progress_size = GRPC_HEADER_SIZE_IN_BYTES - slices->length;
+    }
     return grpc_core::Pending{};
   }
 
-  uint8_t header[5];
-  grpc_slice_buffer_copy_first_into_buffer(slices, 5, header);
+  uint8_t header[GRPC_HEADER_SIZE_IN_BYTES];
+  grpc_slice_buffer_copy_first_into_buffer(slices, GRPC_HEADER_SIZE_IN_BYTES,
+                                           header);
 
   switch (header[0]) {
     case 0:
@@ -114,9 +117,9 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
                   (static_cast<uint32_t>(header[3]) << 8) |
                   static_cast<uint32_t>(header[4]);
 
-  if (slices->length < length + 5) {
+  if (slices->length < length + GRPC_HEADER_SIZE_IN_BYTES) {
     if (min_progress_size != nullptr) {
-      *min_progress_size = length + 5 - slices->length;
+      *min_progress_size = length + GRPC_HEADER_SIZE_IN_BYTES - slices->length;
     }
     return grpc_core::Pending{};
   }
@@ -124,8 +127,10 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
   if (min_progress_size != nullptr) *min_progress_size = 0;
 
   if (stream_out != nullptr) {
-    s->call_tracer_wrapper.RecordIncomingBytes({5, length, 0});
-    grpc_slice_buffer_move_first_into_buffer(slices, 5, header);
+    s->call_tracer_wrapper.RecordIncomingBytes(
+        {GRPC_HEADER_SIZE_IN_BYTES, length, 0});
+    grpc_slice_buffer_move_first_into_buffer(slices, GRPC_HEADER_SIZE_IN_BYTES,
+                                             header);
     grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
   }
 

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

@@ -0,0 +1,82 @@
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "src/core/ext/transport/chttp2/transport/frame_security.h"
+
+#include <cstddef>
+#include <cstdint>
+
+#include "absl/status/status.h"
+#include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+
+absl::Status grpc_chttp2_security_frame_parser_parse(void* parser,
+                                                     grpc_chttp2_transport* t,
+                                                     grpc_chttp2_stream* /*s*/,
+                                                     const grpc_slice& slice,
+                                                     int is_last) {
+  // Ignore frames from non-EventEngine endpoints.
+  if (t->transport_framing_endpoint_extension == nullptr) {
+    return absl::OkStatus();
+  }
+
+  grpc_chttp2_security_frame_parser* p =
+      static_cast<grpc_chttp2_security_frame_parser*>(parser);
+  p->payload.Append(grpc_core::Slice(slice));
+
+  if (is_last) {
+    // Send security frame payload to endpoint.
+    t->transport_framing_endpoint_extension->ReceiveFrame(
+        std::move(p->payload));
+  }
+
+  return absl::OkStatus();
+}
+
+absl::Status grpc_chttp2_security_frame_parser_begin_frame(
+    grpc_chttp2_security_frame_parser* parser) {
+  parser->payload.Clear();
+  return absl::OkStatus();
+}
+
+void grpc_chttp2_security_frame_create(grpc_slice_buffer* payload,
+                                       uint32_t length,
+                                       grpc_slice_buffer* frame) {
+  // does this frame need padding for security?
+  // do we need to worry about max frame size? it's 16 bytes
+  grpc_slice hdr;
+  uint8_t* p;
+  static const size_t header_size = 9;
+
+  hdr = GRPC_SLICE_MALLOC(header_size);
+  p = GRPC_SLICE_START_PTR(hdr);
+  *p++ = static_cast<uint8_t>(length >> 16);
+  *p++ = static_cast<uint8_t>(length >> 8);
+  *p++ = static_cast<uint8_t>(length);
+  *p++ = GRPC_CHTTP2_FRAME_SECURITY;
+  *p++ = 0;  // no flags
+  *p++ = 0;
+  *p++ = 0;
+  *p++ = 0;
+  *p++ = 0;
+
+  grpc_slice_buffer_add(frame, hdr);
+  grpc_slice_buffer_move_first_no_ref(payload, payload->length, frame);
+}

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

@@ -0,0 +1,44 @@
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_SECURITY_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_SECURITY_H
+
+#include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
+#include <stdint.h>
+
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+
+struct grpc_chttp2_security_frame_parser {
+  grpc_core::SliceBuffer payload;
+};
+
+void grpc_chttp2_security_frame_create(grpc_slice_buffer* payload,
+                                       uint32_t length,
+                                       grpc_slice_buffer* frame);
+
+absl::Status grpc_chttp2_security_frame_parser_begin_frame(
+    grpc_chttp2_security_frame_parser* parser);
+
+grpc_error_handle grpc_chttp2_security_frame_parser_parse(
+    void* parser, grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+    const grpc_slice& slice, int is_last);
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_FRAME_SECURITY_H

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

@@ -36,6 +36,7 @@
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/telemetry/stats.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/useful.h"
 
@@ -100,6 +101,21 @@ grpc_error_handle grpc_chttp2_settings_parser_parse(void* p,
         if (cur == end) {
           parser->state = GRPC_CHTTP2_SPS_ID0;
           if (is_last) {
+            grpc_core::Http2Settings* target_settings =
+                parser->incoming_settings.get();
+            grpc_core::global_stats().IncrementHttp2HeaderTableSize(
+                target_settings->header_table_size());
+            grpc_core::global_stats().IncrementHttp2InitialWindowSize(
+                target_settings->initial_window_size());
+            grpc_core::global_stats().IncrementHttp2MaxConcurrentStreams(
+                target_settings->max_concurrent_streams());
+            grpc_core::global_stats().IncrementHttp2MaxFrameSize(
+                target_settings->max_frame_size());
+            grpc_core::global_stats().IncrementHttp2MaxHeaderListSize(
+                target_settings->max_header_list_size());
+            grpc_core::global_stats()
+                .IncrementHttp2PreferredReceiveCryptoMessageSize(
+                    target_settings->preferred_receive_crypto_message_size());
             *parser->target_settings = *parser->incoming_settings;
             t->num_pending_induced_frames++;
             grpc_slice_buffer_add(&t->qbuf, grpc_chttp2_settings_ack_create());