grpc 1.39.0.pre1 → 1.41.0.pre2

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

@@ -24,87 +24,87 @@
 #include <stddef.h>
 
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/ext/transport/chttp2/transport/hpack_table.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_parser_table.h"
 #include "src/core/lib/transport/metadata.h"
 
-typedef struct grpc_chttp2_hpack_parser grpc_chttp2_hpack_parser;
-
-typedef grpc_error_handle (*grpc_chttp2_hpack_parser_state)(
-    grpc_chttp2_hpack_parser* p, const uint8_t* beg, const uint8_t* end);
-
-struct grpc_chttp2_hpack_parser_string {
-  bool copied;
-  struct {
-    grpc_slice referenced;
-    struct {
-      char* str;
-      uint32_t length;
-      uint32_t capacity;
-    } copied;
-  } data;
-};
-struct grpc_chttp2_hpack_parser {
-  /* user specified callback for each header output */
-  grpc_error_handle (*on_header)(void* user_data, grpc_mdelem md);
-  void* on_header_user_data;
-
-  grpc_error_handle last_error;
-
-  /* current parse state - or a function that implements it */
-  grpc_chttp2_hpack_parser_state state;
-  /* future states dependent on the opening op code */
-  const grpc_chttp2_hpack_parser_state* next_state;
-  /* what to do after skipping prioritization data */
-  grpc_chttp2_hpack_parser_state after_prioritization;
-  /* the refcount of the slice that we're currently parsing */
-  grpc_slice_refcount* current_slice_refcount;
-  /* the value we're currently parsing */
-  union {
-    uint32_t* value;
-    grpc_chttp2_hpack_parser_string* str;
-  } parsing;
-  /* string parameters for each chunk */
-  grpc_chttp2_hpack_parser_string key;
-  grpc_chttp2_hpack_parser_string value;
-  /* parsed index */
-  uint32_t index;
-  /* When we parse a value string, we determine the metadata element for a
-     specific index, which we need again when we're finishing up with that
-     header. To avoid calculating the metadata element for that index a second
-     time at that stage, we cache (and invalidate) the element here. */
-  grpc_mdelem md_for_index;
-#ifndef NDEBUG
-  int64_t precomputed_md_index;
-#endif
-  /* length of source bytes for the currently parsing string */
-  uint32_t strlen;
-  /* number of source bytes read for the currently parsing string */
-  uint32_t strgot;
-  /* huffman decoding state */
-  int16_t huff_state;
-  /* is the string being decoded binary? */
-  uint8_t binary;
-  /* is the current string huffman encoded? */
-  uint8_t huff;
-  /* is a dynamic table update allowed? */
-  uint8_t dynamic_table_update_allowed;
-  /* set by higher layers, used by grpc_chttp2_header_parser_parse to signal
-     it should append a metadata boundary at the end of frame */
-  uint8_t is_boundary;
-  uint8_t is_eof;
-  uint32_t base64_buffer;
-
-  /* hpack table */
-  grpc_chttp2_hptbl table;
-};
+namespace grpc_core {
+
+// Top level interface for parsing a sequence of header, continuation frames.
+class HPackParser {
+ public:
+  // What kind of stream boundary is provided by this frame?
+  enum class Boundary : uint8_t {
+    // More continuations are expected
+    None,
+    // This marks the end of headers, so data frames should follow
+    EndOfHeaders,
+    // This marks the end of headers *and* the end of the stream
+    EndOfStream
+  };
+  // What kind of priority is represented in the next frame
+  enum class Priority : uint8_t {
+    // No priority field
+    None,
+    // Yes there's a priority field
+    Included
+  };
+
+  // User specified structure called for each received header.
+  using Sink = std::function<grpc_error_handle(grpc_mdelem)>;
+
+  HPackParser();
+  ~HPackParser();
+
+  // Non-copyable/movable
+  HPackParser(const HPackParser&) = delete;
+  HPackParser& operator=(const HPackParser&) = delete;
 
-void grpc_chttp2_hpack_parser_init(grpc_chttp2_hpack_parser* p);
-void grpc_chttp2_hpack_parser_destroy(grpc_chttp2_hpack_parser* p);
+  // Begin parsing a new frame
+  // Sink receives each parsed header,
+  void BeginFrame(Sink sink, Boundary boundary, Priority priority);
+  // Change the header sink mid parse
+  void ResetSink(Sink sink) { sink_ = std::move(sink); }
+  // Parse one slice worth of data
+  grpc_error_handle Parse(const grpc_slice& slice, bool is_last);
+  // Reset state ready for the next BeginFrame
+  void FinishFrame();
 
-void grpc_chttp2_hpack_parser_set_has_priority(grpc_chttp2_hpack_parser* p);
+  // Retrieve the associated hpack table (for tests, debugging)
+  HPackTable* hpack_table() { return &table_; }
+  // Is the current frame a boundary of some sort
+  bool is_boundary() const { return boundary_ != Boundary::None; }
+  // Is the current frame the end of a stream
+  bool is_eof() const { return boundary_ == Boundary::EndOfStream; }
+
+ private:
+  // Helper classes: see implementation
+  class Parser;
+  class Input;
+  class String;
+
+  grpc_error_handle ParseInput(Input input, bool is_last);
+  bool ParseInputInner(Input* input);
+
+  // Callback per header received
+  Sink sink_;
+
+  // Bytes that could not be parsed last parsing round
+  std::vector<uint8_t> unparsed_bytes_;
+  // Buffer kind of boundary
+  // TODO(ctiller): see if we can move this argument to Parse, and avoid
+  // buffering.
+  Boundary boundary_;
+  // Buffer priority
+  // TODO(ctiller): see if we can move this argument to Parse, and avoid
+  // buffering.
+  Priority priority_;
+  uint8_t dynamic_table_updates_allowed_;
+
+  // hpack table
+  HPackTable table_;
+};
 
-grpc_error_handle grpc_chttp2_hpack_parser_parse(grpc_chttp2_hpack_parser* p,
-                                                 const grpc_slice& slice);
+}  // namespace grpc_core
 
 /* wraps grpc_chttp2_hpack_parser_parse to provide a frame level parser for
    the transport */

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

