grpc 1.81.1 → 1.83.1

data/src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h

@@ -1,86 +0,0 @@
-//
-// 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_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H
-
-#include <stddef.h>
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/service_config/service_config_parser.h"
-#include "src/core/util/json/json.h"
-#include "src/core/util/json/json_args.h"
-#include "src/core/util/json/json_object_loader.h"
-#include "src/core/util/validation_errors.h"
-#include "absl/strings/string_view.h"
-
-// Channel arg key for enabling parsing fault injection via method config.
-#define GRPC_ARG_PARSE_GCP_AUTHENTICATION_METHOD_CONFIG \
-  "grpc.internal.parse_gcp_authentication_method_config"
-
-namespace grpc_core {
-
-class GcpAuthenticationParsedConfig : public ServiceConfigParser::ParsedConfig {
- public:
-  struct Config {
-    std::string filter_instance_name;
-    uint64_t cache_size = 10;
-
-    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors);
-  };
-
-  // Returns the config at the specified index.  There might be multiple
-  // GCP auth filters in the list of HTTP filters at the same time.
-  // The order of the list is stable, and an index is used to keep track of
-  // their relative positions.  Each filter instance uses this method to
-  // access the appropriate parsed config for that instance.
-  const Config* GetConfig(size_t index) const {
-    if (index >= configs_.size()) return nullptr;
-    return &configs_[index];
-  }
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-
- private:
-  std::vector<Config> configs_;
-};
-
-class GcpAuthenticationServiceConfigParser final
-    : public ServiceConfigParser::Parser {
- public:
-  absl::string_view name() const override { return parser_name(); }
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
-      const ChannelArgs& args, const Json& json,
-      ValidationErrors* errors) override;
-  // Returns the parser index for the parser.
-  static size_t ParserIndex();
-  // Registers the parser.
-  static void Register(CoreConfiguration::Builder* builder);
-
- private:
-  static absl::string_view parser_name() { return "gcp_auth"; }
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_GCP_AUTHENTICATION_GCP_AUTHENTICATION_SERVICE_CONFIG_PARSER_H

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.cc

@@ -1,83 +0,0 @@
-//
-// Copyright 2022 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/filters/stateful_session/stateful_session_service_config_parser.h"
-
-#include <grpc/support/port_platform.h>
-
-#include <optional>
-#include <vector>
-
-#include "src/core/lib/channel/channel_args.h"
-
-namespace grpc_core {
-
-const JsonLoaderInterface*
-StatefulSessionMethodParsedConfig::CookieConfig::JsonLoader(const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<CookieConfig>()
-          .OptionalField("name", &CookieConfig::cookie_name)
-          .OptionalField("path", &CookieConfig::path)
-          .OptionalField("ttl", &CookieConfig::ttl)
-          .Finish();
-  return loader;
-}
-
-void StatefulSessionMethodParsedConfig::CookieConfig::JsonPostLoad(
-    const Json& json, const JsonArgs&, ValidationErrors* errors) {
-  // Validate that cookie_name is non-empty.
-  if (json.object().find("name") != json.object().end() &&
-      cookie_name.empty()) {
-    ValidationErrors::ScopedField field(errors, ".name");
-    errors->AddError("must be non-empty");
-  }
-}
-
-const JsonLoaderInterface* StatefulSessionMethodParsedConfig::JsonLoader(
-    const JsonArgs&) {
-  static const auto* loader =
-      JsonObjectLoader<StatefulSessionMethodParsedConfig>()
-          .OptionalField("stateful_session",
-                         &StatefulSessionMethodParsedConfig::configs_)
-          .Finish();
-  return loader;
-}
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-StatefulSessionServiceConfigParser::ParsePerMethodParams(
-    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
-  // Only parse config if the following channel arg is present.
-  if (!args.GetBool(GRPC_ARG_PARSE_STATEFUL_SESSION_METHOD_CONFIG)
-           .value_or(false)) {
-    return nullptr;
-  }
-  // Parse config from json.
-  return LoadFromJson<std::unique_ptr<StatefulSessionMethodParsedConfig>>(
-      json, JsonArgs(), errors);
-}
-
-void StatefulSessionServiceConfigParser::Register(
-    CoreConfiguration::Builder* builder) {
-  builder->service_config_parser()->RegisterParser(
-      std::make_unique<StatefulSessionServiceConfigParser>());
-}
-
-size_t StatefulSessionServiceConfigParser::ParserIndex() {
-  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
-      parser_name());
-}
-
-}  // namespace grpc_core

data/src/core/ext/filters/stateful_session/stateful_session_service_config_parser.h

