grpc 1.83.1 → 1.84.0

data/src/core/filter/ext_proc/ext_proc_messages.h

@@ -0,0 +1,297 @@
+//
+// Copyright 2026 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_FILTER_EXT_PROC_EXT_PROC_MESSAGES_H
+#define GRPC_SRC_CORE_FILTER_EXT_PROC_EXT_PROC_MESSAGES_H
+
+#include <grpc/status.h>
+
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "google/protobuf/struct.upb.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/util/matchers.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "upb/mem/arena.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+// Data structures and message creation/parsing helpers for the xDS External
+// Processing (ext_proc) filter in gRPC, as specified in gRFC A93
+// (https://github.com/grpc/proposal/blob/master/A93-xds-ext-proc.md).
+
+namespace grpc_core {
+
+// Represents the processing mode configuration for an external processor
+// stream, corresponding to
+// envoy.extensions.filters.http.ext_proc.v3.ProcessingMode in gRFC A93. Note:
+// In gRPC, when body processing is enabled (send_request_body /
+// send_response_body), it always operates in GRPC mode (deframed gRPC messages
+// sent one at a time).
+struct ExtProcProcessingMode {
+  bool send_request_headers = false;
+  bool send_response_headers = false;
+  bool send_response_trailers = false;
+  bool send_request_body = false;
+  bool send_response_body = false;
+
+  bool operator==(const ExtProcProcessingMode& other) const {
+    return send_request_headers == other.send_request_headers &&
+           send_response_headers == other.send_response_headers &&
+           send_response_trailers == other.send_response_trailers &&
+           send_request_body == other.send_request_body &&
+           send_response_body == other.send_response_body;
+  }
+
+  std::string ToString() const;
+};
+
+// Creates a serialized envoy.service.ext_proc.v3.ProcessingRequest containing a
+// HttpHeaders message for client request headers.
+//
+// Parameters:
+//  - arena: The upb arena used for memory allocation during proto creation and
+//  serialization.
+//  - metadata: The gRPC metadata batch containing the client request headers.
+//  - allowed_headers: List of string matchers specifying which headers are
+//  allowed to be forwarded.
+//  - disallowed_headers: List of string matchers specifying which headers must
+//  be excluded.
+//  - attributes: A protobuf Struct message containing request/connection
+//  attributes to include, or nullptr.
+//  - observability_mode: If true (observability mode in gRFC A93), indicates
+//  that the external processor should only observe traffic asynchronously
+//  without blocking or mutating the stream.
+//  - processing_mode: If present, populates the protocol_config field in the
+//  request (sent on the first message of a stream to configure desired
+//  processing modes as per gRFC A93).
+absl::StatusOr<std::string> CreateExtProcClientHeadersRequest(
+    upb_Arena* arena, grpc_metadata_batch* metadata,
+    const std::vector<StringMatcher>& allowed_headers,
+    const std::vector<StringMatcher>& disallowed_headers,
+    ::google_protobuf_Struct* attributes, bool observability_mode,
+    std::optional<ExtProcProcessingMode> processing_mode);
+
+// Creates a serialized envoy.service.ext_proc.v3.ProcessingRequest containing a
+// HttpHeaders message for server response headers.
+//
+// Parameters:
+//  - arena: The upb arena used for memory allocation during proto creation and
+//  serialization.
+//  - metadata: The gRPC metadata batch containing the server response headers.
+//  - allowed_headers: List of string matchers specifying which headers are
+//  allowed to be forwarded.
+//  - disallowed_headers: List of string matchers specifying which headers must
+//  be excluded.
+//  - attributes: A protobuf Struct message containing request/connection
+//  attributes to include, or nullptr.
+//  - observability_mode: If true (observability mode in gRFC A93), indicates
+//  that the external
+//    processor should only observe traffic asynchronously without blocking or
+//    mutating the stream.
+//  - processing_mode: If present, populates the protocol_config field in the
+//  request (sent on the
+//    first message of a stream to configure desired processing modes as per
+//    gRFC A93).
+//  - end_of_stream: If true, indicates that this header message is also the end
+//  of the HTTP/gRPC stream.
+absl::StatusOr<std::string> CreateExtProcServerHeadersRequest(
+    upb_Arena* arena, grpc_metadata_batch* metadata,
+    const std::vector<StringMatcher>& allowed_headers,
+    const std::vector<StringMatcher>& disallowed_headers,
+    ::google_protobuf_Struct* attributes, bool observability_mode,
+    std::optional<ExtProcProcessingMode> processing_mode, bool end_of_stream);
+
+// Creates a serialized envoy.service.ext_proc.v3.ProcessingRequest containing a
+// HttpBody message for a client request body payload chunk.
+//
+// Parameters:
+//  - arena: The upb arena used for memory allocation during proto creation and
+//  serialization.
+//  - body: The payload data chunk of the body. In GRPC mode (gRFC A93), this
+//  represents a complete, deframed gRPC message payload (not raw HTTP/2 DATA
+//  frames).
+//  - attributes: A protobuf Struct message containing request/connection
+//  attributes to include, or nullptr.
+//  - observability_mode: If true (observability mode in gRFC A93), indicates
+//  that the external processor should only observe traffic asynchronously
+//  without blocking or mutating the stream.
+//  - processing_mode: If present, populates the protocol_config field in the
+//  request (sent on the first message of a stream to configure desired
+//  processing modes as per gRFC A93).
+//  - end_of_stream: If true, indicates that this body chunk is the last message
+//  on the stream.
+//  - end_of_stream_without_message: If true, indicates end of stream with an
+//  empty body chunk.
+absl::StatusOr<std::string> CreateExtProcClientBodyRequest(
+    upb_Arena* arena, absl::string_view body,
+    ::google_protobuf_Struct* attributes, bool observability_mode,
+    std::optional<ExtProcProcessingMode> processing_mode, bool end_of_stream,
+    bool end_of_stream_without_message);
+
+// Creates a serialized envoy.service.ext_proc.v3.ProcessingRequest containing a
+// HttpBody message for a server response body payload chunk.
+//
+// Parameters:
+//  - arena: The upb arena used for memory allocation during proto creation and
+//  serialization.
+//  - body: The payload data chunk of the body. In GRPC mode (gRFC A93), this
+//  represents a complete, deframed gRPC message payload (not raw HTTP/2 DATA
+//  frames).
+//  - attributes: A protobuf Struct message containing request/connection
+//  attributes to include, or nullptr.
+//  - observability_mode: If true (observability mode in gRFC A93), indicates
+//  that the external processor should only observe traffic asynchronously
+//  without blocking or mutating the stream.
+//  - processing_mode: If present, populates the protocol_config field in the
+//  request (sent on the first message of a stream to configure desired
+//  processing modes as per gRFC A93).
+absl::StatusOr<std::string> CreateExtProcServerBodyRequest(
+    upb_Arena* arena, absl::string_view body,
+    ::google_protobuf_Struct* attributes, bool observability_mode,
+    std::optional<ExtProcProcessingMode> processing_mode);
+
+// Creates a serialized envoy.service.ext_proc.v3.ProcessingRequest containing a
+// HttpTrailers message for server response trailers.
+//
+// Parameters:
+//  - arena: The upb arena used for memory allocation during proto creation and
+//  serialization.
+//  - trailers: The gRPC metadata batch containing the server response trailers.
+//  - allowed_headers: List of string matchers specifying which trailer keys are
+//  allowed to be forwarded.
+//  - disallowed_headers: List of string matchers specifying which trailer keys
+//  must be excluded.
+//  - attributes: A protobuf Struct message containing request/connection
+//  attributes to include, or nullptr.
+//  - observability_mode: If true (observability mode in gRFC A93), indicates
+//  that the external processor should only observe traffic asynchronously
+//  without blocking or mutating the stream.
+//  - processing_mode: If present, populates the protocol_config field in the
+//  request (sent on the first message of a stream to configure desired
+//  processing modes as per gRFC A93).
+absl::StatusOr<std::string> CreateExtProcServerTrailersRequest(
+    upb_Arena* arena, grpc_metadata_batch* trailers,
+    const std::vector<StringMatcher>& allowed_headers,
+    const std::vector<StringMatcher>& disallowed_headers,
+    ::google_protobuf_Struct* attributes, bool observability_mode,
+    std::optional<ExtProcProcessingMode> processing_mode);
+
+// Creates a protobuf Struct message (::google_protobuf_Struct*) containing
+// connection and request metadata attributes requested by the external
+// processor configuration.
+//
+// Parameters:
+//  - arena: The upb arena used for allocating the Struct message and its
+//  fields.
+//  - requested_attributes: A list of attribute names (e.g., "request.path",
+//  "request.method", "request.host") to extract and populate.
+//  - metadata: The gRPC metadata batch from which attribute values (like
+//  authority, method, path, or headers) are extracted.
+//
+// Returns:
+//  A pointer to the newly created ::google_protobuf_Struct message on the
+//  arena, or nullptr if no requested attributes were matched or populated.
+::google_protobuf_Struct* CreateExtProcAttributesProtoStruct(
+    upb_Arena* arena, const std::vector<std::string>& requested_attributes,
+    const grpc_metadata_batch& metadata);
+
+// Represents the parsed response from an external processor, corresponding to
+// envoy.service.ext_proc.v3.ProcessingResponse in gRFC A93.
+struct ExtProcResponse {
+  struct HeaderMutation {
+    // Headers to set or append.
+    std::vector<XdsHeaderValueOption> set_headers;
+    // Header keys to remove.
+    std::vector<std::string> remove_headers;
+  };
+
+  // Represents body mutations returned by the external processor.
+  // In GRPC mode (gRFC A93), the body string must be a complete deframed gRPC
+  // message.
+  struct BodyMutation {
+    // The new body content.
+    std::string body;
+    // If true, indicates the end of the stream.
+    bool end_of_stream = false;
+    // If true, indicates the end of the stream without a message.
+    bool end_of_stream_without_message = false;
+  };
+
+  struct RequestHeaders {
+    HeaderMutation mutation;
+  };
+
+  struct ResponseHeaders {
+    HeaderMutation mutation;
+  };
+
+  struct ResponseTrailers {
+    HeaderMutation mutation;
+  };
+
+  struct RequestBody {
+    BodyMutation mutation;
+  };
+
+  struct ResponseBody {
+    BodyMutation mutation;
+  };
+
+  struct ImmediateResponse {
+    // The gRPC status code to return.
+    grpc_status_code status = GRPC_STATUS_UNKNOWN;
+    // error message to return with.
+    std::string details;
+    // Headers to set in the response.
+    HeaderMutation header_mutation;
+  };
+
+  // The variant representing the actual response content.
+  // It can hold one of the mutation types or std::monostate if no response
+  // is set.
+  using ResponseValue =
+      std::variant<std::monostate, RequestHeaders, ResponseHeaders,
+                   ResponseTrailers, RequestBody, ResponseBody,
+                   ImmediateResponse>;
+
+  ResponseValue response;
+  // If true, indicates that the client request should be drained as specified
+  // in gRFC A93: the filter sends a half-close on the ext_proc stream and
+  // pauses data plane reading until the ext_proc server echoes remaining
+  // messages and terminates the stream with OK status.
+  bool request_drain = false;
+
+  // Parses a serialized envoy.service.ext_proc.v3.ProcessingResponse proto.
+  //
+  // Parameters:
+  //  - serialized_response: The raw string containing the protobuf-serialized
+  //  ProcessingResponse.
+  //
+  // Returns:
+  //  The parsed ExtProcResponse structure representing header/body/trailer
+  //  mutations or immediate responses, or an absl::Status error if
+  //  deserialization or validation fails.
+  static absl::StatusOr<ExtProcResponse> Parse(
+      absl::string_view serialized_response);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_FILTER_EXT_PROC_EXT_PROC_MESSAGES_H

data/src/core/filter/filter_args.h

@@ -23,6 +23,13 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/unique_type_name.h"
 
+// A boolean channel arg indicating whether we're using the v3 filter stack.
+#define GRPC_ARG_USE_V3_STACK "grpc.internal.use_v3_stack"
+
+// A boolean channel arg indicating whether the filter stack is for the
+// server side.
+#define GRPC_ARG_IS_SERVER_FILTER_STACK "grpc.internal.is_server_filter_stack"
+
 namespace grpc_core {
 
 // A base class for filter configs.
@@ -83,8 +90,8 @@ class FilterArgs {
   // 0 0 0 1 1 0 2.
   // This is useful for filters that need to store per-instance data in a
   // parallel data structure.
-  // TODO(roth): Remove this once server side is migrated to the new
-  // approach for handling xDS filter configs.
+  // TODO(roth): Remove this when removing the
+  // xds_server_filter_chain_per_route experiment.
   size_t instance_id() const {
     return Match(
         impl_,
@@ -103,11 +110,15 @@ class FilterArgs {
   struct ChannelStackBased {
     grpc_channel_stack* channel_stack;
     grpc_channel_element* channel_element;
+    // TODO(roth): Remove this when removing the
+    // xds_server_filter_chain_per_route experiment.
     size_t (*channel_stack_filter_instance_number)(grpc_channel_stack*,
                                                    grpc_channel_element*);
   };
 
   struct V3Based {
+    // TODO(roth): Remove this when removing the
+    // xds_server_filter_chain_per_route experiment.
     size_t instance_id;
   };
 

data/src/core/handshaker/http_connect/http_proxy_mapper.cc

@@ -33,7 +33,6 @@
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/util/env.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/host_port.h"
@@ -55,6 +54,8 @@
 namespace grpc_core {
 namespace {
 
+constexpr int kDefaultSecurePortInt = 443;
+
 bool ServerInCIDRRange(const grpc_resolved_address& server_address,
                        absl::string_view cidr_range) {
   std::pair<absl::string_view, absl::string_view> possible_cidr =
@@ -76,8 +77,34 @@ bool ServerInCIDRRange(const grpc_resolved_address& server_address,
 }
 
 bool ExactMatchOrSubdomain(absl::string_view host_name,
-                           absl::string_view host_name_or_domain) {
-  return absl::EndsWithIgnoreCase(host_name, host_name_or_domain);
+                           absl::string_view no_proxy_entry) {
+  // Remove surrounding whitespace.
+  no_proxy_entry = absl::StripAsciiWhitespace(no_proxy_entry);
+
+  // Strip a leading dot if present (e.g. ".example.com" -> "example.com").
+  // A leading dot is optional notation; both "example.com" and
+  // ".example.com" match the domain itself and all of its subdomains.
+  if (!no_proxy_entry.empty() && no_proxy_entry[0] == '.') {
+    no_proxy_entry = no_proxy_entry.substr(1);
+  }
+
+  if (no_proxy_entry.empty()) return false;
+
+  // Exact match (case-insensitive).
+  if (absl::EqualsIgnoreCase(host_name, no_proxy_entry)) {
+    return true;
+  }
+
+  // Boundary-aware subdomain match: host_name must end with
+  // ".<no_proxy_entry>". Prevents "notexample.com" from matching
+  // "example.com", while "test.example.com" still matches.
+  if (host_name.size() > no_proxy_entry.size() &&
+      absl::EndsWithIgnoreCase(host_name, no_proxy_entry) &&
+      host_name[host_name.size() - no_proxy_entry.size() - 1] == '.') {
+    return true;
+  }
+
+  return false;
 }
 
 // Parses the list of host names, addresses or subnet masks and returns true if

data/src/core/handshaker/security/security_handshaker.cc

@@ -92,7 +92,7 @@ class SecurityHandshaker : public Handshaker {
       tsi_result result, const unsigned char* bytes_to_send,
       size_t bytes_to_send_size, tsi_handshaker_result* handshaker_result)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  void HandshakeFailedLocked(absl::Status error)
+  void HandshakeFailedLocked(absl::Status error, bool peer_closed = false)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   void Finish(absl::Status status);
 
@@ -166,14 +166,15 @@ size_t SecurityHandshaker::MoveReadBufferIntoHandshakeBuffer() {
 
 // If the handshake failed or we're shutting down, clean up and invoke the
 // callback with the error.
-void SecurityHandshaker::HandshakeFailedLocked(absl::Status error) {
+void SecurityHandshaker::HandshakeFailedLocked(absl::Status error,
+                                               bool peer_closed) {
   if (error.ok()) {
     // If we were shut down after the handshake succeeded but before an
     // endpoint callback was invoked, we need to generate our own error.
     error = GRPC_ERROR_CREATE("Handshaker shutdown");
   }
   if (!is_shutdown_) {
-    tsi_handshaker_shutdown(handshaker_);
+    tsi_handshaker_shutdown(handshaker_, peer_closed);
     // Set shutdown to true so that subsequent calls to
     // security_handshaker_shutdown() do nothing.
     is_shutdown_ = true;
@@ -457,7 +458,8 @@ void SecurityHandshaker::OnHandshakeDataReceivedFromPeerFn(absl::Status error) {
   MutexLock lock(&mu_);
   if (!error.ok() || is_shutdown_) {
     HandshakeFailedLocked(
-        GRPC_ERROR_CREATE_REFERENCING("Handshake read failed", &error, 1));
+        GRPC_ERROR_CREATE_REFERENCING("Handshake read failed", &error, 1),
+        /*peer_closed=*/true);
     return;
   }
   // Copy all slices received.
@@ -488,7 +490,8 @@ void SecurityHandshaker::OnHandshakeDataSentToPeerFn(absl::Status error) {
   MutexLock lock(&mu_);
   if (!error.ok() || is_shutdown_) {
     HandshakeFailedLocked(
-        GRPC_ERROR_CREATE_REFERENCING("Handshake write failed", &error, 1));
+        GRPC_ERROR_CREATE_REFERENCING("Handshake write failed", &error, 1),
+        /*peer_closed=*/true);
     return;
   }
   // We may be done.
@@ -518,7 +521,7 @@ void SecurityHandshaker::Shutdown(grpc_error_handle error) {
   if (!is_shutdown_) {
     is_shutdown_ = true;
     connector_->cancel_check_peer(on_peer_checked_, std::move(error));
-    tsi_handshaker_shutdown(handshaker_);
+    tsi_handshaker_shutdown(handshaker_, /*peer_closed=*/false);
     args_->endpoint.reset();
   }
 }

data/src/core/lib/channel/channel_stack.cc

@@ -307,6 +307,9 @@ void grpc_channel_next_get_info(grpc_channel_element* elem,
 
 void grpc_channel_next_op(grpc_channel_element* elem, grpc_transport_op* op) {
   grpc_channel_element* next_elem = elem + 1;
+  GRPC_TRACE_LOG(channel, INFO)
+      << "TRANSPORT OP[" << elem->filter->name << ":" << elem
+      << "]: " << grpc_transport_op_string(op);
   next_elem->filter->start_transport_op(next_elem, op);
 }
 

data/src/core/lib/channel/channel_stack.h

@@ -257,6 +257,8 @@ grpc_channel_element* grpc_channel_stack_last_element(
 // A utility function for a filter to determine how many other instances
 // of the same filter exist above it in the same stack.  Intended to be
 // used in the filter's init_channel_elem() method.
+// TODO(roth): Remove this when removing the
+// xds_server_filter_chain_per_route experiment.
 size_t grpc_channel_stack_filter_instance_number(
     grpc_channel_stack* channel_stack, grpc_channel_element* elem);
 

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -75,8 +75,7 @@ ChannelStackBuilderImpl::Build() {
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);
     gpr_free(channel_stack);
-    auto status = grpc_error_to_absl_status(error);
-    return status;
+    return error;
   }
 
   // run post-initialization functions