grpc 1.71.0 → 1.74.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

@@ -54,11 +54,11 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/security/context/security_context.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/transport/auth_context.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -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.
@@ -373,13 +373,16 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
     outgoing_.Clear();
     outgoing_.Append(Slice::FromCopiedBuffer(
         reinterpret_cast<const char*>(bytes_to_send), bytes_to_send_size));
+    grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs
+        write_args;
+    write_args.set_max_frame_size(INT_MAX);
     grpc_endpoint_write(
         args_->endpoint.get(), outgoing_.c_slice_buffer(),
         NewClosure(
             [self = RefAsSubclass<SecurityHandshaker>()](absl::Status status) {
               self->OnHandshakeDataSentToPeerFnScheduler(std::move(status));
             }),
-        nullptr, /*max_frame_size=*/INT_MAX);
+        std::move(write_args));
   } else if (handshaker_result == nullptr) {
     // There is nothing to send, but need to read from peer.
     grpc_endpoint_read(

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

@@ -24,9 +24,9 @@
 
 #include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/security_connector.h"
 #include "src/core/handshaker/handshaker.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/security/security_connector/security_connector.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
 

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -119,11 +119,17 @@ void TCPConnectHandshaker::Shutdown(absl::Status /*error*/) {
 void TCPConnectHandshaker::DoHandshake(
     HandshakerArgs* args,
     absl::AnyInvocable<void(absl::Status)> on_handshake_done) {
+  // If the endpoint already exists, skip the TCP connection step.
+  // In this case, the handshaker becomes a no-op, it simply completes the
+  // handshake successfully without performing any action.
+  if (args->endpoint != nullptr) {
+    InvokeOnHandshakeDone(args, std::move(on_handshake_done), absl::OkStatus());
+    return;
+  }
   {
     MutexLock lock(&mu_);
     on_handshake_done_ = std::move(on_handshake_done);
   }
-  CHECK_EQ(args->endpoint.get(), nullptr);
   args_ = args;
   absl::string_view resolved_address_text =
       args->args.GetString(GRPC_ARG_TCP_HANDSHAKER_RESOLVED_ADDRESS).value();

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.cc

@@ -291,6 +291,21 @@ absl::string_view ChannelArgs::Value::ToString(
   return backing_strings.back();
 }
 
+channelz::PropertyList ChannelArgs::ToPropertyList() const {
+  channelz::PropertyList result;
+  args_.ForEach(
+      [&result](const RefCountedStringValue& key, const Value& value) {
+        if (auto i = value.GetIfInt(); i.has_value()) {
+          result.Set(key.as_string_view(), *i);
+        } else if (auto s = value.GetIfString(); s != nullptr) {
+          result.Set(key.as_string_view(), s->as_string_view());
+        } else if (auto p = value.GetIfPointer(); p != nullptr) {
+          result.Set(key.as_string_view(), "POINTER");
+        }
+      });
+  return result;
+}
+
 std::string ChannelArgs::ToString() const {
   std::vector<absl::string_view> strings;
   std::list<std::string> backing_strings;

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

@@ -35,6 +35,7 @@
 
 #include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/util/avl.h"
 #include "src/core/util/debug_location.h"
@@ -91,6 +92,31 @@ struct IsRawPointerTagged<T,
                           absl::void_t<typename T::RawPointerChannelArgTag>> {
   static constexpr bool kValue = true;
 };
+
+// Define a check for shared_ptr supported types, which must extend
+// enable_shared_from_this.
+template <typename T>
+struct SupportedSharedPtrType
+    : std::integral_constant<
+          bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
+template <>
+struct SupportedSharedPtrType<grpc_event_engine::experimental::EventEngine>
+    : std::true_type {};
+
+// Specialization for shared_ptr
+// Incurs an allocation because shared_ptr.release is not a thing.
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+template <typename T>
+struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+template <typename T, typename = void>
+struct has_channel_args_compare : std::false_type {};
+template <typename T>
+struct has_channel_args_compare<
+    T, absl::void_t<decltype(T::ChannelArgsCompare(std::declval<const T*>(),
+                                                   std::declval<const T*>()))>>
+    : std::true_type {};
 }  // namespace channel_args_detail
 
 // Specialization for ref-counted pointers.
@@ -133,25 +159,9 @@ struct ChannelArgTypeTraits<
   };
 };
 
-// Define a check for shared_ptr supported types, which must extend
-// enable_shared_from_this.
-template <typename T>
-struct SupportedSharedPtrType
-    : std::integral_constant<
-          bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
-template <>
-struct SupportedSharedPtrType<grpc_event_engine::experimental::EventEngine>
-    : std::true_type {};
-
-// Specialization for shared_ptr
-// Incurs an allocation because shared_ptr.release is not a thing.
 template <typename T>
-struct is_shared_ptr : std::false_type {};
-template <typename T>
-struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
-template <typename T>
-struct ChannelArgTypeTraits<T,
-                            absl::enable_if_t<is_shared_ptr<T>::value, void>> {
+struct ChannelArgTypeTraits<
+    T, absl::enable_if_t<channel_args_detail::is_shared_ptr<T>::value, void>> {
   static void* TakeUnownedPointer(T* p) { return p; }
   static const grpc_arg_pointer_vtable* VTable() {
     static const grpc_arg_pointer_vtable tbl = {
@@ -161,8 +171,15 @@ struct ChannelArgTypeTraits<T,
         [](void* p) { delete static_cast<T*>(p); },
         // compare
         [](void* p1, void* p2) {
-          return QsortCompare(static_cast<const T*>(p1)->get(),
-                              static_cast<const T*>(p2)->get());
+          if constexpr (channel_args_detail::has_channel_args_compare<
+                            typename T::element_type>::value) {
+            return T::element_type::ChannelArgsCompare(
+                static_cast<const T*>(p1)->get(),
+                static_cast<const T*>(p2)->get());
+          } else {
+            return QsortCompare(static_cast<const T*>(p1)->get(),
+                                static_cast<const T*>(p2)->get());
+          }
         },
     };
     return &tbl;
@@ -209,9 +226,10 @@ struct GetObjectImpl;
 // std::shared_ptr implementation
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
-                             SupportedSharedPtrType<T>::value,
-                         void>> {
+    T,
+    absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
+                          channel_args_detail::SupportedSharedPtrType<T>::value,
+                      void>> {
   using Result = T*;
   using ReffedResult = std::shared_ptr<T>;
   using StoredType = std::shared_ptr<T>*;
@@ -232,9 +250,10 @@ struct GetObjectImpl<
 // RefCountedPtr
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<!ChannelArgPointerShouldBeConst<T>::kValue &&
-                             !SupportedSharedPtrType<T>::value,
-                         void>> {
+    T, absl::enable_if_t<
+           !ChannelArgPointerShouldBeConst<T>::kValue &&
+               !channel_args_detail::SupportedSharedPtrType<T>::value,
+           void>> {
   using Result = T*;
   using ReffedResult = RefCountedPtr<T>;
   using StoredType = Result;
@@ -252,9 +271,10 @@ struct GetObjectImpl<
 
 template <typename T>
 struct GetObjectImpl<
-    T, absl::enable_if_t<ChannelArgPointerShouldBeConst<T>::kValue &&
-                             !SupportedSharedPtrType<T>::value,
-                         void>> {
+    T, absl::enable_if_t<
+           ChannelArgPointerShouldBeConst<T>::kValue &&
+               !channel_args_detail::SupportedSharedPtrType<T>::value,
+           void>> {
   using Result = const T*;
   using ReffedResult = RefCountedPtr<const T>;
   using StoredType = Result;
@@ -469,7 +489,7 @@ class ChannelArgs {
           decltype(ChannelArgTypeTraits<std::shared_ptr<T>>::VTable())>::value,
       ChannelArgs>
   Set(absl::string_view name, std::shared_ptr<T> value) const {
-    static_assert(SupportedSharedPtrType<T>::value,
+    static_assert(channel_args_detail::SupportedSharedPtrType<T>::value,
                   "Type T must extend std::enable_shared_from_this to be added "
                   "into ChannelArgs as a shared_ptr<T>");
     auto* store_value = new std::shared_ptr<T>(value);
@@ -488,6 +508,8 @@ class ChannelArgs {
   GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
   bool Contains(absl::string_view name) const;
 
+  channelz::PropertyList ToPropertyList() const;
+
   GRPC_MUST_USE_RESULT ChannelArgs
   RemoveAllKeysWithPrefix(absl::string_view prefix) const;
 
@@ -551,6 +573,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

@@ -26,6 +26,7 @@
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "src/core/channelz/property_list.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_init.h"
@@ -114,8 +115,7 @@ grpc_error_handle grpc_channel_stack_init(
     int initial_refs, grpc_iomgr_cb_func destroy, void* destroy_arg,
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& channel_args, const char* name,
-    grpc_channel_stack* stack, const grpc_core::Blackboard* old_blackboard,
-    grpc_core::Blackboard* new_blackboard) {
+    grpc_channel_stack* stack, const grpc_core::Blackboard* blackboard) {
   if (GRPC_TRACE_FLAG_ENABLED(channel_stack)) {
     LOG(INFO) << "CHANNEL_STACK: init " << name;
     for (size_t i = 0; i < filter_count; i++) {
@@ -144,8 +144,7 @@ grpc_error_handle grpc_channel_stack_init(
                                              sizeof(grpc_channel_element));
 
   // init per-filter data
-  args.old_blackboard = old_blackboard;
-  args.new_blackboard = new_blackboard;
+  args.blackboard = blackboard;
   grpc_error_handle first_error;
   for (i = 0; i < filter_count; i++) {
     args.channel_stack = stack;
@@ -171,14 +170,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) {
+  grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
+      reinterpret_cast<char*>(this) -
+      offsetof(grpc_channel_stack, channelz_data_source));
+  sink.AddData(
+      "channel_stack",
+      grpc_core::channelz::PropertyList()
+          .Set("type", "v1")
+          .Set("elements", [channel_stack]() {
+            grpc_core::channelz::PropertyTable elements;
+            grpc_channel_element* elems =
+                CHANNEL_ELEMS_FROM_STACK(channel_stack);
+            for (size_t i = 0; i < channel_stack->count; i++) {
+              grpc_channel_element& e = elems[i];
+              elements.AppendRow(
+                  grpc_core::channelz::PropertyList()
+                      .Set("type", e.filter->name.name())
+                      .Set("call_data_size", e.filter->sizeof_call_data)
+                      .Set("channel_data_size", e.filter->sizeof_channel_data));
+            }
+            return elements;
+          }()));
+}
+
 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

@@ -75,13 +75,11 @@ struct grpc_channel_element_args {
   grpc_core::ChannelArgs channel_args;
   int is_first;
   int is_last;
-  const grpc_core::Blackboard* old_blackboard;
-  grpc_core::Blackboard* new_blackboard;
+  const grpc_core::Blackboard* blackboard;
 };
 struct grpc_call_element_args {
   grpc_call_stack* call_stack;
   const void* server_transport_data;
-  const grpc_slice& path;
   gpr_cycle_counter start_time;  // Note: not populated in subchannel stack.
   grpc_core::Timestamp deadline;
   grpc_core::Arena* arena;
@@ -189,6 +187,19 @@ 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:
+    explicit ChannelStackDataSource(
+        grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> node)
+        : DataSource(std::move(node)) {
+      SourceConstructed();
+    }
+    ~ChannelStackDataSource() { SourceDestructing(); }
+    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;
@@ -198,7 +209,7 @@ struct grpc_channel_stack {
   }
 
   grpc_core::ManualConstructor<
-      grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>
+      std::shared_ptr<grpc_core::GlobalStatsPluginRegistry::StatsPluginGroup>>
       stats_plugin_group;
 
   // Minimal infrastructure to act like a RefCounted thing without converting
@@ -261,8 +272,7 @@ grpc_error_handle grpc_channel_stack_init(
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_core::ChannelArgs& args, const char* name,
     grpc_channel_stack* stack,
-    const grpc_core::Blackboard* old_blackboard = nullptr,
-    grpc_core::Blackboard* new_blackboard = nullptr);
+    const grpc_core::Blackboard* blackboard = nullptr);
 // Destroy a channel stack
 void grpc_channel_stack_destroy(grpc_channel_stack* stack);
 

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

@@ -33,6 +33,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -43,7 +44,6 @@
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/sync.h"
@@ -75,7 +75,7 @@ ChannelStackBuilderImpl::Build() {
         gpr_free(stk);
       },
       channel_stack, stack.data(), stack.size(), channel_args(), name(),
-      channel_stack, old_blackboard_, new_blackboard_);
+      channel_stack, blackboard_);
 
   if (!error.ok()) {
     grpc_channel_stack_destroy(channel_stack);

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

@@ -35,11 +35,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
  public:
   using ChannelStackBuilder::ChannelStackBuilder;
 
-  void SetBlackboards(const Blackboard* old_blackboard,
-                      Blackboard* new_blackboard) {
-    old_blackboard_ = old_blackboard;
-    new_blackboard_ = new_blackboard;
-  }
+  void SetBlackboard(const Blackboard* blackboard) { blackboard_ = blackboard; }
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
@@ -49,8 +45,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
   absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
 
  private:
-  const Blackboard* old_blackboard_ = nullptr;
-  Blackboard* new_blackboard_ = nullptr;
+  const Blackboard* blackboard_ = nullptr;
 };
 
 }  // namespace grpc_core

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

@@ -34,8 +34,9 @@
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "src/core/call/call_finalization.h"
+#include "src/core/call/metadata_batch.h"
 #include "src/core/config/core_configuration.h"
-#include "src/core/lib/channel/call_finalization.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -67,7 +68,6 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/debug_location.h"