@@ -1,91 +0,0 @@
-//
-// Copyright 2022 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_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_SERVICE_CONFIG_PARSER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_SERVICE_CONFIG_PARSER_H
-
-#include <grpc/support/port_platform.h>
-#include <stddef.h>
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/service_config/service_config_parser.h"
-#include "src/core/util/json/json.h"
-#include "src/core/util/json/json_args.h"
-#include "src/core/util/json/json_object_loader.h"
-#include "src/core/util/time.h"
-#include "src/core/util/validation_errors.h"
-#include "absl/strings/string_view.h"
-
-// Channel arg key for enabling parsing fault injection via method config.
-#define GRPC_ARG_PARSE_STATEFUL_SESSION_METHOD_CONFIG \
-  "grpc.internal.parse_stateful_session_method_config"
-
-namespace grpc_core {
-
-class StatefulSessionMethodParsedConfig
-    : public ServiceConfigParser::ParsedConfig {
- public:
-  struct CookieConfig {
-    std::string cookie_name;  // Will be empty if disabled.
-    std::string path;
-    Duration ttl;
-
-    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors);
-  };
-
-  // Returns the config at the specified index.  There might be multiple
-  // stateful session filters in the list of HTTP filters at the same time.
-  // The order of the list is stable, and an index is used to keep track of
-  // their relative positions.  Each filter instance uses this method to
-  // access the appropriate parsed config for that instance.
-  const CookieConfig* GetConfig(size_t index) const {
-    if (index >= configs_.size()) return nullptr;
-    return &configs_[index];
-  }
-
-  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-
- private:
-  std::vector<CookieConfig> configs_;
-};
-
-class StatefulSessionServiceConfigParser final
-    : public ServiceConfigParser::Parser {
- public:
-  absl::string_view name() const override { return parser_name(); }
-  // Parses the per-method service config for the filter.
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const ChannelArgs& args, const Json& json,
-      ValidationErrors* errors) override;
-  // Returns the parser index for the parser.
-  static size_t ParserIndex();
-  // Registers the parser.
-  static void Register(CoreConfiguration::Builder* builder);
-
- private:
-  static absl::string_view parser_name() { return "stateful_session"; }
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_STATEFUL_SESSION_STATEFUL_SESSION_SERVICE_CONFIG_PARSER_H

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

