grpc 1.47.0 → 1.48.0.pre1

data/src/core/lib/surface/server.cc

@@ -707,7 +707,7 @@ void Server::FailCall(size_t cq_idx, RequestedCall* rc,
                       grpc_error_handle error) {
   *rc->call = nullptr;
   rc->initial_metadata->count = 0;
-  GPR_ASSERT(error != GRPC_ERROR_NONE);
+  GPR_ASSERT(!GRPC_ERROR_IS_NONE(error));
   grpc_cq_end_op(cqs_[cq_idx], rc->tag, error, DoneRequestEvent, rc,
                  &rc->completion);
 }
@@ -829,8 +829,13 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
   if (await_requests != nullptr) {
     await_requests->WaitForNotification();
   }
-  // Shutdown listeners.
+  StopListening();
+  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
+}
+
+void Server::StopListening() {
   for (auto& listener : listeners_) {
+    if (listener.listener == nullptr) continue;
     channelz::ListenSocketNode* channelz_listen_socket_node =
         listener.listener->channelz_listen_socket_node();
     if (channelz_node_ != nullptr && channelz_listen_socket_node != nullptr) {
@@ -842,7 +847,6 @@ void Server::ShutdownAndNotify(grpc_completion_queue* cq, void* tag) {
     listener.listener->SetOnDestroyDone(&listener.destroy_done);
     listener.listener.reset();
   }
-  broadcaster.BroadcastShutdown(/*send_goaway=*/true, GRPC_ERROR_NONE);
 }
 
 void Server::CancelAllCalls() {
@@ -1117,7 +1121,7 @@ void Server::ChannelData::AcceptStream(void* arg, grpc_transport* /*transport*/,
   grpc_call_element* elem =
       grpc_call_stack_element(grpc_call_get_call_stack(call), 0);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     GRPC_ERROR_UNREF(error);
     calld->FailCallCreation();
     return;
@@ -1269,7 +1273,7 @@ void Server::CallData::PublishNewRpc(void* arg, grpc_error_handle error) {
   auto* chand = static_cast<Server::ChannelData*>(call_elem->channel_data);
   RequestMatcherInterface* rm = calld->matcher_;
   Server* server = rm->server();
-  if (error != GRPC_ERROR_NONE || server->ShutdownCalled()) {
+  if (!GRPC_ERROR_IS_NONE(error) || server->ShutdownCalled()) {
     calld->state_.store(CallState::ZOMBIED, std::memory_order_relaxed);
     calld->KillZombie();
     return;
@@ -1333,7 +1337,7 @@ void Server::CallData::RecvInitialMetadataBatchComplete(
     void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   auto* calld = static_cast<Server::CallData*>(elem->call_data);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_DEBUG, "Failed call creation: %s",
             grpc_error_std_string(error).c_str());
     calld->FailCallCreation();
@@ -1368,9 +1372,11 @@ void Server::CallData::RecvInitialMetadataReady(void* arg,
                                                 grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   CallData* calld = static_cast<CallData*>(elem->call_data);
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     calld->path_ = calld->recv_initial_metadata_->Take(HttpPathMetadata());
-    calld->host_ = calld->recv_initial_metadata_->Take(HttpAuthorityMetadata());
+    auto* host =
+        calld->recv_initial_metadata_->get_pointer(HttpAuthorityMetadata());
+    if (host != nullptr) calld->host_.emplace(host->Ref());
   } else {
     (void)GRPC_ERROR_REF(error);
   }

data/src/core/lib/surface/server.h

@@ -43,8 +43,8 @@
 #include <grpc/support/log.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"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
@@ -64,6 +64,7 @@
 #include "src/core/lib/surface/completion_queue.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 struct grpc_server_config_fetcher;
 
@@ -194,6 +195,8 @@ class Server : public InternallyRefCounted<Server>,
   void ShutdownAndNotify(grpc_completion_queue* cq, void* tag)
       ABSL_LOCKS_EXCLUDED(mu_global_, mu_call_);
 
+  void StopListening();
+
   void CancelAllCalls() ABSL_LOCKS_EXCLUDED(mu_global_);
 
   void SendGoaways() ABSL_LOCKS_EXCLUDED(mu_global_, mu_call_);

data/src/core/lib/surface/validate_metadata.cc

@@ -60,7 +60,7 @@ static grpc_error_handle conforms_to(const grpc_slice& slice,
 }
 
 static int error2int(grpc_error_handle error) {
-  int r = (error == GRPC_ERROR_NONE);
+  int r = (GRPC_ERROR_IS_NONE(error));
   GRPC_ERROR_UNREF(error);
   return r;
 }

data/src/core/lib/surface/version.cc

@@ -23,6 +23,6 @@
 
 #include <grpc/grpc.h>
 
-const char* grpc_version_string(void) { return "25.0.0"; }
+const char* grpc_version_string(void) { return "26.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gridman"; }
+const char* grpc_g_stands_for(void) { return "garum"; }

data/src/core/lib/transport/error_utils.cc

@@ -22,13 +22,19 @@
 
 #include <stdint.h>
 
+#include <vector>
+
 #include "absl/strings/string_view.h"
 
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/iomgr/error_internal.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/transport/status_conversion.h"
 
+#ifndef GRPC_ERROR_IS_ABSEIL_STATUS
+#include "src/core/lib/iomgr/error_internal.h"
+#endif
+
 static grpc_error_handle recursively_find_error_with_field(
     grpc_error_handle error, grpc_error_ints which) {
   intptr_t unused;
@@ -40,7 +46,7 @@ static grpc_error_handle recursively_find_error_with_field(
   std::vector<absl::Status> children = grpc_core::StatusGetChildren(error);
   for (const absl::Status& child : children) {
     grpc_error_handle result = recursively_find_error_with_field(child, which);
-    if (result != GRPC_ERROR_NONE) return result;
+    if (!GRPC_ERROR_IS_NONE(result)) return result;
   }
 #else
   if (grpc_error_is_special(error)) return GRPC_ERROR_NONE;
@@ -64,7 +70,7 @@ void grpc_error_get_status(grpc_error_handle error,
                            grpc_http2_error_code* http_error,
                            const char** error_string) {
   // Fast path: We expect no error.
-  if (GPR_LIKELY(error == GRPC_ERROR_NONE)) {
+  if (GPR_LIKELY(GRPC_ERROR_IS_NONE(error))) {
     if (code != nullptr) *code = GRPC_STATUS_OK;
     if (message != nullptr) {
       // Normally, we call grpc_error_get_str(
@@ -87,7 +93,7 @@ void grpc_error_get_status(grpc_error_handle error,
   // until we find the first one that has a status code.
   grpc_error_handle found_error =
       recursively_find_error_with_field(error, GRPC_ERROR_INT_GRPC_STATUS);
-  if (found_error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(found_error)) {
     /// If no grpc-status exists, retry through the tree to find a http2 error
     /// code
     found_error =
@@ -96,7 +102,7 @@ void grpc_error_get_status(grpc_error_handle error,
 
   // If we found an error with a status code above, use that; otherwise,
   // fall back to using the parent error.
-  if (found_error == GRPC_ERROR_NONE) found_error = error;
+  if (GRPC_ERROR_IS_NONE(found_error)) found_error = error;
 
   grpc_status_code status = GRPC_STATUS_UNKNOWN;
   intptr_t integer;
@@ -125,8 +131,8 @@ void grpc_error_get_status(grpc_error_handle error,
       *http_error =
           grpc_status_to_http2_error(static_cast<grpc_status_code>(integer));
     } else {
-      *http_error = found_error == GRPC_ERROR_NONE ? GRPC_HTTP2_NO_ERROR
-                                                   : GRPC_HTTP2_INTERNAL_ERROR;
+      *http_error = GRPC_ERROR_IS_NONE(found_error) ? GRPC_HTTP2_NO_ERROR
+                                                    : GRPC_HTTP2_INTERNAL_ERROR;
     }
   }
 

data/src/core/lib/transport/handshaker.cc

@@ -100,9 +100,9 @@ bool HandshakeManager::CallNextHandshakerLocked(grpc_error_handle error) {
   // If we got an error or we've been shut down or we're exiting early or
   // we've finished the last handshaker, invoke the on_handshake_done
   // callback.  Otherwise, call the next handshaker.
-  if (error != GRPC_ERROR_NONE || is_shutdown_ || args_.exit_early ||
+  if (!GRPC_ERROR_IS_NONE(error) || is_shutdown_ || args_.exit_early ||
       index_ == handshakers_.size()) {
-    if (error == GRPC_ERROR_NONE && is_shutdown_) {
+    if (GRPC_ERROR_IS_NONE(error) && is_shutdown_) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("handshaker shutdown");
       // It is possible that the endpoint has already been destroyed by
       // a shutdown call while this callback was sitting on the ExecCtx
@@ -165,7 +165,7 @@ void HandshakeManager::CallNextHandshakerFn(void* arg,
 
 void HandshakeManager::OnTimeoutFn(void* arg, grpc_error_handle error) {
   auto* mgr = static_cast<HandshakeManager*>(arg);
-  if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled
+  if (GRPC_ERROR_IS_NONE(error)) {  // Timer fired, rather than being cancelled
     mgr->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
   }
   mgr->Unref();

data/src/core/lib/transport/http_connect_handshaker.cc

@@ -125,7 +125,7 @@ void HttpConnectHandshaker::CleanupArgsForFailureLocked() {
 // If the handshake failed or we're shutting down, clean up and invoke the
 // callback with the error.
 void HttpConnectHandshaker::HandshakeFailedLocked(grpc_error_handle error) {
-  if (error == GRPC_ERROR_NONE) {
+  if (GRPC_ERROR_IS_NONE(error)) {
     // If we were shut down after an endpoint operation succeeded but
     // before the endpoint callback was invoked, we need to generate our
     // own error.
@@ -164,7 +164,7 @@ void HttpConnectHandshaker::OnWriteDoneScheduler(void* arg,
 void HttpConnectHandshaker::OnWriteDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
     // If the write failed or we're shutting down, clean up and invoke the
     // callback with the error.
     handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
@@ -198,7 +198,7 @@ void HttpConnectHandshaker::OnReadDoneScheduler(void* arg,
 void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
   auto* handshaker = static_cast<HttpConnectHandshaker*>(arg);
   ReleasableMutexLock lock(&handshaker->mu_);
-  if (error != GRPC_ERROR_NONE || handshaker->is_shutdown_) {
+  if (!GRPC_ERROR_IS_NONE(error) || handshaker->is_shutdown_) {
     // If the read failed or we're shutting down, clean up and invoke the
     // callback with the error.
     handshaker->HandshakeFailedLocked(GRPC_ERROR_REF(error));
@@ -211,7 +211,7 @@ void HttpConnectHandshaker::OnReadDone(void* arg, grpc_error_handle error) {
       error = grpc_http_parser_parse(&handshaker->http_parser_,
                                      handshaker->args_->read_buffer->slices[i],
                                      &body_start_offset);
-      if (error != GRPC_ERROR_NONE) {
+      if (!GRPC_ERROR_IS_NONE(error)) {
         handshaker->HandshakeFailedLocked(error);
         goto done;
       }

data/src/core/lib/transport/tcp_connect_handshaker.cc

@@ -169,8 +169,8 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       static_cast<TCPConnectHandshaker*>(arg));
   {
     MutexLock lock(&self->mu_);
-    if (error != GRPC_ERROR_NONE || self->shutdown_) {
-      if (error == GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(error) || self->shutdown_) {
+      if (GRPC_ERROR_IS_NONE(error)) {
         error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("tcp handshaker shutdown");
       } else {
         error = GRPC_ERROR_REF(error);

data/src/core/lib/transport/transport.cc

@@ -161,9 +161,6 @@ void grpc_transport_stream_op_batch_finish_with_failure(
 void grpc_transport_stream_op_batch_queue_finish_with_failure(
     grpc_transport_stream_op_batch* batch, grpc_error_handle error,
     grpc_core::CallCombinerClosureList* closures) {
-  if (batch->send_message) {
-    batch->payload->send_message.send_message.reset();
-  }
   if (batch->cancel_stream) {
     GRPC_ERROR_UNREF(batch->payload->cancel_stream.cancel_error);
   }

data/src/core/lib/transport/transport.h

@@ -55,9 +55,10 @@
 #include "src/core/lib/promise/latch.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 struct grpc_transport_stream_op_batch_payload;
 
@@ -69,6 +70,17 @@ struct grpc_transport_stream_op_batch_payload;
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
+/** Internal bit flag for grpc_begin_message's \a flags signaling the use of
+ * compression for the message. (Does not apply for stream compression.) */
+#define GRPC_WRITE_INTERNAL_COMPRESS (0x80000000u)
+/** Internal bit flag for determining whether the message was compressed and had
+ * to be decompressed by the message_decompress filter. (Does not apply for
+ * stream compression.) */
+#define GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED (0x40000000u)
+/** Mask of all valid internal flags. */
+#define GRPC_WRITE_INTERNAL_USED_MASK \
+  (GRPC_WRITE_INTERNAL_COMPRESS | GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED)
+
 namespace grpc_core {
 // TODO(ctiller): eliminate once MetadataHandle is constructable directly.
 namespace promise_filter_detail {
@@ -156,8 +168,6 @@ using NextPromiseFactory =
 
 /* forward declarations */
 
-typedef struct grpc_transport grpc_transport;
-
 /* grpc_stream doesn't actually exist. It's used as a typesafe
    opaque pointer for whatever data the transport wants to track
    for a stream. */
@@ -332,12 +342,6 @@ struct grpc_transport_stream_op_batch_payload {
   explicit grpc_transport_stream_op_batch_payload(
       grpc_call_context_element* context)
       : context(context) {}
-  ~grpc_transport_stream_op_batch_payload() {
-    // We don't really own `send_message`, so release ownership and let the
-    // owner clean the data.
-    (void)send_message.send_message.release();
-  }
-
   struct {
     grpc_metadata_batch* send_initial_metadata = nullptr;
     /** Iff send_initial_metadata != NULL, flags associated with
@@ -366,7 +370,8 @@ struct grpc_transport_stream_op_batch_payload {
     // the op gets down to the transport) takes ownership.
     // The batch's on_complete will not be called until after the byte
     // stream is orphaned.
-    grpc_core::OrphanablePtr<grpc_core::ByteStream> send_message;
+    grpc_core::SliceBuffer* send_message;
+    uint32_t flags = 0;
     // Set by the transport if the stream has been closed for writes. If this
     // is set and send message op is present, we set the operation to be a
     // failure without sending a cancel OP down the stack. This is so that the
@@ -405,10 +410,11 @@ struct grpc_transport_stream_op_batch_payload {
   } recv_initial_metadata;
 
   struct {
-    // Will be set by the transport to point to the byte stream
-    // containing a received message.
-    // Will be NULL if trailing metadata is received instead of a message.
-    grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message = nullptr;
+    // Will be set by the transport to point to the byte stream containing a
+    // received message. Will be nullopt if trailing metadata is received
+    // instead of a message.
+    absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+    uint32_t* flags = nullptr;
     // Was this recv_message failed for reasons other than a clean end-of-stream
     bool* call_failed_before_recv_message = nullptr;
     /** Should be enqueued when one message is ready to be processed. */

data/src/core/lib/transport/transport_fwd.h

@@ -0,0 +1,20 @@
+// 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_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H
+#define GRPC_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H
+
+typedef struct grpc_transport grpc_transport;
+
+#endif  // GRPC_CORE_LIB_TRANSPORT_TRANSPORT_FWD_H

data/src/core/lib/transport/transport_impl.h

@@ -32,6 +32,7 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/transport_fwd.h"
 
 typedef struct grpc_transport_vtable {
   /* Memory required for a single stream element - this is allocated by upper

data/src/core/lib/transport/transport_op_string.cc

@@ -29,10 +29,11 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -53,10 +54,9 @@ std::string grpc_transport_stream_op_batch_string(
 
   if (op->send_message) {
     if (op->payload->send_message.send_message != nullptr) {
-      out.push_back(
-          absl::StrFormat(" SEND_MESSAGE:flags=0x%08x:len=%d",
-                          op->payload->send_message.send_message->flags(),
-                          op->payload->send_message.send_message->length()));
+      out.push_back(absl::StrFormat(
+          " SEND_MESSAGE:flags=0x%08x:len=%d", op->payload->send_message.flags,
+          op->payload->send_message.send_message->Length()));
     } else {
       // This can happen when we check a batch after the transport has
       // processed and cleared the send_message op.
@@ -107,14 +107,14 @@ std::string grpc_transport_op_string(grpc_transport_op* op) {
                                   op->stop_connectivity_watch));
   }
 
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(op->disconnect_with_error)) {
     out.push_back(absl::StrCat(
         " DISCONNECT:", grpc_error_std_string(op->disconnect_with_error)));
   }
 
-  if (op->goaway_error != GRPC_ERROR_NONE) {
-    out.push_back(absl::StrCat(" SEND_GOAWAY:%s",
-                               grpc_error_std_string(op->goaway_error)));
+  if (!GRPC_ERROR_IS_NONE(op->goaway_error)) {
+    out.push_back(
+        absl::StrCat(" SEND_GOAWAY:", grpc_error_std_string(op->goaway_error)));
   }
 
   if (op->set_accept_stream) {

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.cc

@@ -391,7 +391,7 @@ static void on_handshaker_service_resp_recv(void* arg,
     return;
   }
   bool success = true;
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     gpr_log(GPR_INFO,
             "ALTS handshaker on_handshaker_service_resp_recv error: %s",
             grpc_error_std_string(error).c_str());

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -174,7 +174,7 @@ static tsi_result alts_zero_copy_grpc_protector_protect(
 
 static tsi_result alts_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     gpr_log(GPR_ERROR,
@@ -215,6 +215,14 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
       return status;
     }
   }
+  if (min_progress_size != nullptr) {
+    if (protector->parsed_frame_size > kZeroCopyFrameLengthFieldSize) {
+      *min_progress_size =
+          protector->parsed_frame_size - protector->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }
 

data/src/core/tsi/fake_transport_security.cc

@@ -143,6 +143,11 @@ static uint32_t read_frame_size(const grpc_slice_buffer* sb) {
   return load32_little_endian(frame_size_buffer);
 }
 
+uint32_t tsi_fake_zero_copy_grpc_protector_next_frame_size(
+    const grpc_slice_buffer* protected_slices) {
+  return read_frame_size(protected_slices);
+}
+
 static void tsi_fake_frame_reset(tsi_fake_frame* frame, int needs_draining) {
   frame->offset = 0;
   frame->needs_draining = needs_draining;
@@ -432,7 +437,7 @@ static tsi_result fake_zero_copy_grpc_protector_protect(
 
 static tsi_result fake_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || unprotected_slices == nullptr ||
       protected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
@@ -462,6 +467,13 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
     impl->parsed_frame_size = 0;
     grpc_slice_buffer_reset_and_unref_internal(&impl->header_sb);
   }
+  if (min_progress_size != nullptr) {
+    if (impl->parsed_frame_size > TSI_FAKE_FRAME_HEADER_SIZE) {
+      *min_progress_size = impl->parsed_frame_size - impl->protected_sb.length;
+    } else {
+      *min_progress_size = 1;
+    }
+  }
   return TSI_OK;
 }
 

data/src/core/tsi/fake_transport_security.h

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/transport_security_interface.h"
 
 /* Value for the TSI_CERTIFICATE_TYPE_PEER_PROPERTY property for FAKE certs. */
@@ -44,4 +45,9 @@ tsi_frame_protector* tsi_create_fake_frame_protector(
 tsi_zero_copy_grpc_protector* tsi_create_fake_zero_copy_grpc_protector(
     size_t* max_protected_frame_size);
 
+/* Given a buffer containing slices encrypted by a fake_zero_copy_protector
+ * it parses these protected slices to return the total frame size of the first
+ * contained frame */
+uint32_t tsi_fake_zero_copy_grpc_protector_next_frame_size(
+    const grpc_slice_buffer* protected_slices);
 #endif /* GRPC_CORE_TSI_FAKE_TRANSPORT_SECURITY_H */

data/src/core/tsi/ssl_transport_security.cc

@@ -1566,7 +1566,7 @@ static tsi_result ssl_handshaker_write_output_buffer(tsi_handshaker* self,
                                                      size_t* bytes_written) {
   tsi_ssl_handshaker* impl = reinterpret_cast<tsi_ssl_handshaker*>(self);
   tsi_result status = TSI_OK;
-  int offset = *bytes_written;
+  size_t offset = *bytes_written;
   do {
     size_t to_send_size = impl->outgoing_bytes_buffer_size - offset;
     status = ssl_handshaker_get_bytes_to_send_to_peer(

data/src/core/tsi/transport_security_grpc.cc

@@ -51,13 +51,14 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
 
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices) {
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size) {
   if (self == nullptr || self->vtable == nullptr ||
       protected_slices == nullptr || unprotected_slices == nullptr) {
     return TSI_INVALID_ARGUMENT;
   }
   if (self->vtable->unprotect == nullptr) return TSI_UNIMPLEMENTED;
-  return self->vtable->unprotect(self, protected_slices, unprotected_slices);
+  return self->vtable->unprotect(self, protected_slices, unprotected_slices,
+                                 min_progress_size);
 }
 
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self) {

data/src/core/tsi/transport_security_grpc.h

@@ -47,12 +47,14 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
 /* Outputs unprotected bytes.
    - protected_slices is the bytes of protected frames.
    - unprotected_slices is the unprotected output data.
+   - if min_progress_size is not null, it returns the size of the last
+     incomplete frame which could not be fully unprotected.
    - This method returns TSI_OK in case of success. Success includes cases where
      there is not enough data to output in which case unprotected_slices has 0
      bytes.  */
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices);
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size);
 
 /* Destroys the tsi_zero_copy_grpc_protector object.  */
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self);
@@ -68,7 +70,8 @@ struct tsi_zero_copy_grpc_protector_vtable {
                         grpc_slice_buffer* protected_slices);
   tsi_result (*unprotect)(tsi_zero_copy_grpc_protector* self,
                           grpc_slice_buffer* protected_slices,
-                          grpc_slice_buffer* unprotected_slices);
+                          grpc_slice_buffer* unprotected_slices,
+                          int* min_progress_size);
   void (*destroy)(tsi_zero_copy_grpc_protector* self);
   tsi_result (*max_frame_size)(tsi_zero_copy_grpc_protector* self,
                                size_t* max_frame_size);

data/src/ruby/ext/grpc/ext-export-truffleruby.clang

@@ -0,0 +1,2 @@
+_Init_grpc_c
+_rb_tr_abi_version

data/src/ruby/ext/grpc/ext-export-truffleruby.gcc

@@ -0,0 +1,7 @@
+grpc_1.0 { 
+  global: 
+    Init_grpc_c;
+    rb_tr_abi_version;
+  local: 
+    *;
+};

data/src/ruby/ext/grpc/ext-export.clang

@@ -1 +1,2 @@
 _Init_grpc_c
+_ruby_abi_version

data/src/ruby/ext/grpc/ext-export.gcc

@@ -1,6 +1,7 @@
 grpc_1.0 { 
   global: 
     Init_grpc_c;
+    ruby_abi_version;
   local: 
     *;
 };