grpc 1.42.0 → 1.52.0

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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>
 
@@ -22,42 +22,46 @@
 
 #include <assert.h>
 #include <stddef.h>
-#include <string.h>
+#include <stdlib.h>
 
+#include <algorithm>
+#include <string>
+#include <utility>
+
+#include "absl/base/attributes.h"
+#include "absl/status/status.h"
+#include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/span.h"
+#include "absl/types/variant.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/status.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
-#include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/match.h"
-#include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/surface/validate_metadata.h"
-#include "src/core/lib/transport/http2_errors.h"
-
-#if __cplusplus > 201103L
-#define GRPC_HPACK_CONSTEXPR_FN constexpr
-#define GRPC_HPACK_CONSTEXPR_VALUE constexpr
-#else
-#define GRPC_HPACK_CONSTEXPR_FN
-#define GRPC_HPACK_CONSTEXPR_VALUE const
-#endif
+#include "src/core/ext/transport/chttp2/transport/decode_huff.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.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/slice/slice.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/transport/parsed_metadata.h"
+
+// IWYU pragma: no_include <type_traits>
 
 namespace grpc_core {
 
 TraceFlag grpc_trace_chttp2_hpack_parser(false, "chttp2_hpack_parser");
 
-/* state table for huffman decoding: given a state, gives an index/16 into
-   next_sub_tbl. Taking that index and adding the value of the nibble being
-   considered returns the next state.
-
-   generated by gen_hpack_tables.c */
+// state table for huffman decoding: given a state, gives an index/16 into
+// next_sub_tbl. Taking that index and adding the value of the nibble being
+// considered returns the next state.
+// generated by gen_hpack_tables.c
+// TODO(ctiller): remove once the new_hpack_huffman_decoder experiment is
+//                complete.
 static const uint8_t next_tbl[256] = {
     0,  1,  2,  3,  4,  1,  2, 5,  6,  1, 7,  8,  1,  3,  3,  9,  10, 11, 1,  1,
     1,  12, 1,  2,  13, 1,  1, 1,  1,  1, 1,  1,  1,  1,  1,  1,  1,  1,  1,  2,
@@ -74,8 +78,8 @@ static const uint8_t next_tbl[256] = {
     3,  3,  3,  45, 46, 1,  1, 2,  2,  2, 35, 3,  3,  18, 47, 2,
 };
 
-/* next state, based upon current state and the current nibble: see above.
-   generated by gen_hpack_tables.c */
+// next state, based upon current state and the current nibble: see above.
+// generated by gen_hpack_tables.c
 static const int16_t next_sub_tbl[48 * 16] = {
     1,   204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
     218, 2,   6,   10,  13,  14,  15,  16,  17,  2,   6,   10,  13,  14,  15,
@@ -131,10 +135,9 @@ static const int16_t next_sub_tbl[48 * 16] = {
     0,   0,   255,
 };
 
-/* emission table: indexed like next_tbl, ultimately gives the byte to be
-   emitted, or -1 for no byte, or 256 for end of stream
-
-   generated by gen_hpack_tables.c */
+// emission table: indexed like next_tbl, ultimately gives the byte to be
+// emitted, or -1 for no byte, or 256 for end of stream
+// generated by gen_hpack_tables.c
 static const uint16_t emit_tbl[256] = {
     0,   1,   2,   3,   4,   5,   6,   7,   0,   8,   9,   10,  11,  12,  13,
     14,  15,  16,  17,  18,  19,  20,  21,  22,  0,   23,  24,  25,  26,  27,
@@ -156,7 +159,7 @@ static const uint16_t emit_tbl[256] = {
     248,
 };
 
-/* generated by gen_hpack_tables.c */
+// generated by gen_hpack_tables.c
 static const int16_t emit_sub_tbl[249 * 16] = {
     -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
     -1,  48,  48,  48,  48,  48,  48,  48,  48,  49,  49,  49,  49,  49,  49,
@@ -428,7 +431,7 @@ static const int16_t emit_sub_tbl[249 * 16] = {
 
 namespace {
 // The alphabet used for base64 encoding binary metadata.
-static constexpr char kBase64Alphabet[] =
+constexpr char kBase64Alphabet[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 
 // An inverted table: for each value in kBase64Alphabet, table contains the
@@ -436,7 +439,7 @@ static constexpr char kBase64Alphabet[] =
 // any complicated runtime logic.
 struct Base64InverseTable {
   uint8_t table[256]{};
-  GRPC_HPACK_CONSTEXPR_FN Base64InverseTable() {
+  constexpr Base64InverseTable() {
     for (int i = 0; i < 256; i++) {
       table[i] = 255;
     }
@@ -448,7 +451,7 @@ struct Base64InverseTable {
   }
 };
 
-static GRPC_HPACK_CONSTEXPR_VALUE Base64InverseTable kBase64InverseTable;
+constexpr Base64InverseTable kBase64InverseTable;
 }  // namespace
 
 // Input tracks the current byte through the input data and provides it
@@ -576,15 +579,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 (error_ != GRPC_ERROR_NONE || eof_error_) {
-      GRPC_ERROR_UNREF(error);
+    if (!error_.ok() || eof_error_) {
       return;
     }
     error_ = error;
@@ -596,7 +598,7 @@ class HPackParser::Input {
   template <typename F, typename T>
   GPR_ATTRIBUTE_NOINLINE T MaybeSetErrorAndReturn(F error_factory,
                                                   T return_value) {
-    if (error_ != GRPC_ERROR_NONE || eof_error_) return return_value;
+    if (!error_.ok() || eof_error_) return return_value;
     error_ = error_factory();
     begin_ = end_;
     return return_value;
@@ -606,7 +608,7 @@ class HPackParser::Input {
   // is a common case)
   template <typename T>
   T UnexpectedEOF(T return_value) {
-    if (error_ != GRPC_ERROR_NONE) return return_value;
+    if (!error_.ok()) return return_value;
     eof_error_ = true;
     return return_value;
   }
@@ -623,7 +625,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));
@@ -640,7 +642,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;
 };
@@ -649,31 +651,6 @@ class HPackParser::Input {
 // management characteristics
 class HPackParser::String {
  public:
-  // Helper to specify a string should be internalized
-  struct Intern {};
-  // Helper to specify a string should be externalized
-  struct Extern {};
-
- private:
-  // Forward declare take functions... we'll need them in the public interface
-  UnmanagedMemorySlice Take(Extern);
-  ManagedMemorySlice Take(Intern);
-
- public:
-  // If a String is a Slice then unref
-  ~String() {
-    if (auto* p = absl::get_if<grpc_slice>(&value_)) {
-      grpc_slice_unref_internal(*p);
-    }
-  }
-
-  // Take the value and leave this empty
-  // Use Intern/Extern to choose memory management
-  template <typename T>
-  auto Take() -> decltype(this->Take(T())) {
-    return Take(T());
-  }
-
   String(const String&) = delete;
   String& operator=(const String&) = delete;
   String(String&& other) noexcept : value_(std::move(other.value_)) {
@@ -685,6 +662,23 @@ class HPackParser::String {
     return *this;
   }
 
+  // Take the value and leave this empty
+  Slice Take();
+
+  // Return a reference to the value as a string view
+  absl::string_view string_view() const {
+    if (auto* p = absl::get_if<Slice>(&value_)) {
+      return p->as_string_view();
+    } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+      return absl::string_view(reinterpret_cast<const char*>(p->data()),
+                               p->size());
+    } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+      return absl::string_view(reinterpret_cast<const char*>(p->data()),
+                               p->size());
+    }
+    GPR_UNREACHABLE_CODE(return absl::string_view());
+  }
+
   // Parse a non-binary string
   static absl::optional<String> Parse(Input* input) {
     auto pfx = input->ParseStringPrefix();
@@ -758,39 +752,12 @@ class HPackParser::String {
   explicit String(std::vector<uint8_t> v) : value_(std::move(v)) {}
   explicit String(absl::Span<const uint8_t> v) : value_(v) {}
   String(grpc_slice_refcount* r, const uint8_t* begin, const uint8_t* end)
-      : value_(MakeSlice(r, begin, end)) {}
-
-  // Given a refcount and a byte range, make a slice
-  static grpc_slice MakeSlice(grpc_slice_refcount* r, const uint8_t* begin,
-                              const uint8_t* end) {
-    grpc_slice out;
-    out.refcount = r;
-    r->Ref();
-    out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
-    out.data.refcounted.length = end - begin;
-    return out;
-  }
+      : value_(Slice::FromRefcountAndBytes(r, begin, end)) {}
 
   // Parse some huffman encoded bytes, using output(uint8_t b) to emit each
   // decoded byte.
   template <typename Out>
   static bool ParseHuff(Input* input, uint32_t length, Out output) {
-    GRPC_STATS_INC_HPACK_RECV_HUFFMAN();
-    int16_t state = 0;
-    // Parse one half byte... we leverage some lookup tables to keep the logic
-    // here really simple.
-    auto nibble = [&output, &state](uint8_t nibble) {
-      int16_t emit = emit_sub_tbl[16 * emit_tbl[state] + nibble];
-      int16_t next = next_sub_tbl[16 * next_tbl[state] + nibble];
-      if (emit != -1) {
-        if (emit >= 0 && emit < 256) {
-          output(static_cast<uint8_t>(emit));
-        } else {
-          assert(emit == 256);
-        }
-      }
-      state = next;
-    };
     // If there's insufficient bytes remaining, return now.
     if (input->remaining() < length) {
       return input->UnexpectedEOF(false);
@@ -798,17 +765,35 @@ class HPackParser::String {
     // Grab the byte range, and iterate through it.
     const uint8_t* p = input->cur_ptr();
     input->Advance(length);
-    for (uint32_t i = 0; i < length; i++) {
-      nibble(p[i] >> 4);
-      nibble(p[i] & 0xf);
+    if (IsNewHpackHuffmanDecoderEnabled()) {
+      return HuffDecoder<Out>(output, p, p + length).Run();
+    } else {
+      int16_t state = 0;
+      // Parse one half byte... we leverage some lookup tables to keep the logic
+      // here really simple.
+      auto nibble = [&output, &state](uint8_t nibble) {
+        int16_t emit = emit_sub_tbl[16 * emit_tbl[state] + nibble];
+        int16_t next = next_sub_tbl[16 * next_tbl[state] + nibble];
+        if (emit != -1) {
+          if (emit >= 0 && emit < 256) {
+            output(static_cast<uint8_t>(emit));
+          } else {
+            assert(emit == 256);
+          }
+        }
+        state = next;
+      };
+      for (uint32_t i = 0; i < length; i++) {
+        nibble(p[i] >> 4);
+        nibble(p[i] & 0xf);
+      }
+      return true;
     }
-    return true;
   }
 
   // Parse some uncompressed string bytes.
   static absl::optional<String> ParseUncompressed(Input* input,
                                                   uint32_t length) {
-    GRPC_STATS_INC_HPACK_RECV_UNCOMPRESSED();
     // Check there's enough bytes
     if (input->remaining() < length) {
       return input->UnexpectedEOF(absl::optional<String>());
@@ -826,27 +811,22 @@ class HPackParser::String {
   // Turn base64 encoded bytes into not base64 encoded bytes.
   // Only takes input to set an error on failure.
   static absl::optional<String> Unbase64(Input* input, String s) {
-    auto v = Match(
-        s.value_,
-        [](const grpc_slice& slice) {
-          return Unbase64Loop(GRPC_SLICE_START_PTR(slice),
-                              GRPC_SLICE_END_PTR(slice));
-        },
-        [](absl::Span<const uint8_t> span) {
-          return Unbase64Loop(span.begin(), span.end());
-        },
-        [](const std::vector<uint8_t>& vec) {
-          return Unbase64Loop(vec.data(), vec.data() + vec.size());
-        });
-    if (!v.has_value()) {
+    absl::optional<std::vector<uint8_t>> result;
+    if (auto* p = absl::get_if<Slice>(&s.value_)) {
+      result = Unbase64Loop(p->begin(), p->end());
+    }
+    if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&s.value_)) {
+      result = Unbase64Loop(p->begin(), p->end());
+    }
+    if (auto* p = absl::get_if<std::vector<uint8_t>>(&s.value_)) {
+      result = Unbase64Loop(p->data(), p->data() + p->size());
+    }
+    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(*v));
+    return String(std::move(*result));
   }
 
   // Main loop for Unbase64
@@ -931,8 +911,7 @@ class HPackParser::String {
     GPR_UNREACHABLE_CODE(return out;);
   }
 
-  absl::variant<grpc_slice, absl::Span<const uint8_t>, std::vector<uint8_t>>
-      value_;
+  absl::variant<Slice, absl::Span<const uint8_t>, std::vector<uint8_t>> value_;
 };
 
 // Parser parses one key/value pair from a byte stream.
@@ -970,13 +949,11 @@ class HPackParser::Parser {
       case 1:
         switch (cur & 0xf) {
           case 0:  // literal key
-            return FinishHeaderOmitFromTable(ParseLiteralKey<String::Extern>());
+            return FinishHeaderOmitFromTable(ParseLiteralKey());
           case 0xf:  // varint encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseVarIdxKey<String::Extern>(0xf));
+            return FinishHeaderOmitFromTable(ParseVarIdxKey(0xf));
           default:  // inline encoded key index
-            return FinishHeaderOmitFromTable(
-                ParseIdxKey<String::Extern>(cur & 0xf));
+            return FinishHeaderOmitFromTable(ParseIdxKey(cur & 0xf));
         }
         // Update max table size.
         // First byte format: 001xxxxx
@@ -1003,23 +980,20 @@ class HPackParser::Parser {
       case 4:
         if (cur == 0x40) {
           // literal key
-          return FinishHeaderAndAddToTable(ParseLiteralKey<String::Intern>());
+          return FinishHeaderAndAddToTable(ParseLiteralKey());
         }
         ABSL_FALLTHROUGH_INTENDED;
       case 5:
       case 6:
         // inline encoded key index
-        return FinishHeaderAndAddToTable(
-            ParseIdxKey<String::Intern>(cur & 0x3f));
+        return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
       case 7:
         if (cur == 0x7f) {
           // varint encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseVarIdxKey<String::Intern>(0x3f));
+          return FinishHeaderAndAddToTable(ParseVarIdxKey(0x3f));
         } else {
           // inline encoded key index
-          return FinishHeaderAndAddToTable(
-              ParseIdxKey<String::Intern>(cur & 0x3f));
+          return FinishHeaderAndAddToTable(ParseIdxKey(cur & 0x3f));
         }
         // Indexed Header Field Representation
         // First byte format: 1xxxxxxx
@@ -1031,11 +1005,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,11 +1054,7 @@ class HPackParser::Parser {
       return HandleMetadataSizeLimitExceeded(md);
     }
 
-    grpc_error_handle err = metadata_buffer_->Set(md);
-    if (GPR_UNLIKELY(err != GRPC_ERROR_NONE)) {
-      input_->SetError(err);
-      return false;
-    }
+    metadata_buffer_->Set(md);
     return true;
   }
 
@@ -1103,7 +1069,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(err != GRPC_ERROR_NONE)) {
+    if (GPR_UNLIKELY(!err.ok())) {
       input_->SetError(err);
       return false;
     };
@@ -1125,22 +1091,25 @@ class HPackParser::Parser {
   }
 
   // Parse a string encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseLiteralKey() {
     auto key = String::Parse(input_);
     if (!key.has_value()) return {};
-    auto key_slice = key->Take<String::Intern>();
-    auto value =
-        ParseValueString(grpc_is_refcounted_slice_binary_header(key_slice));
+    auto value = ParseValueString(absl::EndsWith(key->string_view(), "-bin"));
     if (GPR_UNLIKELY(!value.has_value())) {
-      grpc_slice_unref_internal(key_slice);
       return {};
     }
-    return grpc_metadata_batch::Parse(key_slice, value->Take<TakeValueType>());
+    auto key_string = key->string_view();
+    auto value_slice = value->Take();
+    const auto transport_size = key_string.size() + value_slice.size() +
+                                hpack_constants::kEntryOverhead;
+    return grpc_metadata_batch::Parse(
+        key->string_view(), std::move(value_slice), transport_size,
+        [key_string](absl::string_view error, const Slice& value) {
+          ReportMetadataParseError(key_string, error, value.as_string_view());
+        });
   }
 
   // Parse an index encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseIdxKey(uint32_t index) {
     const auto* elem = table_->Lookup(index);
     if (GPR_UNLIKELY(elem == nullptr)) {
@@ -1149,15 +1118,17 @@ class HPackParser::Parser {
     }
     auto value = ParseValueString(elem->is_binary_header());
     if (GPR_UNLIKELY(!value.has_value())) return {};
-    return elem->WithNewValue(value->Take<TakeValueType>());
+    return elem->WithNewValue(
+        value->Take(), [=](absl::string_view error, const Slice& value) {
+          ReportMetadataParseError(elem->key(), error, value.as_string_view());
+        });
   }
 
   // Parse a varint index encoded key and a string encoded value
-  template <typename TakeValueType>
   absl::optional<HPackTable::Memento> ParseVarIdxKey(uint32_t offset) {
     auto index = input_->ParseVarint(offset);
     if (GPR_UNLIKELY(!index.has_value())) return {};
-    return ParseIdxKey<TakeValueType>(*index);
+    return ParseIdxKey(*index);
   }
 
   // Parse a string, figuring out if it's binary or not by the key name.
@@ -1177,7 +1148,6 @@ class HPackParser::Parser {
     if (GPR_UNLIKELY(elem == nullptr)) {
       return InvalidHPackIndexError(*index, false);
     }
-    GRPC_STATS_INC_HPACK_RECV_INDEXED();
     return FinishHeaderOmitFromTable(*elem);
   }
 
@@ -1187,14 +1157,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 (err != GRPC_ERROR_NONE) {
+    if (!err.ok()) {
       input_->SetError(err);
       return false;
     }
@@ -1208,33 +1178,71 @@ 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));
   }
 
+  class MetadataSizeLimitExceededEncoder {
+   public:
+    explicit MetadataSizeLimitExceededEncoder(std::string& summary)
+        : summary_(summary) {}
+
+    void Encode(const Slice& key, const Slice& value) {
+      AddToSummary(key.as_string_view(), value.size());
+    }
+
+    template <typename Key, typename Value>
+    void Encode(Key, const Value& value) {
+      AddToSummary(Key::key(), Key::Encode(value).size());
+    }
+
+   private:
+    void AddToSummary(absl::string_view key,
+                      size_t value_length) GPR_ATTRIBUTE_NOINLINE {
+      absl::StrAppend(&summary_, " ", key, ":",
+                      hpack_constants::SizeForEntry(key.size(), value_length),
+                      "B");
+    }
+    std::string& summary_;
+  };
+
   GPR_ATTRIBUTE_NOINLINE
-  bool HandleMetadataSizeLimitExceeded(const HPackTable::Memento&) {
-    gpr_log(GPR_DEBUG,
-            "received initial metadata size exceeds limit (%" PRIu32
-            " vs. %" PRIu32
-            "). GRPC_ARG_MAX_METADATA_SIZE can be set to increase this limit.",
-            *frame_length_, metadata_size_limit_);
+  bool HandleMetadataSizeLimitExceeded(const HPackTable::Memento& md) {
+    // Collect a summary of sizes so far for debugging
+    // Do not collect contents, for fear of exposing PII.
+    std::string summary;
+    if (metadata_buffer_ != nullptr) {
+      MetadataSizeLimitExceededEncoder encoder(summary);
+      metadata_buffer_->Encode(&encoder);
+    }
+    summary =
+        absl::StrCat("; adding ", md.key(), " (length ", md.transport_size(),
+                     "B)", summary.empty() ? "" : " to ", summary);
+    if (metadata_buffer_ != nullptr) metadata_buffer_->Clear();
     return input_->MaybeSetErrorAndReturn(
-        [] {
+        [this, summary = std::move(summary)] {
           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(absl::StrCat(
+                  "received initial metadata size exceeds limit (",
+                  *frame_length_, " vs. ", metadata_size_limit_, ")", summary)),
+              StatusIntProperty::kRpcStatus, GRPC_STATUS_RESOURCE_EXHAUSTED);
         },
         false);
   }
 
+  static void ReportMetadataParseError(absl::string_view key,
+                                       absl::string_view error,
+                                       absl::string_view value) {
+    gpr_log(
+        GPR_ERROR, "Error parsing metadata: %s",
+        absl::StrCat("error=", error, " key=", key, " value=", value).c_str());
+  }
+
   Input* const input_;
   grpc_metadata_batch* const metadata_buffer_;
   HPackTable* const table_;
@@ -1244,51 +1252,18 @@ class HPackParser::Parser {
   const LogInfo log_info_;
 };
 
-UnmanagedMemorySlice HPackParser::String::Take(Extern) {
-  auto s = Match(
-      value_,
-      [](const grpc_slice& slice) {
-        // TODO(ctiller): Think about this before submission.
-        GPR_DEBUG_ASSERT(!grpc_slice_is_interned(slice));
-        auto out_slice = grpc_slice_copy(slice);
-        grpc_slice_unref_internal(slice);
-        return static_cast<const UnmanagedMemorySlice&>(out_slice);
-      },
-      [](absl::Span<const uint8_t> span) {
-        return UnmanagedMemorySlice(
-            reinterpret_cast<char*>(const_cast<uint8_t*>(span.begin())),
-            span.size());
-      },
-      [](const std::vector<uint8_t>& v) {
-        return UnmanagedMemorySlice(reinterpret_cast<const char*>(v.data()),
-                                    v.size());
-      });
-  value_ = absl::Span<const uint8_t>();
-  return s;
-}
-
-ManagedMemorySlice HPackParser::String::Take(Intern) {
-  auto s = Match(
-      value_,
-      [](const grpc_slice& slice) {
-        ManagedMemorySlice s(&slice);
-        grpc_slice_unref_internal(slice);
-        return s;
-      },
-      [](absl::Span<const uint8_t> span) {
-        return ManagedMemorySlice(
-            reinterpret_cast<char*>(const_cast<uint8_t*>(span.data())),
-            span.size());
-      },
-      [](const std::vector<uint8_t>& v) {
-        return ManagedMemorySlice(reinterpret_cast<const char*>(v.data()),
-                                  v.size());
-      });
-  value_ = absl::Span<const uint8_t>();
-  return s;
+Slice HPackParser::String::Take() {
+  if (auto* p = absl::get_if<Slice>(&value_)) {
+    return p->Copy();
+  } else if (auto* p = absl::get_if<absl::Span<const uint8_t>>(&value_)) {
+    return Slice::FromCopiedBuffer(*p);
+  } else if (auto* p = absl::get_if<std::vector<uint8_t>>(&value_)) {
+    return Slice::FromCopiedBuffer(*p);
+  }
+  GPR_UNREACHABLE_CODE(return Slice());
 }
 
-/* PUBLIC INTERFACE */
+// PUBLIC INTERFACE
 
 HPackParser::HPackParser() = default;
 
@@ -1298,6 +1273,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;
@@ -1321,15 +1299,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();
 }
@@ -1360,95 +1338,3 @@ bool HPackParser::ParseInputInner(Input* input) {
 void HPackParser::FinishFrame() { metadata_buffer_ = nullptr; }
 
 }  // namespace grpc_core
-
-// TODO(ctiller): this serves as an eviction notice for the remainder of this
-// file... it belongs elsewhere!
-
-typedef void (*maybe_complete_func_type)(grpc_chttp2_transport* t,
-                                         grpc_chttp2_stream* s);
-static const maybe_complete_func_type maybe_complete_funcs[] = {
-    grpc_chttp2_maybe_complete_recv_initial_metadata,
-    grpc_chttp2_maybe_complete_recv_trailing_metadata};
-
-static void force_client_rst_stream(void* sp, grpc_error_handle /*error*/) {
-  grpc_chttp2_stream* s = static_cast<grpc_chttp2_stream*>(sp);
-  grpc_chttp2_transport* t = s->t;
-  if (!s->write_closed) {
-    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_STREAM_UNREF(s, "final_rst");
-}
-
-static void parse_stream_compression_md(grpc_chttp2_transport* /*t*/,
-                                        grpc_chttp2_stream* s,
-                                        grpc_metadata_batch* initial_metadata) {
-  if (initial_metadata->legacy_index()->named.content_encoding == nullptr ||
-      grpc_stream_compression_method_parse(
-          GRPC_MDVALUE(
-              initial_metadata->legacy_index()->named.content_encoding->md),
-          false, &s->stream_decompression_method) == 0) {
-    s->stream_decompression_method =
-        GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS;
-  }
-
-  if (s->stream_decompression_method !=
-      GRPC_STREAM_COMPRESSION_IDENTITY_DECOMPRESS) {
-    s->stream_decompression_ctx = nullptr;
-    grpc_slice_buffer_init(&s->decompressed_data_buffer);
-  }
-}
-
-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) {
-  GPR_TIMER_SCOPE("grpc_chttp2_header_parser_parse", 0);
-  auto* parser = static_cast<grpc_core::HPackParser*>(hpack_parser);
-  if (s != nullptr) {
-    s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
-  }
-  grpc_error_handle error = parser->Parse(slice, is_last != 0);
-  if (error != GRPC_ERROR_NONE) {
-    return error;
-  }
-  if (is_last) {
-    /* need to check for null stream: this can occur if we receive an invalid
-       stream id on a header */
-    if (s != nullptr) {
-      if (parser->is_boundary()) {
-        if (s->header_frames_received == 2) {
-          return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "Too many trailer frames");
-        }
-        /* Process stream compression md element if it exists */
-        if (s->header_frames_received ==
-            0) { /* Only acts on initial metadata */
-          parse_stream_compression_md(t, s, &s->initial_metadata_buffer);
-        }
-        s->published_metadata[s->header_frames_received] =
-            GRPC_METADATA_PUBLISHED_FROM_WIRE;
-        maybe_complete_funcs[s->header_frames_received](t, s);
-        s->header_frames_received++;
-      }
-      if (parser->is_eof()) {
-        if (t->is_client && !s->write_closed) {
-          /* server eof ==> complete closure; we may need to forcefully close
-             the stream. Wait until the combiner lock is ready to be released
-             however -- it might be that we receive a RST_STREAM following this
-             and can avoid the extra write */
-          GRPC_CHTTP2_STREAM_REF(s, "final_rst");
-          t->combiner->FinallyRun(
-              GRPC_CLOSURE_CREATE(force_client_rst_stream, s, nullptr),
-              GRPC_ERROR_NONE);
-        }
-        grpc_chttp2_mark_stream_closed(t, s, true, false, GRPC_ERROR_NONE);
-      }
-    }
-    parser->FinishFrame();
-  }
-  return GRPC_ERROR_NONE;
-}