@@ -1,217 +0,0 @@
-//
-//
-// 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_INCOMING_METADATA_TRACKER_H
-#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <cstdint>
-#include <string>
-#include <utility>
-
-#include "src/core/call/metadata_info.h"
-#include "src/core/ext/transport/chttp2/transport/header_assembler.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
-#include "src/core/ext/transport/chttp2/transport/http2_status.h"
-#include "src/core/ext/transport/chttp2/transport/http2_transport.h"
-#include "src/core/ext/transport/chttp2/transport/stream.h"
-#include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/slice/slice.h"
-#include "src/core/lib/slice/slice_buffer.h"
-#include "src/core/lib/transport/promise_endpoint.h"
-#include "src/core/util/debug_location.h"
-#include "src/core/util/grpc_check.h"
-#include "absl/log/log.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/str_cat.h"
-
-namespace grpc_core {
-namespace http2 {
-
-class IncomingMetadataTracker {
-  // Manages transport-wide state for incoming HEADERS and CONTINUATION frames.
-  // RFC 9113 (Section 6.10) requires that if a HEADERS frame does not have
-  // END_HEADERS set, it must be followed by a contiguous sequence of
-  // CONTINUATION frames for the same stream, ending with END_HEADERS. No other
-  // frame types or frames for other streams may be interleaved during this
-  // sequence. This constraint makes tracking header sequence state a
-  // transport-level concern, as only one stream can be receiving headers at
-  // a time. This class is distinct from HeaderAssembler, which buffers header
-  // payloads on a per-stream basis.
- public:
-  explicit IncomingMetadataTracker(Slice peer_string, const bool is_client)
-      : peer_string_(std::move(peer_string)), is_client_(is_client) {}
-  ~IncomingMetadataTracker() = default;
-
-  IncomingMetadataTracker(IncomingMetadataTracker&& rvalue) = delete;
-  IncomingMetadataTracker& operator=(IncomingMetadataTracker&& rvalue) = delete;
-  IncomingMetadataTracker(const IncomingMetadataTracker&) = delete;
-  IncomingMetadataTracker& operator=(const IncomingMetadataTracker&) = delete;
-
-  static Slice GetPeerString(const PromiseEndpoint& endpoint) {
-    absl::StatusOr<std::string> uri =
-        grpc_event_engine::experimental::ResolvedAddressToURI(
-            endpoint.GetPeerAddress());
-    if (uri.ok()) {
-      return Slice::FromCopiedString(*uri);
-    }
-    return Slice::FromCopiedString("unknown");
-  }
-
-  Slice peer_string() const { return peer_string_.Ref(); }
-
-  void set_soft_limit(uint32_t limit) {
-    max_header_list_size_soft_limit_ = limit;
-  }
-  uint32_t soft_limit() const { return max_header_list_size_soft_limit_; }
-
-  HPackParser& parser() { return parser_; }
-
-  void SetMaxHeaderTableSize(const uint32_t size) {
-    parser_.hpack_table()->SetMaxBytes(size);
-  }
-
-  // This function is used to partially process a HEADER or CONTINUATION frame.
-  // `PARTIAL PROCESSING` means reading the payload of a HEADER or CONTINUATION
-  // and processing it with the HPACK decoder, and then discarding the payload.
-  // This is done to keep the transports HPACK parser in sync with peers HPACK.
-  // Scenarios where 'partial processing' is used when we receive a HEADER or
-  // CONTINUATION frames when a stream is closed, or there is a Stream Error. We
-  // do not do partial processing for Connection Errors because the Transport
-  // will be destroyed soon after.
-  Http2Status ParseAndDiscardHeaders(
-      SliceBuffer&& buffer, const bool is_end_headers, Stream* stream,
-      Http2Status&& original_status,
-      const uint32_t max_header_list_size_hard_limit) {
-    const HeaderAssembler::ParseHeaderArgs args = {
-        /*is_initial_metadata=*/!incoming_header_end_stream_,
-        /*is_end_headers=*/is_end_headers,
-        /*is_client=*/is_client_,
-        /*max_header_list_size_soft_limit=*/
-        max_header_list_size_soft_limit_,
-        /*max_header_list_size_hard_limit=*/max_header_list_size_hard_limit,
-        /*stream_id=*/incoming_header_stream_id_,
-    };
-    GRPC_HTTP2_COMMON_DLOG << "ParseAndDiscardHeaders buffer "
-                              "size: "
-                           << buffer.Length() << " args: " << args.DebugString()
-                           << " stream_id: "
-                           << (stream == nullptr ? 0 : stream->GetStreamId())
-                           << " original_status: "
-                           << original_status.DebugString();
-    if (stream != nullptr) {
-      // Parse all the data in the header assembler
-      Http2Status result = stream->GetHeaderAssembler().ParseAndDiscardHeaders(
-          parser_, args.is_initial_metadata,
-          args.max_header_list_size_soft_limit,
-          args.max_header_list_size_hard_limit);
-      if (!result.IsOk()) {
-        GRPC_DCHECK(result.GetType() ==
-                    Http2Status::Http2ErrorType::kConnectionError);
-        LOG(ERROR) << "Connection Error: " << result;
-        return result;
-      }
-    }
-
-    if (buffer.Length() == 0) {
-      return std::move(original_status);
-    }
-
-    Http2Status status = HeaderAssembler::ParseHeader(
-        parser_, std::move(buffer), /*grpc_metadata_batch=*/nullptr, args);
-
-    return (status.IsOk()) ? std::move(original_status) : std::move(status);
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Writing Header and Continuation State
-
-  // Called when a HEADER frame is received.
-  void UpdateState(const Http2HeaderFrame& frame) {
-    GRPC_CHECK(!incoming_header_in_progress_);
-    incoming_header_in_progress_ = !frame.end_headers;
-    incoming_header_stream_id_ = frame.stream_id;
-    incoming_header_end_stream_ = frame.end_stream;
-  }
-
-  // Called when a CONTINUATION frame is received.
-  void UpdateState(const Http2ContinuationFrame& frame) {
-    GRPC_CHECK(incoming_header_in_progress_);
-    GRPC_CHECK_EQ(frame.stream_id, incoming_header_stream_id_);
-    incoming_header_in_progress_ = !frame.end_headers;
-  }
-
-  //////////////////////////////////////////////////////////////////////////////
-  // Reading Header and Continuation State
-
-  // Returns true if we are in the middle of receiving a header block
-  // (i.e., HEADERS without END_HEADERS was received, and we are waiting for
-  // CONTINUATION frames).
-  bool IsWaitingForContinuationFrame() const {
-    return incoming_header_in_progress_;
-  }
-
-  // Returns true if end_stream was set in the received header.
-  bool HeaderHasEndStream() const { return incoming_header_end_stream_; }
-
-  // Returns stream id of stream for which headers are being received.
-  uint32_t GetStreamId() const { return incoming_header_stream_id_; }
-
-  // A gRPC server is permitted to send both initial metadata and trailing
-  // metadata where initial metadata is optional.
-  // A gRPC C++ client is permitted to send only initial metadata.
-  // However, other gRPC Client implementations may send trailing metadata too.
-  // So we allow only a maximum of 2 metadata per streams.
-  bool DidReceiveDuplicateMetadata(
-      const bool did_receive_initial_metadata,
-      const bool did_receive_trailing_metadata) const {
-    const bool is_duplicate_initial_metadata =
-        !incoming_header_end_stream_ && did_receive_initial_metadata;
-    const bool is_duplicate_trailing_metadata =
-        incoming_header_end_stream_ && did_receive_trailing_metadata;
-    return is_duplicate_initial_metadata || is_duplicate_trailing_metadata;
-  }
-
-  std::string DebugString() const {
-    return absl::StrCat(
-        "{ incoming_header_in_progress : ",
-        incoming_header_in_progress_ ? "true" : "false",
-        ", incoming_header_end_stream : ",
-        incoming_header_end_stream_ ? "true" : "false",
-        ", incoming_header_stream_id : ", incoming_header_stream_id_, "}");
-  }
-
- private:
-  // Initialized only once at the time of transport creation.
-  // Should remain constant for the lifetime of the transport.
-  const Slice peer_string_;
-  const bool is_client_;
-
-  bool incoming_header_in_progress_ = false;
-  bool incoming_header_end_stream_ = false;
-  uint32_t incoming_header_stream_id_ = 0;
-  uint32_t max_header_list_size_soft_limit_ =
-      DEFAULT_MAX_HEADER_LIST_SIZE_SOFT_LIMIT;
-  HPackParser parser_;
-};
-
-}  // namespace http2
-}  // namespace grpc_core
-
-#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INCOMING_METADATA_TRACKER_H

data/third_party/upb/upb/message/internal/tagged_ptr.h

@@ -1,56 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2023 Google LLC.  All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file or at
-// https://developers.google.com/open-source/licenses/bsd
-
-#ifndef UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_
-#define UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_
-
-#include <stdint.h>
-
-#include "upb/message/internal/message.h"
-
-// Must be last.
-#include "upb/port/def.inc"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Internal-only because empty messages cannot be created by the user.
-UPB_INLINE uintptr_t
-UPB_PRIVATE(_upb_TaggedMessagePtr_Pack)(struct upb_Message* ptr, bool empty) {
-  UPB_ASSERT(((uintptr_t)ptr & 1) == 0);
-  return (uintptr_t)ptr | (empty ? 1 : 0);
-}
-
-UPB_API_INLINE bool upb_TaggedMessagePtr_IsEmpty(uintptr_t ptr) {
-  return ptr & 1;
-}
-
-UPB_INLINE struct upb_Message* UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)(
-    uintptr_t ptr) {
-  return (struct upb_Message*)(ptr & ~(uintptr_t)1);
-}
-
-UPB_API_INLINE struct upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage(
-    uintptr_t ptr) {
-  UPB_ASSERT(!upb_TaggedMessagePtr_IsEmpty(ptr));
-  return UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)(ptr);
-}
-
-UPB_INLINE struct upb_Message* UPB_PRIVATE(
-    _upb_TaggedMessagePtr_GetEmptyMessage)(uintptr_t ptr) {
-  UPB_ASSERT(upb_TaggedMessagePtr_IsEmpty(ptr));
-  return UPB_PRIVATE(_upb_TaggedMessagePtr_GetMessage)(ptr);
-}
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#include "upb/port/undef.inc"
-
-#endif /* UPB_MINI_TABLE_INTERNAL_TAGGED_PTR_H_ */

