grpc 1.46.3 → 1.53.1

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

@@ -1,32 +1,40 @@
-/*
- *
- * Copyright 2015 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
+//
+//
+// Copyright 2015 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_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+
+#include <grpc/slice.h>
 
 #include "src/core/ext/transport/chttp2/transport/frame.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
+#include "src/core/lib/backoff/random_early_detection.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
+// IWYU pragma: no_include <type_traits>
+
 namespace grpc_core {
 
 // Top level interface for parsing a sequence of header, continuation frames.
@@ -73,7 +81,8 @@ class HPackParser {
   // Begin parsing a new frame
   // Sink receives each parsed header,
   void BeginFrame(grpc_metadata_batch* metadata_buffer,
-                  uint32_t metadata_size_limit, Boundary boundary,
+                  uint32_t metadata_size_soft_limit,
+                  uint32_t metadata_size_hard_limit, Boundary boundary,
                   Priority priority, LogInfo log_info);
   // Start throwing away any received headers after parsing them.
   void StopBufferingFrame() { metadata_buffer_ = nullptr; }
@@ -96,7 +105,9 @@ class HPackParser {
   class String;
 
   grpc_error_handle ParseInput(Input input, bool is_last);
-  bool ParseInputInner(Input* input);
+  void ParseInputInner(Input* input);
+  GPR_ATTRIBUTE_NOINLINE
+  void HandleMetadataSoftSizeLimitExceeded(Input* input);
 
   // Target metadata buffer
   grpc_metadata_batch* metadata_buffer_ = nullptr;
@@ -114,7 +125,7 @@ class HPackParser {
   uint8_t dynamic_table_updates_allowed_;
   // Length of frame so far.
   uint32_t frame_length_;
-  uint32_t metadata_size_limit_;
+  RandomEarlyDetection metadata_early_detection_;
   // Information for logging
   LogInfo log_info_;
 
@@ -124,12 +135,12 @@ class HPackParser {
 
 }  // namespace grpc_core
 
-/* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
-   the transport */
+// wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
+// the transport
 grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
                                                   grpc_chttp2_transport* t,
                                                   grpc_chttp2_stream* s,
                                                   const grpc_slice& slice,
                                                   int is_last);
 
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H */
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_H

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

