grpc 1.61.3 → 1.62.0.pre1

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

@@ -91,14 +91,12 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc,
-        HpackParseResult& frame_error, HpackParseResult& field_error)
+        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        frame_error_(frame_error),
-        field_error_(field_error),
+        error_(error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -217,18 +215,14 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || frame_error_.connection_error();
-  }
-
-  // Reset the field error to be ok
-  void ClearFieldError() {
-    if (field_error_.ok()) return;
-    field_error_ = HpackParseResult();
+    return min_progress_size_ != 0 || error_.connection_error();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
+  bool has_error() const { return !error_.ok(); }
+
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // Intended for errors that are specific to a stream and recoverable.
@@ -252,7 +246,10 @@ class HPackParser::Input {
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
     GPR_ASSERT(min_progress_size > 0);
-    if (eof_error()) return;
+    if (min_progress_size_ != 0 || error_.connection_error()) {
+      GPR_DEBUG_ASSERT(eof_error());
+      return;
+    }
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
@@ -305,18 +302,13 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    SetErrorFor(frame_error_, error);
-    SetErrorFor(field_error_, std::move(error));
-  }
-
-  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
-    if (!error.ok() || min_progress_size_ > 0) {
-      if (new_error.connection_error() && !error.connection_error()) {
-        error = std::move(new_error);  // connection errors dominate
+    if (!error_.ok() || min_progress_size_ > 0) {
+      if (error.connection_error() && !error_.connection_error()) {
+        error_ = std::move(error);  // connection errors dominate
       }
       return;
     }
-    error = std::move(new_error);
+    error_ = std::move(error);
   }
 
   // Refcount if we are backed by a slice
@@ -328,8 +320,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& frame_error_;
-  HpackParseResult& field_error_;
+  HpackParseResult& error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -606,7 +597,6 @@ class HPackParser::Parser {
   bool ParseTop() {
     GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
-    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -712,7 +702,7 @@ class HPackParser::Parser {
         break;
     }
     gpr_log(
-        GPR_INFO, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
+        GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
         memento.parse_status == nullptr
             ? ""
@@ -961,10 +951,11 @@ class HPackParser::Parser {
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
+    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (state_.field_error.ok()) {
+      if (status.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -974,7 +965,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (state_.field_error.ok() && memento->parse_status != nullptr) {
+      if (status.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -1001,16 +992,16 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         key_string, std::move(value_slice), state_.add_to_table, transport_size,
-        [key_string, this](absl::string_view message, const Slice&) {
-          if (!state_.field_error.ok()) return;
+        [key_string, &status, this](absl::string_view message, const Slice&) {
+          if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
           gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
                   std::string(key_string).c_str(),
                   std::string(message).c_str());
         });
-    HPackTable::Memento memento{
-        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{std::move(md),
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1172,13 +1163,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error, state_.field_error),
+              state_.frame_error),
         is_last, call_tracer);
   }
-  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
-                          state_.field_error),
-                    is_last, call_tracer);
+  return ParseInput(
+      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
+      is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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

@@ -88,9 +88,11 @@ class HPackParser {
   HPackParser();
   ~HPackParser();
 
-  // Non-copyable/movable
+  // Non-copyable
   HPackParser(const HPackParser&) = delete;
   HPackParser& operator=(const HPackParser&) = delete;
+  HPackParser(HPackParser&&) = default;
+  HPackParser& operator=(HPackParser&&) = default;
 
   // Begin parsing a new frame
   // Sink receives each parsed header,
@@ -236,8 +238,6 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
-    // Error so far for this field (set by class Input)
-    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed

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

@@ -45,6 +45,8 @@ class HPackTable {
 
   HPackTable(const HPackTable&) = delete;
   HPackTable& operator=(const HPackTable&) = delete;
+  HPackTable(HPackTable&&) = default;
+  HPackTable& operator=(HPackTable&&) = default;
 
   void SetMaxBytes(uint32_t max_bytes);
   bool SetCurrentTableSize(uint32_t bytes);
@@ -151,7 +153,7 @@ class HPackTable {
   // HPack table entries
   MementoRingBuffer entries_;
   // Static mementos
-  const StaticMementos* const static_mementos_ = GetStaticMementos();
+  const StaticMementos* static_mementos_ = GetStaticMementos();
 };
 
 }  // namespace grpc_core

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -112,17 +112,15 @@ class InprocClientTransport final : public Transport, public ClientTransport {
   void StartCall(CallHandler call_handler) override {
     call_handler.SpawnGuarded(
         "pull_initial_metadata",
-        TrySeq(
-            call_handler.PullClientInitialMetadata(),
-            [server_transport = server_transport_,
-             call_handler](ClientMetadataHandle md) {
-              auto call_initiator = server_transport->AcceptCall(*md);
-              if (!call_initiator.ok()) return call_initiator.status();
-              ForwardCall(call_handler, std::move(*call_initiator),
-                          std::move(md));
-              return absl::OkStatus();
-            },
-            ImmediateOkStatus()));
+        TrySeq(call_handler.PullClientInitialMetadata(),
+               [server_transport = server_transport_,
+                call_handler](ClientMetadataHandle md) {
+                 auto call_initiator = server_transport->AcceptCall(*md);
+                 if (!call_initiator.ok()) return call_initiator.status();
+                 ForwardCall(call_handler, std::move(*call_initiator),
+                             std::move(md));
+                 return absl::OkStatus();
+               }));
   }
 
   void Orphan() override { delete this; }
@@ -172,8 +170,9 @@ RefCountedPtr<Channel> MakeLameChannel(absl::string_view why,
 
 RefCountedPtr<Channel> MakeInprocChannel(Server* server,
                                          ChannelArgs client_channel_args) {
-  auto client_transport = MakeOrphanable<InprocClientTransport>();
-  auto server_transport = client_transport->GetServerTransport();
+  auto transports = MakeInProcessTransportPair();
+  auto client_transport = std::move(transports.first);
+  auto server_transport = std::move(transports.second);
   auto error =
       server->SetupTransport(server_transport.get(), nullptr,
                              server->channel_args()
@@ -195,6 +194,14 @@ RefCountedPtr<Channel> MakeInprocChannel(Server* server,
 }
 }  // namespace
 
+std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
+MakeInProcessTransportPair() {
+  auto client_transport = MakeOrphanable<InprocClientTransport>();
+  auto server_transport = client_transport->GetServerTransport();
+  return std::make_pair(std::move(client_transport),
+                        std::move(server_transport));
+}
+
 }  // namespace grpc_core
 
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -20,6 +20,7 @@
 #include <grpc/grpc.h>
 
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/transport/transport.h"
 
 grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                                          const grpc_channel_args* args,
@@ -27,4 +28,11 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
 extern grpc_core::TraceFlag grpc_inproc_trace;
 
+namespace grpc_core {
+
+std::pair<OrphanablePtr<Transport>, OrphanablePtr<Transport>>
+MakeInProcessTransportPair();
+
+}
+
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H