data/third_party/upb/upb/message/tagged_ptr.h

@@ -1,48 +0,0 @@
-// Protocol Buffers - Google's data interchange format
-// Copyright 2023 Google LLC.  All rights reserved.
-//
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file or at
-// https://developers.google.com/open-source/licenses/bsd
-
-#ifndef UPB_MINI_TABLE_TAGGED_PTR_H_
-#define UPB_MINI_TABLE_TAGGED_PTR_H_
-
-#include <stdint.h>
-
-#include "upb/message/internal/tagged_ptr.h"
-#include "upb/message/message.h"
-
-// Must be last.
-#include "upb/port/def.inc"
-
-// When a upb_Message* is stored in a message, array, or map, it is stored in a
-// tagged form. If the tag bit is set, the referenced upb_Message is of type
-// _kUpb_MiniTable_Empty (a sentinel message type with no fields) instead of
-// that field's true message type. This forms the basis of what we call
-// "dynamic tree shaking."
-//
-// See the documentation for kUpb_DecodeOption_ExperimentalAllowUnlinked for
-// more information.
-
-typedef uintptr_t upb_TaggedMessagePtr;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Users who enable unlinked sub-messages must use this to test whether a
-// message is empty before accessing it. If a message is empty, it must be
-// first promoted using the interfaces in message/promote.h.
-UPB_API_INLINE bool upb_TaggedMessagePtr_IsEmpty(upb_TaggedMessagePtr ptr);
-
-UPB_API_INLINE upb_Message* upb_TaggedMessagePtr_GetNonEmptyMessage(
-    upb_TaggedMessagePtr ptr);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#include "upb/port/undef.inc"
-
-#endif /* UPB_MINI_TABLE_TAGGED_PTR_H_ */