@@ -1,66 +1,91 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 
-#include <assert.h>
-#include <string.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+#include <initializer_list>
+#include <utility>
+
+#include "absl/status/status.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/murmur_hash.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/validate_metadata.h"
-
-extern grpc_core::TraceFlag grpc_http_trace;
+#include "src/core/lib/slice/slice.h"
 
 namespace grpc_core {
 
-HPackTable::HPackTable() : static_metadata_(GetStaticMementos()) {}
+void HPackTable::MementoRingBuffer::Put(Memento m) {
+  GPR_ASSERT(num_entries_ < max_entries_);
+  if (entries_.size() < max_entries_) {
+    ++num_entries_;
+    return entries_.push_back(std::move(m));
+  }
+  size_t index = (first_entry_ + num_entries_) % max_entries_;
+  entries_[index] = std::move(m);
+  ++num_entries_;
+}
 
-HPackTable::~HPackTable() = default;
+auto HPackTable::MementoRingBuffer::PopOne() -> Memento {
+  GPR_ASSERT(num_entries_ > 0);
+  size_t index = first_entry_ % max_entries_;
+  ++first_entry_;
+  --num_entries_;
+  return std::move(entries_[index]);
+}
 
-/* Evict one element from the table */
-void HPackTable::EvictOne() {
-  auto first_entry = std::move(entries_[first_entry_]);
-  GPR_ASSERT(first_entry.transport_size() <= mem_used_);
-  mem_used_ -= first_entry.transport_size();
-  first_entry_ = ((first_entry_ + 1) % entries_.size());
-  num_entries_--;
+auto HPackTable::MementoRingBuffer::Lookup(uint32_t index) const
+    -> const Memento* {
+  if (index >= num_entries_) return nullptr;
+  uint32_t offset = (num_entries_ - 1u - index + first_entry_) % max_entries_;
+  return &entries_[offset];
 }
 
-void HPackTable::Rebuild(uint32_t new_cap) {
-  EntriesVec entries;
-  entries.resize(new_cap);
+void HPackTable::MementoRingBuffer::Rebuild(uint32_t max_entries) {
+  if (max_entries == max_entries_) return;
+  std::vector<Memento> entries;
+  entries.reserve(num_entries_);
   for (size_t i = 0; i < num_entries_; i++) {
-    entries[i] = std::move(entries_[(first_entry_ + i) % entries_.size()]);
+    entries.push_back(
+        std::move(entries_[(first_entry_ + i) % entries_.size()]));
   }
   first_entry_ = 0;
   entries_.swap(entries);
 }
 
+// Evict one element from the table
+void HPackTable::EvictOne() {
+  auto first_entry = entries_.PopOne();
+  GPR_ASSERT(first_entry.md.transport_size() <= mem_used_);
+  mem_used_ -= first_entry.md.transport_size();
+}
+
 void HPackTable::SetMaxBytes(uint32_t max_bytes) {
   if (max_bytes_ == max_bytes) {
     return;
@@ -76,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 absl::InternalError(absl::StrFormat(
         "Attempt to make hpack table %d bytes when max is %d bytes", bytes,
         max_bytes_));
   }
@@ -90,31 +115,22 @@ grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
     EvictOne();
   }
   current_table_bytes_ = bytes;
-  max_entries_ = hpack_constants::EntriesForBytes(bytes);
-  if (max_entries_ > entries_.size()) {
-    Rebuild(max_entries_);
-  } else if (max_entries_ < entries_.size() / 3) {
-    // TODO(ctiller): move to resource quota system, only shrink under memory
-    // pressure
-    uint32_t new_cap =
-        std::max(max_entries_, static_cast<uint32_t>(kInlineEntries));
-    if (new_cap != entries_.size()) {
-      Rebuild(new_cap);
-    }
-  }
-  return GRPC_ERROR_NONE;
+  uint32_t new_cap = std::max(hpack_constants::EntriesForBytes(bytes),
+                              hpack_constants::kInitialTableEntries);
+  entries_.Rebuild(new_cap);
+  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_));
   }
 
   // we can't add elements bigger than the max table size