@@ -0,0 +1,159 @@
+/*
+ *
+ * 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 "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.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"
+#include "src/core/lib/transport/static_metadata.h"
+
+extern grpc_core::TraceFlag grpc_http_trace;
+
+namespace grpc_core {
+
+HPackTable::HPackTable() = default;
+
+HPackTable::~HPackTable() {
+  for (size_t i = 0; i < num_entries_; i++) {
+    GRPC_MDELEM_UNREF(entries_[(first_entry_ + i) % entries_.size()]);
+  }
+}
+
+/* Evict one element from the table */
+void HPackTable::EvictOne() {
+  grpc_mdelem first_entry = entries_[first_entry_];
+  size_t elem_bytes = GRPC_SLICE_LENGTH(GRPC_MDKEY(first_entry)) +
+                      GRPC_SLICE_LENGTH(GRPC_MDVALUE(first_entry)) +
+                      hpack_constants::kEntryOverhead;
+  GPR_ASSERT(elem_bytes <= mem_used_);
+  mem_used_ -= static_cast<uint32_t>(elem_bytes);
+  first_entry_ = ((first_entry_ + 1) % entries_.size());
+  num_entries_--;
+  GRPC_MDELEM_UNREF(first_entry);
+}
+
+void HPackTable::Rebuild(uint32_t new_cap) {
+  EntriesVec entries;
+  entries.resize(new_cap);
+  for (size_t i = 0; i < num_entries_; i++) {
+    entries[i] = entries_[(first_entry_ + i) % entries_.size()];
+  }
+  first_entry_ = 0;
+  entries_.swap(entries);
+}
+
+void HPackTable::SetMaxBytes(uint32_t max_bytes) {
+  if (max_bytes_ == max_bytes) {
+    return;
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+    gpr_log(GPR_INFO, "Update hpack parser max size to %d", max_bytes);
+  }
+  while (mem_used_ > max_bytes) {
+    EvictOne();
+  }
+  max_bytes_ = max_bytes;
+}
+
+grpc_error_handle HPackTable::SetCurrentTableSize(uint32_t bytes) {
+  if (current_table_bytes_ == bytes) {
+    return GRPC_ERROR_NONE;
+  }
+  if (bytes > max_bytes_) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrFormat(
+        "Attempt to make hpack table %d bytes when max is %d bytes", bytes,
+        max_bytes_));
+  }
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
+    gpr_log(GPR_INFO, "Update hpack parser table size to %d", bytes);
+  }
+  while (mem_used_ > 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;
+}
+
+grpc_error_handle HPackTable::Add(grpc_mdelem md) {
+  /* determine how many bytes of buffer this entry represents */
+  size_t elem_bytes = GRPC_SLICE_LENGTH(GRPC_MDKEY(md)) +
+                      GRPC_SLICE_LENGTH(GRPC_MDVALUE(md)) +
+                      hpack_constants::kEntryOverhead;
+
+  if (current_table_bytes_ > max_bytes_) {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(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 (elem_bytes > 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
+    // attempt to add an entry that is larger than the maximum size; an
+    // 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_) {
+      EvictOne();
+    }
+    return GRPC_ERROR_NONE;
+  }
+
+  // evict entries to ensure no overflow
+  while (elem_bytes > static_cast<size_t>(current_table_bytes_) - mem_used_) {
+    EvictOne();
+  }
+
+  // copy the finalized entry in
+  entries_[(first_entry_ + num_entries_) % entries_.size()] =
+      GRPC_MDELEM_REF(md);
+
+  // update accounting values
+  num_entries_++;
+  mem_used_ += static_cast<uint32_t>(elem_bytes);
+  return GRPC_ERROR_NONE;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,130 @@
+/*
+ *
+ * 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
+
+#include <grpc/support/port_platform.h>
+
+#include <grpc/slice.h>
+
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/static_metadata.h"
+
+namespace grpc_core {
+
+// HPACK header table
+class HPackTable {
+ public:
+  HPackTable();
+  ~HPackTable();
+
+  HPackTable(const HPackTable&);
+  HPackTable& operator=(const HPackTable&);
+
+  void SetMaxBytes(uint32_t max_bytes);
+  grpc_error_handle SetCurrentTableSize(uint32_t bytes);
+
+  // Lookup, but don't ref.
+  grpc_mdelem Peek(uint32_t index) const { return Lookup<false>(index); }
+  // Lookup, taking a ref if found.
+  grpc_mdelem Fetch(uint32_t index) const { return Lookup<true>(index); }
+
+  // add a table entry to the index
+  grpc_error_handle Add(grpc_mdelem md) GRPC_MUST_USE_RESULT;
+
+  // Current entry count in the table.
+  uint32_t num_entries() const { return num_entries_; }
+
+ private:
+  enum { kInlineEntries = hpack_constants::kInitialTableEntries };
+  using EntriesVec = absl::InlinedVector<grpc_mdelem, kInlineEntries>;
+
+  /* lookup a table entry based on its hpack index */
+  template <bool take_ref>
+  grpc_mdelem Lookup(uint32_t index) const {
+    // Static table comes first, just return an entry from it.
+    // NB: This imposes the constraint that the first
+    // GRPC_CHTTP2_LAST_STATIC_ENTRY entries in the core static metadata table
+    // must follow the hpack standard. If that changes, we *must* not rely on
+    // 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 grpc_static_mdelem_manifested()[index - 1];
+    } else {
+      return LookupDynamic<take_ref>(index);
+    }
+  }
+
+  template <bool take_ref>
+  grpc_mdelem 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();
+      grpc_mdelem md = entries_[offset];
+      if (take_ref) {
+        GRPC_MDELEM_REF(md);
+      }
+      return md;
+    }
+    // Invalid entry: return error
+    return GRPC_MDNULL;
+  }
+
+  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;
+  // 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
+  // algorithm.
+  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};
+};
+
+}  // namespace grpc_core
+
+/* Returns the static hpack table index that corresponds to /a elem. Returns 0
+  if /a elem is not statically stored or if it is not in the static hpack
+  table */
+inline uintptr_t grpc_chttp2_get_static_hpack_table_index(grpc_mdelem md) {
+  uintptr_t index =
+      reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(md)) -
+      grpc_static_mdelem_table();
+  if (index < grpc_core::hpack_constants::kLastStaticEntry) {
+    return index + 1;  // Hpack static metadata element indices start at 1
+  }
+  return 0;
+}
+
+#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_PARSER_TABLE_H */

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

