grpc 1.73.0 → 1.75.0

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

@@ -23,7 +23,6 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/strings/str_cat.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
 #include "src/core/util/useful.h"
 
@@ -32,35 +31,36 @@ using grpc_core::http2::Http2ErrorCode;
 namespace grpc_core {
 
 void Http2Settings::Diff(
-    bool is_first_send, const Http2Settings& old,
+    bool is_first_send, const Http2Settings& old_setting,
     absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const {
-  if (header_table_size_ != old.header_table_size_) {
+  if (header_table_size_ != old_setting.header_table_size_) {
     cb(kHeaderTableSizeWireId, header_table_size_);
   }
-  if (enable_push_ != old.enable_push_) {
+  if (enable_push_ != old_setting.enable_push_) {
     cb(kEnablePushWireId, enable_push_);
   }
-  if (max_concurrent_streams_ != old.max_concurrent_streams_) {
+  if (max_concurrent_streams_ != old_setting.max_concurrent_streams_) {
     cb(kMaxConcurrentStreamsWireId, max_concurrent_streams_);
   }
-  if (is_first_send || initial_window_size_ != old.initial_window_size_) {
+  if (is_first_send ||
+      initial_window_size_ != old_setting.initial_window_size_) {
     cb(kInitialWindowSizeWireId, initial_window_size_);
   }
-  if (max_frame_size_ != old.max_frame_size_) {
+  if (max_frame_size_ != old_setting.max_frame_size_) {
     cb(kMaxFrameSizeWireId, max_frame_size_);
   }
-  if (max_header_list_size_ != old.max_header_list_size_) {
+  if (max_header_list_size_ != old_setting.max_header_list_size_) {
     cb(kMaxHeaderListSizeWireId, max_header_list_size_);
   }
-  if (allow_true_binary_metadata_ != old.allow_true_binary_metadata_) {
+  if (allow_true_binary_metadata_ != old_setting.allow_true_binary_metadata_) {
     cb(kGrpcAllowTrueBinaryMetadataWireId, allow_true_binary_metadata_);
   }
   if (preferred_receive_crypto_message_size_ !=
-      old.preferred_receive_crypto_message_size_) {
+      old_setting.preferred_receive_crypto_message_size_) {
     cb(kGrpcPreferredReceiveCryptoFrameSizeWireId,
        preferred_receive_crypto_message_size_);
   }
-  if (allow_security_frame_ != old.allow_security_frame_) {
+  if (allow_security_frame_ != old_setting.allow_security_frame_) {
     cb(kGrpcAllowSecurityFrameWireId, allow_security_frame_);
   }
 }
@@ -134,31 +134,4 @@ Http2ErrorCode Http2Settings::Apply(uint16_t key, uint32_t value) {
   return Http2ErrorCode::kNoError;
 }
 
-std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
-  switch (update_state_) {
-    case UpdateState::kSending:
-      return std::nullopt;
-    case UpdateState::kIdle:
-      if (local_ == sent_) return std::nullopt;
-      break;
-    case UpdateState::kFirst:
-      break;
-  }
-  Http2SettingsFrame frame;
-  local_.Diff(update_state_ == UpdateState::kFirst, sent_,
-              [&frame](uint16_t key, uint32_t value) {
-                frame.settings.emplace_back(key, value);
-              });
-  sent_ = local_;
-  update_state_ = UpdateState::kSending;
-  return frame;
-}
-
-bool Http2SettingsManager::AckLastSend() {
-  if (update_state_ != UpdateState::kSending) return false;
-  update_state_ = UpdateState::kIdle;
-  acked_ = sent_;
-  return true;
-}
-
 }  // namespace grpc_core

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

@@ -25,9 +25,8 @@
 
 #include "absl/functional/function_ref.h"
 #include "absl/strings/string_view.h"
-#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/ext/transport/chttp2/transport/http2_status.h"
-#include "src/core/util/json/json.h"
 #include "src/core/util/useful.h"
 
 namespace grpc_core {
@@ -35,18 +34,21 @@ namespace grpc_core {
 class Http2Settings {
  public:
   enum : uint16_t {
+    // These values are as defined in RFC9113
+    // https://www.rfc-editor.org/rfc/rfc9113.html#name-defined-settings
     kHeaderTableSizeWireId = 1,
     kEnablePushWireId = 2,
     kMaxConcurrentStreamsWireId = 3,
     kInitialWindowSizeWireId = 4,
     kMaxFrameSizeWireId = 5,
     kMaxHeaderListSizeWireId = 6,
+    // gRPC specific settings
     kGrpcAllowTrueBinaryMetadataWireId = 65027,
     kGrpcPreferredReceiveCryptoFrameSizeWireId = 65028,
     kGrpcAllowSecurityFrameWireId = 65029,
   };
 
-  void Diff(bool is_first_send, const Http2Settings& old,
+  void Diff(bool is_first_send, const Http2Settings& old_setting,
             absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
   GRPC_MUST_USE_RESULT http2::Http2ErrorCode Apply(uint16_t key,
                                                    uint32_t value);
@@ -133,65 +135,77 @@ class Http2Settings {
 
   bool operator!=(const Http2Settings& rhs) const { return !operator==(rhs); }
 
-  Json::Object ToJsonObject() const {
-    Json::Object object;
-    object["headerTableSize"] = Json::FromNumber(header_table_size());
-    object["maxConcurrentStreams"] = Json::FromNumber(max_concurrent_streams());
-    object["initialWindowSize"] = Json::FromNumber(initial_window_size());
-    object["maxFrameSize"] = Json::FromNumber(max_frame_size());
-    object["maxHeaderListSize"] = Json::FromNumber(max_header_list_size());
-    object["preferredReceiveCryptoMessageSize"] =
-        Json::FromNumber(preferred_receive_crypto_message_size());
-    object["enablePush"] = Json::FromBool(enable_push());
-    object["allowTrueBinaryMetadata"] =
-        Json::FromBool(allow_true_binary_metadata());
-    object["allowSecurityFrame"] = Json::FromBool(allow_security_frame());
-    return object;
+  channelz::PropertyList ChannelzProperties() const {
+    return channelz::PropertyList()
+        .Set(header_table_size_name(), header_table_size())
+        .Set(max_concurrent_streams_name(), max_concurrent_streams())
+        .Set(initial_window_size_name(), initial_window_size())
+        .Set(max_frame_size_name(), max_frame_size())
+        .Set(max_header_list_size_name(), max_header_list_size())
+        .Set(preferred_receive_crypto_message_size_name(),
+             preferred_receive_crypto_message_size())
+        .Set(enable_push_name(), enable_push())
+        .Set(allow_true_binary_metadata_name(), allow_true_binary_metadata())
+        .Set(allow_security_frame_name(), allow_security_frame());
   }
 
  private:
-  uint32_t header_table_size_ = 4096;
+  // RFC9113 states the default value for SETTINGS_HEADER_TABLE_SIZE
+  // Currently this is set only once in the lifetime of a transport.
+  // We plan to change that in the future.
+  uint32_t header_table_size_ = 4096u;
+
+  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
+  // and write it here.
+  // CLIENT : Set only once in the lifetime of a client transport. This is set
+  // to 0 for client.
+  // SERVER : This setting can change for the server. This is usually changed to
+  // handle memory pressure.
   uint32_t max_concurrent_streams_ = 4294967295u;
+
+  // RFC9113 states the default for SETTINGS_INITIAL_WINDOW_SIZE
+  // Both client and servers can change this setting. This is usually changed to
+  // handle memory pressure.
   uint32_t initial_window_size_ = 65535u;
+
+  // RFC9113 states the default for SETTINGS_MAX_FRAME_SIZE
+  // Both client and servers can change this setting. This is usually changed to
+  // handle memory pressure.
   uint32_t max_frame_size_ = 16384u;
+
+  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
+  // and write it here.
+  // This is an advisory but we currently enforce it.
+  // Set only once in the lifetime of a transport currently.
+  // When a peer that updates this more than once, that may indicate either an
+  // underlying issue or a malicious peer.
   uint32_t max_header_list_size_ = 16777216u;
-  uint32_t preferred_receive_crypto_message_size_ = 0u;
-  bool enable_push_ = true;
-  bool allow_true_binary_metadata_ = false;
-  bool allow_security_frame_ = false;
-};
 
-class Http2SettingsManager {
- public:
-  Http2Settings& mutable_local() { return local_; }
-  const Http2Settings& local() const { return local_; }
-  const Http2Settings& acked() const { return acked_; }
-  Http2Settings& mutable_peer() { return peer_; }
-  const Http2Settings& peer() const { return peer_; }
+  // gRPC defined setting
+  // Both client and servers can change this setting. This is usually changed to
+  // handle memory pressure.
+  uint32_t preferred_receive_crypto_message_size_ = 0u;
 
-  Json::Object ToJsonObject() const {
-    Json::Object object;
-    object["local"] = Json::FromObject(local_.ToJsonObject());
-    object["sent"] = Json::FromObject(sent_.ToJsonObject());
-    object["peer"] = Json::FromObject(peer_.ToJsonObject());
-    object["acked"] = Json::FromObject(acked_.ToJsonObject());
-    return object;
-  }
+  // RFC9113 defined default is true. However, for gRPC we always then set it to
+  // false via the SetEnablePush function
+  // Currently this is set only once in the lifetime of a transport.
+  // We have no plans to support this in the future.
+  bool enable_push_ = true;
 
-  std::optional<Http2SettingsFrame> MaybeSendUpdate();
-  GRPC_MUST_USE_RESULT bool AckLastSend();
+  // gRPC defined setting
+  // Unlike most other SETTINGS, this setting is negotiated between the client
+  // and the server.
+  // Currently this is set only once in the lifetime of a transport.
+  // Disconnect if it is received more than once from the peer.
+  bool allow_true_binary_metadata_ = false;
 
- private:
-  enum class UpdateState : uint8_t {
-    kFirst,
-    kSending,
-    kIdle,
-  };
-  UpdateState update_state_ = UpdateState::kFirst;
-  Http2Settings local_;
-  Http2Settings sent_;
-  Http2Settings peer_;
-  Http2Settings acked_;
+  // gRPC defined setting
+  // Unlike most other SETTINGS, this setting is negotiated between the client
+  // and the server. Both have to set it to true for the system to successfully
+  // apply the custom SECURITY frame.
+  // Currently this is set only once in the lifetime of a transport.
+  // Disconnect if it is received more than once from the peer.
+  bool allow_security_frame_ = false;
 };
 
 }  // namespace grpc_core

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

@@ -0,0 +1,61 @@
+//
+// Copyright 2017 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.
+//
+
+//
+// Automatically generated by tools/codegen/core/gen_settings_ids.py
+//
+
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/str_cat.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+std::optional<Http2SettingsFrame> Http2SettingsManager::MaybeSendUpdate() {
+  switch (update_state_) {
+    case UpdateState::kSending:
+      return std::nullopt;
+    case UpdateState::kIdle:
+      if (local_ == sent_) return std::nullopt;
+      break;
+    case UpdateState::kFirst:
+      break;
+  }
+  Http2SettingsFrame frame;
+  local_.Diff(/*is_first_send=*/update_state_ == UpdateState::kFirst,
+              /*old_setting=*/sent_,
+              /*cb=*/[&frame](uint16_t key, uint32_t value) {
+                frame.settings.emplace_back(key, value);
+              });
+  sent_ = local_;
+  update_state_ = UpdateState::kSending;
+  return frame;
+}
+
+bool Http2SettingsManager::AckLastSend() {
+  if (update_state_ != UpdateState::kSending) return false;
+  update_state_ = UpdateState::kIdle;
+  acked_ = sent_;
+  return true;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,142 @@
+//
+// Copyright 2017 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_HTTP2_SETTINGS_MANAGER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_MANAGER_H
+
+#include <grpc/support/port_platform.h>
+#include <stdint.h>
+
+#include <cstdint>
+#include <optional>
+
+#include "absl/functional/function_ref.h"
+#include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
+#include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+class Http2SettingsManager {
+ public:
+  // Only local and peer settings can be edited by the transport.
+  Http2Settings& mutable_local() { return local_; }
+  Http2Settings& mutable_peer() { return peer_; }
+
+  const Http2Settings& local() const { return local_; }
+  // Before the first SETTINGS ACK frame is received acked_ will hold the
+  // default values.
+  const Http2Settings& acked() const { return acked_; }
+  const Http2Settings& peer() const { return peer_; }
+
+  channelz::PropertyGrid ChannelzProperties() const {
+    return channelz::PropertyGrid()
+        .SetColumn("local", local_.ChannelzProperties())
+        .SetColumn("sent", sent_.ChannelzProperties())
+        .SetColumn("peer", peer_.ChannelzProperties())
+        .SetColumn("acked", acked_.ChannelzProperties());
+  }
+
+  // Returns nullopt if we don't need to send a SETTINGS frame to the peer.
+  // Returns Http2SettingsFrame if we need to send a SETTINGS frame to the
+  // peer. Transport MUST send a frame returned by this function to the peer.
+  // This function is not idempotent.
+  std::optional<Http2SettingsFrame> MaybeSendUpdate();
+
+  // To be called from a promise based HTTP2 transport only
+  http2::Http2ErrorCode ApplyIncomingSettings(
+      std::vector<Http2SettingsFrame::Setting>& settings) {
+    for (const auto& setting : settings) {
+      http2::Http2ErrorCode error1 =
+          count_updates_.IsUpdatePermitted(setting.id, setting.value, peer_);
+      if (GPR_UNLIKELY(error1 != http2::Http2ErrorCode::kNoError)) {
+        return error1;
+      }
+      http2::Http2ErrorCode error = peer_.Apply(setting.id, setting.value);
+      if (GPR_UNLIKELY(error != http2::Http2ErrorCode::kNoError)) {
+        return error;
+      }
+    }
+    return http2::Http2ErrorCode::kNoError;
+  }
+
+  // Call when we receive an ACK from our peer.
+  // This function is not idempotent.
+  GRPC_MUST_USE_RESULT bool AckLastSend();
+
+ private:
+  struct CountUpdates {
+    http2::Http2ErrorCode IsUpdatePermitted(const uint16_t setting_id,
+                                            const uint32_t value,
+                                            const Http2Settings& peer) {
+      switch (setting_id) {
+        case Http2Settings::kGrpcAllowTrueBinaryMetadataWireId:
+          // These settings must not change more than once. This is a gRPC
+          // defined settings.
+          if (allow_true_binary_metadata_update &&
+              peer.allow_true_binary_metadata() != static_cast<bool>(value)) {
+            return http2::Http2ErrorCode::kConnectError;
+          }
+          allow_true_binary_metadata_update = true;
+          break;
+        case Http2Settings::kGrpcAllowSecurityFrameWireId:
+          // These settings must not change more than once. This is a gRPC
+          // defined settings.
+          if (allow_security_frame_update &&
+              peer.allow_security_frame() != static_cast<bool>(value)) {
+            return http2::Http2ErrorCode::kConnectError;
+          }
+          allow_security_frame_update = true;
+          break;
+        default:
+          break;
+      }
+      return http2::Http2ErrorCode::kNoError;
+    }
+    bool allow_true_binary_metadata_update = false;
+    bool allow_security_frame_update = false;
+  };
+  CountUpdates count_updates_;
+
+  enum class UpdateState : uint8_t {
+    kFirst,
+    kSending,
+    kIdle,
+  };
+  UpdateState update_state_ = UpdateState::kFirst;
+
+  // This holds a copy of the peers settings.
+  Http2Settings peer_;
+
+  // These are different sets of our settings.
+  // local_  : Setting that has been changed inside our transport,
+  //           but not yet sent to the peer.
+  // sent_   : New settings frame is sent to the peer but we have not yet
+  //           received the ACK from the peer.
+  // acked_  : The settings that have already been ACKed by the peer. These
+  //           settings can be enforced and any violation of these settings by a
+  //           peer may cause an error.
+  Http2Settings local_;
+  Http2Settings sent_;
+  Http2Settings acked_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_SETTINGS_MANAGER_H

data/{third_party/abseil-cpp/absl/strings/cord_buffer.cc → src/core/ext/transport/chttp2/transport/http2_stats_collector.cc}

@@ -1,30 +1,30 @@
-// Copyright 2022 The Abseil Authors
+//
+//
+// Copyright 2025 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
 //
-//     https://www.apache.org/licenses/LICENSE-2.0
+//     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 "absl/strings/cord_buffer.h"
-
-#include <cstddef>
+#include "src/core/ext/transport/chttp2/transport/http2_stats_collector.h"
 
-#include "absl/base/config.h"
+#include <grpc/credentials.h>
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
+namespace grpc_core {
 
-#ifdef ABSL_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
-constexpr size_t CordBuffer::kDefaultLimit;
-constexpr size_t CordBuffer::kCustomLimit;
-#endif
+std::shared_ptr<Http2StatsCollector> CreateHttp2StatsCollector(
+    grpc_auth_context* /*ctx*/) {
+  return std::make_shared<Http2StatsCollector>();
+}
 
-ABSL_NAMESPACE_END
-}  // namespace absl
+}  // namespace grpc_core

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

@@ -0,0 +1,33 @@
+//
+//
+// Copyright 2025 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_HTTP2_STATS_COLLECTOR_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_STATS_COLLECTOR_H
+
+#include <grpc/credentials.h>
+
+#include "src/core/telemetry/stats_data.h"
+
+namespace grpc_core {
+
+std::shared_ptr<Http2StatsCollector> CreateHttp2StatsCollector(
+    grpc_auth_context* ctx);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_STATS_COLLECTOR_H

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

@@ -51,6 +51,7 @@ enum class Http2ErrorCode : uint8_t {
   kConnectError = 0xa,
   kEnhanceYourCalm = 0xb,
   kInadequateSecurity = 0xc,
+  kHTTP11Required = 0xd,
   kDoNotUse = 0xffu  // Force use of a default clause
 };
 
@@ -75,6 +76,10 @@ inline absl::StatusCode ErrorCodeToAbslStatusCode(
   GPR_UNREACHABLE_CODE(return absl::StatusCode::kUnknown);
 }
 
+inline uint8_t GetMaxHttp2ErrorCode() {
+  return static_cast<uint8_t>(Http2ErrorCode::kHTTP11Required);
+}
+
 inline Http2ErrorCode AbslStatusCodeToErrorCode(const absl::StatusCode status) {
   switch (status) {
     case absl::StatusCode::kOk:
@@ -323,7 +328,7 @@ class GRPC_MUST_USE_RESULT Http2Status {
 };
 
 // We can add more methods and helpers as needed.
-// This class is similar to ValueOrFailure but a more minamilasit version.
+// This class is similar to ValueOrFailure but a more minimalist version.
 // Reference :
 // https://github.com/grpc/grpc/blob/master/src/core/lib/promise/status_flag.h