-  if (md.transport_size() > current_table_bytes_) {
+  if (md.md.transport_size() > current_table_bytes_) {
     // HPACK draft 10 section 4.4 states:
     // If the size of the new entry is less than or equal to the maximum
     // size, that entry is added to the table.  It is not an error to
@@ -122,25 +138,22 @@ grpc_error_handle HPackTable::Add(Memento md) {
     // attempt to add an entry larger than the entire table causes
     // the table to be emptied of all existing entries, and results in an
     // empty table.
-    while (num_entries_) {
+    while (entries_.num_entries()) {
       EvictOne();
     }
-    return GRPC_ERROR_NONE;
+    return absl::OkStatus();
   }
 
   // evict entries to ensure no overflow
-  while (md.transport_size() >
+  while (md.md.transport_size() >
          static_cast<size_t>(current_table_bytes_) - mem_used_) {
     EvictOne();
   }
 
   // copy the finalized entry in
-  mem_used_ += md.transport_size();
-  entries_[(first_entry_ + num_entries_) % entries_.size()] = std::move(md);
-
-  // update accounting values
-  num_entries_++;
-  return GRPC_ERROR_NONE;
+  mem_used_ += md.md.transport_size();
+  entries_.Put(std::move(md));
+  return absl::OkStatus();
 }
 
 namespace {
@@ -213,23 +226,20 @@ const StaticTableEntry kStaticTable[hpack_constants::kLastStaticEntry] = {
     {"www-authenticate", ""},
 };
 
-GPR_ATTRIBUTE_NOINLINE HPackTable::Memento MakeMemento(size_t i) {
+HPackTable::Memento MakeMemento(size_t i) {
   auto sm = kStaticTable[i];
-  return grpc_metadata_batch::Parse(
-      sm.key, Slice::FromStaticString(sm.value),
-      strlen(sm.key) + strlen(sm.value) + hpack_constants::kEntryOverhead,
-      [](absl::string_view, const Slice&) {
-        abort();  // not expecting to see this
-      });
+  return HPackTable::Memento{
+      grpc_metadata_batch::Parse(
+          sm.key, Slice::FromStaticString(sm.value),
+          strlen(sm.key) + strlen(sm.value) + hpack_constants::kEntryOverhead,
+          [](absl::string_view, const Slice&) {
+            abort();  // not expecting to see this
+          }),
+      absl::OkStatus()};
 }
 
 }  // namespace
 
-const HPackTable::StaticMementos& HPackTable::GetStaticMementos() {
-  static const StaticMementos* const static_mementos = new StaticMementos();
-  return *static_mementos;
-}
-
 HPackTable::StaticMementos::StaticMementos() {
   for (uint32_t i = 0; i < hpack_constants::kLastStaticEntry; i++) {
     memento[i] = MakeMemento(i);

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

@@ -1,40 +1,45 @@
-/*
- *
- * Copyright 2015 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
+//
+//
+// Copyright 2015 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_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/slice.h>
+#include <stdint.h>
+
+#include <vector>
+
+#include "absl/status/status.h"
 
 #include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/parsed_metadata.h"
 
 namespace grpc_core {
 
 // HPACK header table
 class HPackTable {
  public:
-  HPackTable();
-  ~HPackTable();
+  HPackTable() = default;
+  ~HPackTable() = default;
 
   HPackTable(const HPackTable&) = delete;
   HPackTable& operator=(const HPackTable&) = delete;
@@ -42,7 +47,10 @@ class HPackTable {
   void SetMaxBytes(uint32_t max_bytes);
   grpc_error_handle SetCurrentTableSize(uint32_t bytes);
 
-  using Memento = ParsedMetadata<grpc_metadata_batch>;
+  struct Memento {
+    ParsedMetadata<grpc_metadata_batch> md;
+    absl::Status parse_status;
+  };
 
   // Lookup, but don't ref.
   const Memento* Lookup(uint32_t index) const {
@@ -53,7 +61,7 @@ class HPackTable {
     // reading the core static metadata table here; at that point we'd need our
     // own singleton static metadata in the correct order.
     if (index <= hpack_constants::kLastStaticEntry) {
-      return &static_metadata_.memento[index - 1];
+      return &static_mementos_->memento[index - 1];
     } else {
       return LookupDynamic(index);
     }
@@ -63,37 +71,62 @@ class HPackTable {
   grpc_error_handle Add(Memento md) GRPC_MUST_USE_RESULT;
 
   // Current entry count in the table.
-  uint32_t num_entries() const { return num_entries_; }
+  uint32_t num_entries() const { return entries_.num_entries(); }
+
+  // Current size of the table.
+  uint32_t test_only_table_size() const { return mem_used_; }
 
  private:
   struct StaticMementos {
     StaticMementos();
     Memento memento[hpack_constants::kLastStaticEntry];
   };
-  static const StaticMementos& GetStaticMementos() GPR_ATTRIBUTE_NOINLINE;
 
-  enum { kInlineEntries = hpack_constants::kInitialTableEntries };
-  using EntriesVec = absl::InlinedVector<Memento, kInlineEntries>;
+  class MementoRingBuffer {
+   public:
+    // Rebuild this buffer with a new max_entries_ size.
+    void Rebuild(uint32_t max_entries);
+
+    // Put a new memento.
+    // REQUIRES: num_entries < max_entries
+    void Put(Memento m);
+
+    // Pop the oldest memento.
+    // REQUIRES: num_entries > 0
+    Memento PopOne();
+
+    // Lookup the entry at index, or return nullptr if none exists.
+    const Memento* Lookup(uint32_t index) const;
+
+    uint32_t max_entries() const { return max_entries_; }
+    uint32_t num_entries() const { return num_entries_; }
+
+   private:
+    // The index of the first entry in the buffer. May be greater than
+    // max_entries_, in which case a wraparound has occurred.
+    uint32_t first_entry_ = 0;
+    // How many entries are in the table.
+    uint32_t num_entries_ = 0;
+    // Maximum number of entries we could possibly fit in the table, given
+    // defined overheads.
+    uint32_t max_entries_ = hpack_constants::kInitialTableEntries;
+
+    std::vector<Memento> entries_;
+  };
 
   const Memento* LookupDynamic(uint32_t index) const {
     // Not static - find the value in the list of valid entries
     const uint32_t tbl_index = index - (hpack_constants::kLastStaticEntry + 1);
-    if (tbl_index < num_entries_) {
-      uint32_t offset =
-          (num_entries_ - 1u - tbl_index + first_entry_) % entries_.size();
-      return &entries_[offset];
-    }
-    // Invalid entry: return error
-    return nullptr;
+    return entries_.Lookup(tbl_index);
   }
 
   void EvictOne();
-  void Rebuild(uint32_t new_cap);
 
-  // The first used entry in ents.
-  uint32_t first_entry_ = 0;
-  // How many entries are in the table.
-  uint32_t num_entries_ = 0;
+  static const StaticMementos* GetStaticMementos() {
+    static const NoDestruct<StaticMementos> static_mementos;
+    return static_mementos.get();
+  }
+
   // The amount of memory used by the table, according to the hpack algorithm
   uint32_t mem_used_ = 0;
   // The max memory allowed to be used by the table, according to the hpack
@@ -101,15 +134,12 @@ class HPackTable {
   uint32_t max_bytes_ = hpack_constants::kInitialTableSize;
   // The currently agreed size of the table, according to the hpack algorithm.
   uint32_t current_table_bytes_ = hpack_constants::kInitialTableSize;
-  // Maximum number of entries we could possibly fit in the table, given defined
-  // overheads.
-  uint32_t max_entries_ = hpack_constants::kInitialTableEntries;
   // HPack table entries
-  EntriesVec entries_{hpack_constants::kInitialTableEntries};
-  // Mementos for static data
-  const StaticMementos& static_metadata_;
+  MementoRingBuffer entries_;
+  // Static mementos
+  const StaticMementos* const static_mementos_ = GetStaticMementos();
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H */
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H

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

@@ -1,22 +1,22 @@
-/*
- * Copyright 2017 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.
- */
+//
+// Copyright 2017 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.
+//
 
-/*
- * Automatically generated by tools/codegen/core/gen_settings_ids.py
- */
+//
+// Automatically generated by tools/codegen/core/gen_settings_ids.py
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -25,7 +25,7 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/transport/http2_errors.h"
 
-const uint16_t grpc_setting_id_to_wire_id[] = {1, 2, 3, 4, 5, 6, 65027};
+const uint16_t grpc_setting_id_to_wire_id[] = {1, 2, 3, 4, 5, 6, 65027, 65028};
 
 bool grpc_wire_id_to_setting_id(uint32_t wire_id, grpc_chttp2_setting_id* out) {
   uint32_t i = wire_id - 1;
@@ -59,4 +59,6 @@ const grpc_chttp2_setting_parameters
          GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
         {"GRPC_ALLOW_TRUE_BINARY_METADATA", 0u, 0u, 1u,
          GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
+        {"GRPC_PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE", 0u, 16384u, 2147483647u,
+         GRPC_CHTTP2_CLAMP_INVALID_VALUE, GRPC_HTTP2_PROTOCOL_ERROR},
 };