@@ -0,0 +1,46 @@
+// Copyright 2021 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_utils.h"
+
+#include "src/core/lib/surface/validate_metadata.h"
+
+namespace grpc_core {
+
+namespace {
+size_t Base64EncodedSize(size_t raw_length) {
+  static constexpr uint8_t tail_xtra[3] = {0, 2, 3};
+  return raw_length / 3 * 4 + tail_xtra[raw_length % 3];
+}
+}  // namespace
+
+// Return the size occupied by some metadata in the HPACK table.
+size_t MetadataSizeInHPackTable(grpc_mdelem elem,
+                                bool use_true_binary_metadata) {
+  const uint8_t* key_buf = GRPC_SLICE_START_PTR(GRPC_MDKEY(elem));
+  size_t key_len = GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
+  size_t overhead_and_key = 32 + key_len;
+  size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem));
+  if (grpc_key_is_binary_header(key_buf, key_len)) {
+    return overhead_and_key + (use_true_binary_metadata
+                                   ? value_len + 1
+                                   : Base64EncodedSize(value_len));
+  } else {
+    return overhead_and_key + value_len;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,30 @@
+// Copyright 2021 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_UTILS_H
+#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/transport/metadata.h"
+
+namespace grpc_core {
+
+// Return the size occupied by some metadata in the HPACK table.
+size_t MetadataSizeInHPackTable(grpc_mdelem elem,
+                                bool use_true_binary_metadata);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H

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

@@ -22,11 +22,11 @@
 
 #include <string.h>
 
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/transport/chttp2/transport/internal.h"
+
 grpc_error_handle grpc_chttp2_incoming_metadata_buffer_add(
     grpc_chttp2_incoming_metadata_buffer* buffer, grpc_mdelem elem) {
   buffer->size += GRPC_MDELEM_LENGTH(elem);

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

@@ -345,7 +345,7 @@ struct grpc_chttp2_transport {
   /** data to write now */
   grpc_slice_buffer outbuf;
   /** hpack encoding */
-  grpc_chttp2_hpack_compressor hpack_compressor;
+  grpc_core::HPackCompressor hpack_compressor;
   /** is this a client? */
   bool is_client;
 
@@ -394,7 +394,7 @@ struct grpc_chttp2_transport {
   grpc_chttp2_server_ping_recv_state ping_recv_state;
 
   /** parser for headers */
-  grpc_chttp2_hpack_parser hpack_parser;
+  grpc_core::HPackParser hpack_parser;
   /** simple one shot parsers */
   union {
     grpc_chttp2_window_update_parser window_update;
@@ -555,7 +555,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch* recv_initial_metadata;
   grpc_closure* recv_initial_metadata_ready = nullptr;
   bool* trailing_metadata_available = nullptr;
-  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message;
+  grpc_core::OrphanablePtr<grpc_core::ByteStream>* recv_message = nullptr;
   bool* call_failed_before_recv_message = nullptr;
   grpc_closure* recv_message_ready = nullptr;
   grpc_metadata_batch* recv_trailing_metadata;