grpc 1.72.0 → 1.73.0

data/src/core/handshaker/security/secure_endpoint.h

@@ -24,14 +24,31 @@
 #include <grpc/support/port_platform.h>
 #include <stddef.h>
 
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/util/orphanable.h"
 
+// Integer. The size of a read at which the secure endpoint will offload
+// decryption to an event engine thread.
+#define GRPC_ARG_DECRYPTION_OFFLOAD_THRESHOLD \
+  "grpc.secure_endpoint.decryption_offload_threshold"
+#define GRPC_ARG_ENCRYPTION_OFFLOAD_THRESHOLD \
+  "grpc.secure_endpoint.encryption_offload_threshold"
+#define GRPC_ARG_ENCRYPTION_OFFLOAD_MAX_BUFFERED_WRITES \
+  "grpc.secure_endpoint.encryption_offload_max_buffered_writes"
+
 // Takes ownership of protector, zero_copy_protector, and to_wrap, and refs
 // leftover_slices. If zero_copy_protector is not NULL, protector will never be
 // used.
 grpc_core::OrphanablePtr<grpc_endpoint> grpc_secure_endpoint_create(
+    struct tsi_frame_protector* protector,
+    struct tsi_zero_copy_grpc_protector* zero_copy_protector,
+    grpc_core::OrphanablePtr<grpc_endpoint> to_wrap,
+    grpc_slice* leftover_slices, size_t leftover_nslices,
+    const grpc_core::ChannelArgs& channel_args);
+
+grpc_core::OrphanablePtr<grpc_endpoint> grpc_legacy_secure_endpoint_create(
     struct tsi_frame_protector* protector,
     struct tsi_zero_copy_grpc_protector* zero_copy_protector,
     grpc_core::OrphanablePtr<grpc_endpoint> to_wrap,

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

@@ -281,13 +281,13 @@ void SecurityHandshaker::OnPeerCheckedFn(grpc_error_handle error) {
       grpc_slice slice = grpc_slice_from_copied_buffer(
           reinterpret_cast<const char*>(unused_bytes), unused_bytes_size);
       args_->endpoint = grpc_secure_endpoint_create(
-          protector, zero_copy_protector, std::move(args_->endpoint), &slice,
-          args_->args.ToC().get(), 1);
+          protector, zero_copy_protector, std::move(args_->endpoint), &slice, 1,
+          args_->args);
       CSliceUnref(slice);
     } else {
       args_->endpoint = grpc_secure_endpoint_create(
           protector, zero_copy_protector, std::move(args_->endpoint), nullptr,
-          args_->args.ToC().get(), 0);
+          0, args_->args);
     }
   } else if (unused_bytes_size > 0) {
     // Not wrapping the endpoint, so just pass along unused bytes.

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -73,7 +73,7 @@ static absl::StatusOr<std::string> grpc_sockaddr_to_uri_unix_if_possible(
     path = unix_addr->sun_path;
   }
   absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
-      std::move(scheme), /*authority=*/"", std::move(path),
+      std::move(scheme), /*user_info=*/"", /*host_port=*/"", std::move(path),
       /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
@@ -124,9 +124,9 @@ int grpc_sockaddr_is_v4mapped(const grpc_resolved_address* resolved_addr,
       if (resolved_addr4_out != nullptr) {
         // Normalize ::ffff:0.0.0.0/96 to IPv4.
         memset(resolved_addr4_out, 0, sizeof(*resolved_addr4_out));
-        addr4_out->sin_family = GRPC_AF_INET;
         // s6_addr32 would be nice, but it's non-standard.
         memcpy(&addr4_out->sin_addr, &addr6->sin6_addr.s6_addr[12], 4);
+        addr4_out->sin_family = GRPC_AF_INET;
         addr4_out->sin_port = addr6->sin6_port;
         resolved_addr4_out->len =
             static_cast<socklen_t>(sizeof(grpc_sockaddr_in));
@@ -318,9 +318,9 @@ absl::StatusOr<std::string> grpc_sockaddr_to_uri(
 
   auto path = grpc_sockaddr_to_string(resolved_addr, false /* normalize */);
   if (!path.ok()) return path;
-  absl::StatusOr<grpc_core::URI> uri =
-      grpc_core::URI::Create(scheme, /*authority=*/"", std::move(path.value()),
-                             /*query_parameter_pairs=*/{}, /*fragment=*/"");
+  absl::StatusOr<grpc_core::URI> uri = grpc_core::URI::Create(
+      scheme, /*user_info=*/"", /*host_port=*/"", std::move(path.value()),
+      /*query_parameter_pairs=*/{}, /*fragment=*/"");
   if (!uri.ok()) return uri.status();
   return uri->ToString();
 }

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

@@ -570,6 +570,10 @@ class ChannelArgs {
   bool operator<(const ChannelArgs& other) const;
   bool operator==(const ChannelArgs& other) const;
 
+  friend int QsortCompare(const ChannelArgs& lhs, const ChannelArgs& rhs) {
+    return QsortCompare(lhs.args_, rhs.args_);
+  }
+
   // Helpers for commonly accessed things
 
   bool WantMinimalStack() const;

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

@@ -171,14 +171,43 @@ grpc_error_handle grpc_channel_stack_init(
         grpc_channel_stack_size(filters, filter_count));
 
   stack->call_stack_size = call_size;
+  stack->channelz_data_source.Init(
+      channel_args.GetObjectRef<grpc_core::channelz::BaseNode>());
   return first_error;
 }
 
+void grpc_channel_stack::ChannelStackDataSource::AddData(
+    grpc_core::channelz::DataSink& sink) {
+  using grpc_core::Json;
+  Json::Object output;
+  output["type"] = Json::FromString("v1");
+  Json::Array elements;
+  grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
+      reinterpret_cast<char*>(this) -
+      offsetof(grpc_channel_stack, channelz_data_source));
+  output["call_stack_size"] = Json::FromNumber(channel_stack->call_stack_size);
+  grpc_channel_element* elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
+  elements.reserve(channel_stack->count);
+  for (size_t i = 0; i < channel_stack->count; i++) {
+    grpc_channel_element& e = elems[i];
+    Json::Object element;
+    element["type"] = Json::FromString(std::string(e.filter->name.name()));
+    element["call_data_size"] = Json::FromNumber(e.filter->sizeof_call_data);
+    element["channel_data_size"] =
+        Json::FromNumber(e.filter->sizeof_channel_data);
+    elements.emplace_back(Json::FromObject(std::move(element)));
+  }
+  output["elements"] = Json::FromArray(std::move(elements));
+  sink.AddAdditionalInfo("channelStack", std::move(output));
+}
+
 void grpc_channel_stack_destroy(grpc_channel_stack* stack) {
   grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
   size_t count = stack->count;
   size_t i;
 
+  stack->channelz_data_source.Destroy();
+
   // destroy per-filter data
   for (i = 0; i < count; i++) {
     channel_elems[i].filter->destroy_channel_elem(&channel_elems[i]);

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

@@ -188,6 +188,15 @@ struct grpc_channel_stack {
   // should look like and this can go.
   grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
+  class ChannelStackDataSource final : public grpc_core::channelz::DataSource {
+   public:
+    using grpc_core::channelz::DataSource::DataSource;
+    ~ChannelStackDataSource() { ResetDataSource(); }
+    void AddData(grpc_core::channelz::DataSink& sink) override;
+  };
+
+  grpc_core::ManualConstructor<ChannelStackDataSource> channelz_data_source;
+
   grpc_core::ManualConstructor<
       std::shared_ptr<grpc_event_engine::experimental::EventEngine>>
       event_engine;