grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

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,17 +342,8 @@ 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
-        send_initial_metadata: a bitfield of GRPC_INITIAL_METADATA_xxx */
-    uint32_t send_initial_metadata_flags = 0;
     // If non-NULL, will be set by the transport to the peer string (a char*).
     // The transport retains ownership of the string.
     // Note: This pointer may be used by the transport after the
@@ -366,7 +367,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
@@ -383,10 +385,6 @@ struct grpc_transport_stream_op_batch_payload {
 
   struct {
     grpc_metadata_batch* recv_initial_metadata = nullptr;
-    // Flags are used only on the server side.  If non-null, will be set to
-    // a bitfield of the GRPC_INITIAL_METADATA_xxx macros (e.g., to
-    // indicate if the call is idempotent).
-    uint32_t* recv_flags = nullptr;
     /** Should be enqueued when initial metadata is ready to be processed. */
     grpc_closure* recv_initial_metadata_ready = nullptr;
     // If not NULL, will be set to true if trailing metadata is
@@ -405,10 +403,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_handshaker_client.cc

@@ -71,7 +71,8 @@ typedef struct alts_grpc_handshaker_client {
    * handshaker service. */
   grpc_byte_buffer* send_buffer = nullptr;
   grpc_byte_buffer* recv_buffer = nullptr;
-  grpc_status_code status = GRPC_STATUS_OK;
+  // Used to inject a read failure from tests.
+  bool inject_read_failure = false;
   /* Initial metadata to be received from handshaker service. */
   grpc_metadata_array recv_initial_metadata;
   /* A callback function provided by an application to be invoked when response
@@ -106,6 +107,8 @@ typedef struct alts_grpc_handshaker_client {
   recv_message_result* pending_recv_message_result = nullptr;
   /* Maximum frame size used by frame protector. */
   size_t max_frame_size;
+  // If non-null, will be populated with an error string upon error.
+  std::string* error;
 } alts_grpc_handshaker_client;
 
 static void handshaker_client_send_buffer_destroy(
@@ -174,10 +177,11 @@ static void maybe_complete_tsi_next(
 }
 
 static void handle_response_done(alts_grpc_handshaker_client* client,
-                                 tsi_result status,
+                                 tsi_result status, std::string error,
                                  const unsigned char* bytes_to_send,
                                  size_t bytes_to_send_size,
                                  tsi_handshaker_result* result) {
+  if (client->error != nullptr) *client->error = std::move(error);
   recv_message_result* p = grpc_core::Zalloc<recv_message_result>();
   p->status = status;
   p->bytes_to_send = bytes_to_send;
@@ -193,7 +197,6 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
   grpc_byte_buffer* recv_buffer = client->recv_buffer;
-  grpc_status_code status = client->status;
   alts_tsi_handshaker* handshaker = client->handshaker;
   /* Invalid input check. */
   if (client->cb == nullptr) {
@@ -204,25 +207,34 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   if (handshaker == nullptr) {
     gpr_log(GPR_ERROR,
             "handshaker is nullptr in alts_tsi_handshaker_handle_response()");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+    handle_response_done(
+        client, TSI_INTERNAL_ERROR,
+        "handshaker is nullptr in alts_tsi_handshaker_handle_response()",
+        nullptr, 0, nullptr);
     return;
   }
   /* TSI handshake has been shutdown. */
   if (alts_tsi_handshaker_has_shutdown(handshaker)) {
     gpr_log(GPR_INFO, "TSI handshake shutdown");
-    handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_HANDSHAKE_SHUTDOWN,
+                         "TSI handshake shutdown", nullptr, 0, nullptr);
     return;
   }
-  /* Failed grpc call check. */
-  if (!is_ok || status != GRPC_STATUS_OK) {
-    gpr_log(GPR_INFO, "grpc call made to handshaker service failed");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+  /* Check for failed grpc read. */
+  if (!is_ok || client->inject_read_failure) {
+    gpr_log(GPR_INFO, "read failed on grpc call to handshaker service");
+    handle_response_done(client, TSI_INTERNAL_ERROR,
+                         "read failed on grpc call to handshaker service",
+                         nullptr, 0, nullptr);
     return;
   }
   if (recv_buffer == nullptr) {
     gpr_log(GPR_ERROR,
             "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()");
-    handle_response_done(client, TSI_INTERNAL_ERROR, nullptr, 0, nullptr);
+    handle_response_done(
+        client, TSI_INTERNAL_ERROR,
+        "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()",
+        nullptr, 0, nullptr);
     return;
   }
   upb::Arena arena;
@@ -233,14 +245,17 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   /* Invalid handshaker response check. */
   if (resp == nullptr) {
     gpr_log(GPR_ERROR, "alts_tsi_utils_deserialize_response() failed");
-    handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_DATA_CORRUPTED,
+                         "alts_tsi_utils_deserialize_response() failed",
+                         nullptr, 0, nullptr);
     return;
   }
   const grpc_gcp_HandshakerStatus* resp_status =
       grpc_gcp_HandshakerResp_status(resp);
   if (resp_status == nullptr) {
     gpr_log(GPR_ERROR, "No status in HandshakerResp");
-    handle_response_done(client, TSI_DATA_CORRUPTED, nullptr, 0, nullptr);
+    handle_response_done(client, TSI_DATA_CORRUPTED,
+                         "No status in HandshakerResp", nullptr, 0, nullptr);
     return;
   }
   upb_StringView out_frames = grpc_gcp_HandshakerResp_out_frames(resp);
@@ -262,7 +277,9 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
         alts_tsi_handshaker_result_create(resp, client->is_client, &result);
     if (status != TSI_OK) {
       gpr_log(GPR_ERROR, "alts_tsi_handshaker_result_create() failed");
-      handle_response_done(client, status, nullptr, 0, nullptr);
+      handle_response_done(client, status,
+                           "alts_tsi_handshaker_result_create() failed",
+                           nullptr, 0, nullptr);
       return;
     }
     alts_tsi_handshaker_result_set_unused_bytes(
@@ -271,13 +288,13 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   }
   grpc_status_code code = static_cast<grpc_status_code>(
       grpc_gcp_HandshakerStatus_code(resp_status));
+  std::string error;
   if (code != GRPC_STATUS_OK) {
     upb_StringView details = grpc_gcp_HandshakerStatus_details(resp_status);
     if (details.size > 0) {
-      char* error_details = static_cast<char*>(gpr_zalloc(details.size + 1));
-      memcpy(error_details, details.data, details.size);
-      gpr_log(GPR_ERROR, "Error from handshaker service:%s", error_details);
-      gpr_free(error_details);
+      error = absl::StrCat("Status ", code, " from handshaker service: ",
+                           absl::string_view(details.data, details.size));
+      gpr_log(GPR_ERROR, "%s", error.c_str());
     }
   }
   // TODO(apolcyn): consider short ciruiting handle_response_done and
@@ -285,7 +302,8 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
   // handle_response_done's allocation per message received causes
   // a performance issue.
   handle_response_done(client, alts_tsi_utils_convert_to_tsi_result(code),
-                       bytes_to_send, bytes_to_send_size, result);
+                       std::move(error), bytes_to_send, bytes_to_send_size,
+                       result);
 }
 
 static tsi_result continue_make_grpc_call(alts_grpc_handshaker_client* client,
@@ -690,7 +708,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     grpc_alts_credentials_options* options, const grpc_slice& target_name,
     grpc_iomgr_cb_func grpc_cb, tsi_handshaker_on_next_done_cb cb,
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
-    bool is_client, size_t max_frame_size) {
+    bool is_client, size_t max_frame_size, std::string* error) {
   if (channel == nullptr || handshaker_service_url == nullptr) {
     gpr_log(GPR_ERROR, "Invalid arguments to alts_handshaker_client_create()");
     return nullptr;
@@ -713,6 +731,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
   client->buffer = static_cast<unsigned char*>(gpr_zalloc(client->buffer_size));
   client->handshake_status_details = grpc_empty_slice();
   client->max_frame_size = max_frame_size;
+  client->error = error;
   grpc_slice slice = grpc_slice_from_copied_string(handshaker_service_url);
   client->call =
       strcmp(handshaker_service_url, ALTS_HANDSHAKER_SERVICE_URL_FOR_TESTING) ==
@@ -776,7 +795,7 @@ void alts_handshaker_client_set_recv_bytes_for_testing(
 void alts_handshaker_client_set_fields_for_testing(
     alts_handshaker_client* c, alts_tsi_handshaker* handshaker,
     tsi_handshaker_on_next_done_cb cb, void* user_data,
-    grpc_byte_buffer* recv_buffer, grpc_status_code status) {
+    grpc_byte_buffer* recv_buffer, bool inject_read_failure) {
   GPR_ASSERT(c != nullptr);
   alts_grpc_handshaker_client* client =
       reinterpret_cast<alts_grpc_handshaker_client*>(c);
@@ -784,7 +803,7 @@ void alts_handshaker_client_set_fields_for_testing(
   client->cb = cb;
   client->user_data = user_data;
   client->recv_buffer = recv_buffer;
-  client->status = status;
+  client->inject_read_failure = inject_read_failure;
 }
 
 void alts_handshaker_client_check_fields_for_testing(

data/src/core/tsi/alts/handshaker/alts_handshaker_client.h

@@ -144,7 +144,7 @@ alts_handshaker_client* alts_grpc_handshaker_client_create(
     grpc_alts_credentials_options* options, const grpc_slice& target_name,
     grpc_iomgr_cb_func grpc_cb, tsi_handshaker_on_next_done_cb cb,
     void* user_data, alts_handshaker_client_vtable* vtable_for_testing,
-    bool is_client, size_t max_frame_size);
+    bool is_client, size_t max_frame_size, std::string* error);
 
 /**
  * This method handles handshaker response returned from ALTS handshaker

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());
@@ -416,7 +416,7 @@ static void on_handshaker_service_resp_recv_dedicated(
 static tsi_result alts_tsi_handshaker_continue_handshaker_next(
     alts_tsi_handshaker* handshaker, const unsigned char* received_bytes,
     size_t received_bytes_size, tsi_handshaker_on_next_done_cb cb,
-    void* user_data) {
+    void* user_data, std::string* error) {
   if (!handshaker->has_created_handshaker_client) {
     if (handshaker->channel == nullptr) {
       grpc_alts_shared_resource_dedicated_start(
@@ -437,9 +437,10 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
         handshaker->interested_parties, handshaker->options,
         handshaker->target_name, grpc_cb, cb, user_data,
         handshaker->client_vtable_for_testing, handshaker->is_client,
-        handshaker->max_frame_size);
+        handshaker->max_frame_size, error);
     if (client == nullptr) {
       gpr_log(GPR_ERROR, "Failed to create ALTS handshaker client");
+      if (error != nullptr) *error = "Failed to create ALTS handshaker client";
       return TSI_FAILED_PRECONDITION;
     }
     {
@@ -448,6 +449,7 @@ static tsi_result alts_tsi_handshaker_continue_handshaker_next(
       handshaker->client = client;
       if (handshaker->shutdown) {
         gpr_log(GPR_INFO, "TSI handshake shutdown");
+        if (error != nullptr) *error = "TSI handshaker shutdown";
         return TSI_HANDSHAKE_SHUTDOWN;
       }
     }
@@ -490,6 +492,7 @@ struct alts_tsi_handshaker_continue_handshaker_next_args {
   tsi_handshaker_on_next_done_cb cb;
   void* user_data;
   grpc_closure closure;
+  std::string* error = nullptr;
 };
 
 static void alts_tsi_handshaker_create_channel(
@@ -510,7 +513,8 @@ static void alts_tsi_handshaker_create_channel(
   tsi_result continue_next_result =
       alts_tsi_handshaker_continue_handshaker_next(
           handshaker, next_args->received_bytes.get(),
-          next_args->received_bytes_size, next_args->cb, next_args->user_data);
+          next_args->received_bytes_size, next_args->cb, next_args->user_data,
+          next_args->error);
   if (continue_next_result != TSI_OK) {
     next_args->cb(continue_next_result, next_args->user_data, nullptr, 0,
                   nullptr);
@@ -522,9 +526,10 @@ static tsi_result handshaker_next(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** /*bytes_to_send*/,
     size_t* /*bytes_to_send_size*/, tsi_handshaker_result** /*result*/,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
+    tsi_handshaker_on_next_done_cb cb, void* user_data, std::string* error) {
   if (self == nullptr || cb == nullptr) {
     gpr_log(GPR_ERROR, "Invalid arguments to handshaker_next()");
+    if (error != nullptr) *error = "invalid argument";
     return TSI_INVALID_ARGUMENT;
   }
   alts_tsi_handshaker* handshaker =
@@ -533,6 +538,7 @@ static tsi_result handshaker_next(
     grpc_core::MutexLock lock(&handshaker->mu);
     if (handshaker->shutdown) {
       gpr_log(GPR_INFO, "TSI handshake shutdown");
+      if (error != nullptr) *error = "handshake shutdown";
       return TSI_HANDSHAKE_SHUTDOWN;
     }
   }
@@ -542,6 +548,7 @@ static tsi_result handshaker_next(
     args->handshaker = handshaker;
     args->received_bytes = nullptr;
     args->received_bytes_size = received_bytes_size;
+    args->error = error;
     if (received_bytes_size > 0) {
       args->received_bytes = std::unique_ptr<unsigned char>(
           static_cast<unsigned char*>(gpr_zalloc(received_bytes_size)));
@@ -559,7 +566,7 @@ static tsi_result handshaker_next(
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, &args->closure, GRPC_ERROR_NONE);
   } else {
     tsi_result ok = alts_tsi_handshaker_continue_handshaker_next(
-        handshaker, received_bytes, received_bytes_size, cb, user_data);
+        handshaker, received_bytes, received_bytes_size, cb, user_data, error);
     if (ok != TSI_OK) {
       gpr_log(GPR_ERROR, "Failed to schedule ALTS handshaker requests");
       return ok;
@@ -577,11 +584,11 @@ static tsi_result handshaker_next_dedicated(
     tsi_handshaker* self, const unsigned char* received_bytes,
     size_t received_bytes_size, const unsigned char** bytes_to_send,
     size_t* bytes_to_send_size, tsi_handshaker_result** result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data) {
+    tsi_handshaker_on_next_done_cb cb, void* user_data, std::string* error) {
   grpc_core::ExecCtx exec_ctx;
   return handshaker_next(self, received_bytes, received_bytes_size,
                          bytes_to_send, bytes_to_send_size, result, cb,
-                         user_data);
+                         user_data, error);
 }
 
 static void handshaker_shutdown(tsi_handshaker* self) {

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker_private.h

@@ -63,7 +63,7 @@ void alts_handshaker_client_check_fields_for_testing(
 void alts_handshaker_client_set_fields_for_testing(
     alts_handshaker_client* client, alts_tsi_handshaker* handshaker,
     tsi_handshaker_on_next_done_cb cb, void* user_data,
-    grpc_byte_buffer* recv_buffer, grpc_status_code status);
+    grpc_byte_buffer* recv_buffer, bool inject_read_failure);
 
 void alts_handshaker_client_set_vtable_for_testing(
     alts_handshaker_client* client, alts_handshaker_client_vtable* vtable);

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;
 }