grpc 1.50.0 → 1.51.0

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -26,7 +26,6 @@
 #include <stdlib.h>
 
 #include <algorithm>
-#include <cstdint>
 #include <string>
 #include <utility>
 
@@ -49,10 +48,11 @@
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/parsed_metadata.h"
 #include "src/core/lib/transport/transport.h"
@@ -586,15 +586,14 @@ class HPackParser::Input {
   // Extract the parse error, leaving the current error as NONE.
   grpc_error_handle TakeError() {
     grpc_error_handle out = error_;
-    error_ = GRPC_ERROR_NONE;
+    error_ = absl::OkStatus();
     return out;
   }
 
   // Set the current error - allows the rest of the code not to need to pass
   // around StatusOr<> which would be prohibitive here.
   GPR_ATTRIBUTE_NOINLINE void SetError(grpc_error_handle error) {
-    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) {
-      GRPC_ERROR_UNREF(error);
+    if (!error_.ok() || eof_error_) {
       return;
     }
     error_ = error;
@@ -606,7 +605,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (!GRPC_ERROR_IS_NONE(error_) || eof_error_) return return_value;
+    if (!error_.ok() || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -616,7 +615,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (!GRPC_ERROR_IS_NONE(error_)) return return_value;
+    if (!error_.ok()) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -633,7 +632,7 @@ class HPackParser::Input {
                                                  uint8_t last_byte) {
     return MaybeSetErrorAndReturn(
         [value, last_byte] {
-          return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+          return GRPC_ERROR_CREATE(absl::StrFormat(
               "integer overflow in hpack integer decoding: have 0x%08x, "
               "got byte 0x%02x on byte 5",
               value, last_byte));
@@ -650,7 +649,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  grpc_error_handle error_ = GRPC_ERROR_NONE;
+  grpc_error_handle error_;
   // If the error was EOF, we flag it here..
   bool eof_error_ = false;
 };
@@ -831,10 +830,7 @@ class HPackParser::String {
     }
     if (!result.has_value()) {
       return input->MaybeSetErrorAndReturn(
-          [] {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                "illegal base64 encoding");
-          },
+          [] { return GRPC_ERROR_CREATE("illegal base64 encoding"); },
           absl::optional<String>());
     }
     return String(std::move(*result));
@@ -1016,11 +1012,7 @@ class HPackParser::Parser {
         if (cur == 0x80) {
           // illegal value.
           return input_->MaybeSetErrorAndReturn(
-              [] {
-                return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                    "Illegal hpack op code");
-              },
-              false);
+              [] { return GRPC_ERROR_CREATE("Illegal hpack op code"); }, false);
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 9:
@@ -1084,7 +1076,7 @@ class HPackParser::Parser {
     auto r = EmitHeader(*md);
     // Add to the hpack table
     grpc_error_handle err = table_->Add(std::move(*md));
-    if (GPR_UNLIKELY(!GRPC_ERROR_IS_NONE(err))) {
+    if (GPR_UNLIKELY(!err.ok())) {
       input_->SetError(err);
       return false;
     };
@@ -1172,14 +1164,14 @@ class HPackParser::Parser {
     if (*dynamic_table_updates_allowed_ == 0) {
       return input_->MaybeSetErrorAndReturn(
           [] {
-            return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            return GRPC_ERROR_CREATE(
                 "More than two max table size changes in a single frame");
           },
           false);
     }
     (*dynamic_table_updates_allowed_)--;
     grpc_error_handle err = table_->SetCurrentTableSize(*size);
-    if (!GRPC_ERROR_IS_NONE(err)) {
+    if (!err.ok()) {
       input_->SetError(err);
       return false;
     }
@@ -1193,11 +1185,10 @@ class HPackParser::Parser {
     return input_->MaybeSetErrorAndReturn(
         [this, index] {
           return grpc_error_set_int(
-              grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                     "Invalid HPACK index received"),
-                                 GRPC_ERROR_INT_INDEX,
-                                 static_cast<intptr_t>(index)),
-              GRPC_ERROR_INT_SIZE,
+              grpc_error_set_int(
+                  GRPC_ERROR_CREATE("Invalid HPACK index received"),
+                  StatusIntProperty::kIndex, static_cast<intptr_t>(index)),
+              StatusIntProperty::kSize,
               static_cast<intptr_t>(this->table_->num_entries()));
         },
         std::move(result));
@@ -1214,9 +1205,8 @@ class HPackParser::Parser {
     return input_->MaybeSetErrorAndReturn(
         [] {
           return grpc_error_set_int(
-              GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                  "received initial metadata size exceeds limit"),
-              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_RESOURCE_EXHAUSTED);
+              GRPC_ERROR_CREATE("received initial metadata size exceeds limit"),
+              StatusIntProperty::kRpcStatus, GRPC_STATUS_RESOURCE_EXHAUSTED);
         },
         false);
   }
@@ -1259,6 +1249,9 @@ void HPackParser::BeginFrame(grpc_metadata_batch* metadata_buffer,
                              uint32_t metadata_size_limit, Boundary boundary,
                              Priority priority, LogInfo log_info) {
   metadata_buffer_ = metadata_buffer;
+  if (metadata_buffer != nullptr) {
+    metadata_buffer->Set(GrpcStatusFromWire(), true);
+  }
   boundary_ = boundary;
   priority_ = priority;
   dynamic_table_updates_allowed_ = 2;
@@ -1282,15 +1275,15 @@ grpc_error_handle HPackParser::Parse(const grpc_slice& slice, bool is_last) {
 
 grpc_error_handle HPackParser::ParseInput(Input input, bool is_last) {
   if (ParseInputInner(&input)) {
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
   if (input.eof_error()) {
     if (GPR_UNLIKELY(is_last && is_boundary())) {
-      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+      return GRPC_ERROR_CREATE(
           "Incomplete header at the end of a header/continuation sequence");
     }
     unparsed_bytes_ = std::vector<uint8_t>(input.frontier(), input.end_ptr());
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
   return input.TakeError();
 }
@@ -1338,7 +1331,7 @@ static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
     grpc_chttp2_add_rst_stream_to_next_write(t, s->id, GRPC_HTTP2_NO_ERROR,
                                              &s->stats.outgoing);
     grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_FORCE_RST_STREAM);
-    grpc_chttp2_mark_stream_closed(t, s, true, true, GRPC_ERROR_NONE);
+    grpc_chttp2_mark_stream_closed(t, s, true, true, absl::OkStatus());
   }
   GRPC_CHTTP2_STREAM_UNREF(s, "final_rst");
 }
@@ -1353,7 +1346,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     return error;
   }
   if (is_last) {
@@ -1362,8 +1355,7 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
     if (s != nullptr) {
       if (parser->is_boundary()) {
         if (s->header_frames_received == 2) {
-          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Too many trailer frames");
+          return GRPC_ERROR_CREATE("Too many trailer frames");
         }
         s->published_metadata[s->header_frames_received] =
             GRPC_METADATA_PUBLISHED_FROM_WIRE;
@@ -1379,12 +1371,12 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
           GRPC_CHTTP2_STREAM_REF(s, "final_rst");
           t->combiner->FinallyRun(
               GRPC_CLOSURE_CREATE(force_client_rst_stream, s, nullptr),
-              GRPC_ERROR_NONE);
+              absl::OkStatus());
         }
-        grpc_chttp2_mark_stream_closed(t, s, true, false, GRPC_ERROR_NONE);
+        grpc_chttp2_mark_stream_closed(t, s, true, false, absl::OkStatus());
       }
     }
     parser->FinishFrame();
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }

data/src/core/ext/transport/chttp2/transport/hpack_parser_table.cc

@@ -27,6 +27,7 @@
 #include <cstring>
 #include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
@@ -100,10 +101,10 @@ void HPackTable::SetMaxBytes(uint32_t max_bytes) {
 
 grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
   if (current_table_bytes_ == bytes) {
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
   if (bytes > max_bytes_) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+    return GRPC_ERROR_CREATE(absl::StrFormat(
         "Attempt to make hpack table %d bytes when max is %d bytes", bytes,
         max_bytes_));
   }
@@ -117,12 +118,12 @@ grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
   uint32_t new_cap = std::max(hpack_constants::EntriesForBytes(bytes),
                               hpack_constants::kInitialTableEntries);
   entries_.Rebuild(new_cap);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 grpc_error_handle HPackTable::Add(Memento md) {
   if (current_table_bytes_ > max_bytes_) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+    return GRPC_ERROR_CREATE(absl::StrFormat(
         "HPACK max table size reduced to %d but not reflected by hpack "
         "stream (still at %d)",
         max_bytes_, current_table_bytes_));
@@ -140,7 +141,7 @@ grpc_error_handle HPackTable::Add(Memento md) {
     while (entries_.num_entries()) {
       EvictOne();
     }
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
 
   // evict entries to ensure no overflow
@@ -152,7 +153,7 @@ grpc_error_handle HPackTable::Add(Memento md) {
   // copy the finalized entry in
   mem_used_ += md.transport_size();
   entries_.Put(std::move(md));
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 namespace {

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -60,6 +60,7 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -236,7 +237,21 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
-struct grpc_chttp2_transport {
+struct grpc_chttp2_transport
+// TODO(ctiller): #31319 fixed a crash on Linux & Mac whereby iomgr was
+// accessed after shutdown by chttp2. We've not seen similar behavior on
+// Windows afaik, but this fix has exposed another refcounting bug whereby
+// transports leak on Windows and prevent test shutdown.
+// This hack attempts to compromise between two things that are blocking our CI
+// from giving us a good quality signal, but are unlikely to be problems for
+// most customers. We should continue tracking down what's causing the failure,
+// but this gives us some runway to do so - and given that we're actively
+// working on removing the problematic code paths, it may be that effort brings
+// the result we need.
+#ifndef GPR_WINDOWS
+    : public grpc_core::KeepsGrpcInitialized
+#endif
+{
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport();
@@ -261,7 +276,7 @@ struct grpc_chttp2_transport {
   /** is the transport destroying itself? */
   uint8_t destroying = false;
   /** has the upper layer closed the transport? */
-  grpc_error_handle closed_with_error = GRPC_ERROR_NONE;
+  grpc_error_handle closed_with_error;
 
   /** is there a read request to the endpoint outstanding? */
   uint8_t endpoint_reading = 1;
@@ -309,8 +324,8 @@ struct grpc_chttp2_transport {
   uint32_t write_buffer_size = grpc_core::chttp2::kDefaultWindow;
 
   /** Set to a grpc_error object if a goaway frame is received. By default, set
-   * to GRPC_ERROR_NONE */
-  grpc_error_handle goaway_error = GRPC_ERROR_NONE;
+   * to absl::OkStatus() */
+  grpc_error_handle goaway_error;
 
   grpc_chttp2_sent_goaway_state sent_goaway_state = GRPC_CHTTP2_NO_GOAWAY_SEND;
 
@@ -391,7 +406,7 @@ struct grpc_chttp2_transport {
 
   /* if non-NULL, close the transport with this error when writes are finished
    */
-  grpc_error_handle close_transport_on_writes_finished = GRPC_ERROR_NONE;
+  grpc_error_handle close_transport_on_writes_finished;
 
   /* a list of closures to run after writes are finished */
   grpc_closure_list run_after_write = GRPC_CLOSURE_LIST_INIT;
@@ -499,6 +514,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch* recv_initial_metadata;
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
+  bool parsed_trailers_only = false;
   absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
   uint32_t* recv_message_flags = nullptr;
   bool* call_failed_before_recv_message = nullptr;
@@ -527,9 +543,9 @@ struct grpc_chttp2_stream {
   bool eos_sent = false;
 
   /** the error that resulted in this stream being read-closed */
-  grpc_error_handle read_closed_error = GRPC_ERROR_NONE;
+  grpc_error_handle read_closed_error;
   /** the error that resulted in this stream being write-closed */
-  grpc_error_handle write_closed_error = GRPC_ERROR_NONE;
+  grpc_error_handle write_closed_error;
 
   grpc_published_metadata_method published_metadata[2] = {};
   bool final_metadata_requested = false;
@@ -543,7 +559,7 @@ struct grpc_chttp2_stream {
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
   /** saw some stream level error */
-  grpc_error_handle forced_close_error = GRPC_ERROR_NONE;
+  grpc_error_handle forced_close_error;
   /** how many header frames have we received? */
   uint8_t header_frames_received = 0;
   /** number of bytes received - reset at end of parse thread execution */