Skip to content

GitLab

T
tangled
Commit a136ffb8 authored by bnc's avatar bnc Committed by Commit bot
Browse files
Options

Remove HpackDecoder2. 

Also remove associated flag FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2.

HpackDecoder2 (an adapter to //gfe/http2/hpack/decoder) was superseded by
HpackDecoder3, and has not been used in production.

This CL lands server change 149561590 by jamessynge.

BUG=488484

Review-Url: https://codereview.chromium.org/2750853008
Cr-Commit-Position: refs/heads/master@{#457474}
parent b857e84f
Show whitespace changes
Inline Side-by-side
Showing with 18 additions and 1488 deletions
net/BUILD.gn
View file @ a136ffb8
...@@ -1470,8 +1470,6 @@ component("net") { ...@@ -1470,8 +1470,6 @@ component("net") {
"spdy/hpack/hpack_constants.h", "spdy/hpack/hpack_constants.h",
"spdy/hpack/hpack_decoder.cc", "spdy/hpack/hpack_decoder.cc",
"spdy/hpack/hpack_decoder.h", "spdy/hpack/hpack_decoder.h",
"spdy/hpack/hpack_decoder2.cc",
"spdy/hpack/hpack_decoder2.h",
"spdy/hpack/hpack_decoder3.cc", "spdy/hpack/hpack_decoder3.cc",
"spdy/hpack/hpack_decoder3.h", "spdy/hpack/hpack_decoder3.h",
"spdy/hpack/hpack_decoder_interface.h", "spdy/hpack/hpack_decoder_interface.h",
...@@ -4611,7 +4609,6 @@ test("net_unittests") { ...@@ -4611,7 +4609,6 @@ test("net_unittests") {
"spdy/buffered_spdy_framer_unittest.cc", "spdy/buffered_spdy_framer_unittest.cc",
"spdy/fuzzing/hpack_fuzz_util_test.cc", "spdy/fuzzing/hpack_fuzz_util_test.cc",
"spdy/header_coalescer_test.cc", "spdy/header_coalescer_test.cc",
"spdy/hpack/hpack_decoder2_test.cc",
"spdy/hpack/hpack_decoder3_test.cc", "spdy/hpack/hpack_decoder3_test.cc",
"spdy/hpack/hpack_decoder_test.cc", "spdy/hpack/hpack_decoder_test.cc",
"spdy/hpack/hpack_encoder_test.cc", "spdy/hpack/hpack_encoder_test.cc",
......
net/quic/core/quic_headers_stream_test.cc
View file @ a136ffb8
...@@ -150,13 +150,11 @@ std::ostream& operator<<(std::ostream& os, Http2DecoderChoice v) { ...@@ -150,13 +150,11 @@ std::ostream& operator<<(std::ostream& os, Http2DecoderChoice v) {
return os; return os;
} }
enum HpackDecoderChoice { HPACK_DECODER_SPDY, HPACK_DECODER2, HPACK_DECODER3 }; enum HpackDecoderChoice { HPACK_DECODER_SPDY, HPACK_DECODER3 };
std::ostream& operator<<(std::ostream& os, HpackDecoderChoice v) { std::ostream& operator<<(std::ostream& os, HpackDecoderChoice v) {
switch (v) { switch (v) {
case HPACK_DECODER_SPDY: case HPACK_DECODER_SPDY:
return os << "SPDY"; return os << "SPDY";
case HPACK_DECODER2:
return os << "HPACK_DECODER2";
case HPACK_DECODER3: case HPACK_DECODER3:
return os << "HPACK_DECODER3"; return os << "HPACK_DECODER3";
} }
...@@ -191,15 +189,9 @@ struct TestParams { ...@@ -191,15 +189,9 @@ struct TestParams {
} }
switch (hpack_decoder) { switch (hpack_decoder) {
case HPACK_DECODER_SPDY: case HPACK_DECODER_SPDY:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
break;
case HPACK_DECODER2:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false; FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
break; break;
case HPACK_DECODER3: case HPACK_DECODER3:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true; FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true;
break; break;
} }
...@@ -407,13 +399,13 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParamsTuple> { ...@@ -407,13 +399,13 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParamsTuple> {
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
Tests, Tests,
QuicHeadersStreamTest, QuicHeadersStreamTest,
::testing::Combine( ::testing::Combine(::testing::ValuesIn(AllSupportedVersions()),
::testing::ValuesIn(AllSupportedVersions()), ::testing::Values(Perspective::IS_CLIENT,
::testing::Values(Perspective::IS_CLIENT, Perspective::IS_SERVER), Perspective::IS_SERVER),
::testing::Values(HTTP2_DECODER_SPDY, ::testing::Values(HTTP2_DECODER_SPDY,
HTTP2_DECODER_NESTED_SPDY, HTTP2_DECODER_NESTED_SPDY,
HTTP2_DECODER_NEW), HTTP2_DECODER_NEW),
::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER2, HPACK_DECODER3))); ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER3)));
TEST_P(QuicHeadersStreamTest, StreamId) { TEST_P(QuicHeadersStreamTest, StreamId) {
EXPECT_EQ(3u, headers_stream_->id()); EXPECT_EQ(3u, headers_stream_->id());
...@@ -755,8 +747,7 @@ TEST_P(QuicHeadersStreamTest, RespectHttp2SettingsFrameSupportedFields) { ...@@ -755,8 +747,7 @@ TEST_P(QuicHeadersStreamTest, RespectHttp2SettingsFrameSupportedFields) {
stream_frame_.data_buffer = frame.data(); stream_frame_.data_buffer = frame.data();
stream_frame_.data_length = frame.size(); stream_frame_.data_length = frame.size();
headers_stream_->OnStreamFrame(stream_frame_); headers_stream_->OnStreamFrame(stream_frame_);
EXPECT_EQ(kTestHeaderTableSize, EXPECT_EQ(kTestHeaderTableSize, QuicSpdySessionPeer::GetSpdyFramer(&session_)
QuicSpdySessionPeer::GetSpdyFramer(&session_)
.header_encoder_table_size()); .header_encoder_table_size());
} }
......
net/spdy/hpack/hpack_decoder2.cc deleted 100644 → 0
View file @ b857e84f
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/spdy/hpack/hpack_decoder2.h"
#include <list>
#include <utility>
#include "base/logging.h"
#include "base/strings/string_piece.h"
#include "net/http2/decoder/decode_buffer.h"
#include "net/http2/decoder/decode_status.h"
#include "net/spdy/hpack/hpack_entry.h"
#include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
using base::StringPiece;
namespace net {
HpackDecoder2::HpackDecoder2() : hpack_block_decoder_(this) {
Reset();
}
HpackDecoder2::~HpackDecoder2() {}
void HpackDecoder2::Reset() {
DVLOG(2) << "HpackDecoder2::Reset";
handler_ = nullptr;
hpack_block_decoder_.Reset();
hpack_block_decoder_.set_listener(this);
total_hpack_bytes_ = 0;
total_header_bytes_ = 0;
size_update_count_ = 0;
header_seen_ = false;
in_progress_ = false;
error_detected_ = false;
header_block_started_ = false;
name_.Reset();
value_.Reset();
}
void HpackDecoder2::SetErrorDetected() {
if (!error_detected_) {
DVLOG(2) << "HpackDecoder2::SetErrorDetected";
hpack_block_decoder_.set_listener(&no_op_listener_);
error_detected_ = true;
}
}
void HpackDecoder2::ApplyHeaderTableSizeSetting(size_t size_setting) {
DVLOG(2) << "HpackDecoder2::ApplyHeaderTableSizeSetting";
header_table_.SetSettingsHeaderTableSize(size_setting);
}
// If a SpdyHeadersHandlerInterface is provided, the decoder will emit
// headers to it rather than accumulating them in a SpdyHeaderBlock.
void HpackDecoder2::HandleControlFrameHeadersStart(
SpdyHeadersHandlerInterface* handler) {
DVLOG(2) << "HpackDecoder2::HandleControlFrameHeadersStart";
DCHECK(!header_block_started_);
handler_ = handler;
}
// Called as HPACK block fragments arrive. Returns false
// if an error occurred while decoding the block.
bool HpackDecoder2::HandleControlFrameHeadersData(const char* headers_data,
size_t headers_data_length) {
DVLOG(2) << "HpackDecoder2::HandleControlFrameHeadersData: len="
<< headers_data_length;
if (!header_block_started_) {
DCHECK_EQ(total_hpack_bytes_, 0u);
// Clear the SpdyHeaderBlock here rather than in Reset so that it is NOT
// cleared in HandleControlFrameHeadersComplete, which would be before it
// could be used.
decoded_block_.clear();
header_block_started_ = true;
if (handler_ != nullptr) {
handler_->OnHeaderBlockStart();
}
}
// Sometimes we get a call with headers_data==nullptr and
// headers_data_length==0, in which case we need to avoid creating
// a DecodeBuffer, which would otherwise complain.
if (headers_data_length > 0) {
DCHECK_NE(headers_data, nullptr);
total_hpack_bytes_ += headers_data_length;
DecodeBuffer db(headers_data, headers_data_length);
DecodeStatus status = hpack_block_decoder_.Decode(&db);
switch (status) {
case DecodeStatus::kDecodeDone:
// We've completed the decoding of headers_data, and it ended at the
// boundary between two HPACK block entries, so name_ and value_ are
// currently reset.
DCHECK_EQ(0u, db.Remaining());
in_progress_ = false;
break;
case DecodeStatus::kDecodeInProgress:
DCHECK_EQ(0u, db.Remaining());
in_progress_ = true;
if (!error_detected_) {
name_.BufferStringIfUnbuffered();
value_.BufferStringIfUnbuffered();
EnforceMaxDecodeBufferSize();
}
break;
case DecodeStatus::kDecodeError:
SetErrorDetected();
break;
}
}
return !error_detected_;
}
// Called after a HPACK block has been completely delivered via
// HandleControlFrameHeadersData(). Returns false if an error occurred.
// |compressed_len| if non-null will be set to the size of the encoded
// buffered block that was accumulated in HandleControlFrameHeadersData(),
// to support subsequent calculation of compression percentage.
// Discards the handler supplied at the start of decoding the block.
// TODO(jamessynge): Determine if compressed_len is needed; it is used to
// produce UUMA stat Net.SpdyHpackDecompressionPercentage, but only for
// SPDY3, not HTTP2.
bool HpackDecoder2::HandleControlFrameHeadersComplete(size_t* compressed_len) {
DVLOG(2) << "HpackDecoder2::HandleControlFrameHeadersComplete";
if (error_detected_ || in_progress_) {
DVLOG(2) << "error_detected_=" << error_detected_
<< ", in_progress_=" << in_progress_;
return false;
}
if (compressed_len != nullptr) {
*compressed_len = total_hpack_bytes_;
}
if (handler_ != nullptr) {
handler_->OnHeaderBlockEnd(total_header_bytes_);
}
Reset();
return true;
}
const SpdyHeaderBlock& HpackDecoder2::decoded_block() const {
return decoded_block_;
}
void HpackDecoder2::SetHeaderTableDebugVisitor(
std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor) {
DVLOG(2) << "HpackDecoder2::SetHeaderTableDebugVisitor";
header_table_.set_debug_visitor(std::move(visitor));
}
void HpackDecoder2::set_max_decode_buffer_size_bytes(
size_t max_decode_buffer_size_bytes) {
DVLOG(2) << "HpackDecoder2::set_max_decode_buffer_size_bytes";
max_decode_buffer_size_bytes_ = max_decode_buffer_size_bytes;
}
size_t HpackDecoder2::EstimateMemoryUsage() const {
return SpdyEstimateMemoryUsage(header_table_) +
SpdyEstimateMemoryUsage(decoded_block_) +
SpdyEstimateMemoryUsage(name_) + SpdyEstimateMemoryUsage(value_);
}
void HpackDecoder2::OnIndexedHeader(size_t index) {
DVLOG(2) << "HpackDecoder2::OnIndexedHeader: index=" << index;
DCHECK(!error_detected_);
const HpackEntry* entry = header_table_.GetByIndex(index);
if (entry == nullptr) {
SetErrorDetected();
return;
}
HandleHeaderRepresentation(entry->name(), entry->value());
}
void HpackDecoder2::OnStartLiteralHeader(HpackEntryType entry_type,
size_t maybe_name_index) {
DVLOG(2) << "HpackDecoder2::OnStartLiteralHeader: entry_type=" << entry_type
<< ", maybe_name_index=" << maybe_name_index;
DCHECK(!error_detected_);
entry_type_ = entry_type;
if (maybe_name_index > 0) {
const HpackEntry* entry = header_table_.GetByIndex(maybe_name_index);
if (entry == nullptr) {
SetErrorDetected();
return;
} else {
// Non-static entries could be evicted, leaving us with a dangling
// pointer, so we preemptively copy. This could be avoided if
// TryAddEntry would copy the strings prior to performing eviction.
name_.Set(entry->name(), entry->IsStatic());
name_.BufferStringIfUnbuffered();
}
}
}
void HpackDecoder2::OnNameStart(bool huffman_encoded, size_t len) {
DVLOG(2) << "HpackDecoder2::OnNameStart: huffman_encoded="
<< (huffman_encoded ? "true" : "false") << ", len=" << len;
if (len > max_decode_buffer_size_bytes_) {
DVLOG(1) << "Name length (" << len << ") is longer than permitted ("
<< max_decode_buffer_size_bytes_ << ")";
SetErrorDetected();
return;
}
name_.OnStart(huffman_encoded, len);
}
void HpackDecoder2::OnNameData(const char* data, size_t len) {
DVLOG(2) << "HpackDecoder2::OnNameData: len=" << len
<< "\n data: " << StringPiece(data, len);
if (error_detected_) {
return;
}
if (!name_.OnData(data, len)) {
SetErrorDetected();
}
}
void HpackDecoder2::OnNameEnd() {
DVLOG(2) << "HpackDecoder2::OnNameEnd";
if (error_detected_) {
return;
}
if (!name_.OnEnd()) {
SetErrorDetected();
}
}
void HpackDecoder2::OnValueStart(bool huffman_encoded, size_t len) {
DVLOG(2) << "HpackDecoder2::OnValueStart: huffman_encoded="
<< (huffman_encoded ? "true" : "false") << ", len=" << len;
if (len > max_decode_buffer_size_bytes_) {
DVLOG(1) << "Value length (" << len << ") is longer than permitted ("
<< max_decode_buffer_size_bytes_ << ")";
SetErrorDetected();
return;
}
value_.OnStart(huffman_encoded, len);
}
void HpackDecoder2::OnValueData(const char* data, size_t len) {
DVLOG(2) << "HpackDecoder2::OnValueData: len=" << len
<< "\n data: " << StringPiece(data, len);
if (error_detected_) {
return;
}
if (!value_.OnData(data, len)) {
SetErrorDetected();
}
}
void HpackDecoder2::OnValueEnd() {
DVLOG(2) << "HpackDecoder2::OnValueEnd";
if (error_detected_) {
return;
}
if (!value_.OnEnd()) {
SetErrorDetected();
return;
}
if (EnforceMaxDecodeBufferSize()) {
// All is well.
HandleHeaderRepresentation(name_.str(), value_.str());
if (entry_type_ == HpackEntryType::kIndexedLiteralHeader) {
header_table_.TryAddEntry(name_.str(), value_.str());
}
name_.Reset();
value_.Reset();
}
}
void HpackDecoder2::OnDynamicTableSizeUpdate(size_t size) {
DVLOG(2) << "HpackDecoder2::OnDynamicTableSizeUpdate: size=" << size;
if (error_detected_) {
return;
}
if (size > header_table_.settings_size_bound()) {
DVLOG(1) << "Dynamic Table Size Update with too large a size: " << size
<< " > " << header_table_.settings_size_bound();
SetErrorDetected();
return;
}
if (header_seen_) {
DVLOG(1) << "Dynamic Table Size Update seen after a Header";
SetErrorDetected();
return;
}
++size_update_count_;
if (size_update_count_ > 2) {
DVLOG(1) << "Too many (" << size_update_count_
<< ") Dynamic Table Size Updates";
SetErrorDetected();
return;
}
header_table_.SetMaxSize(size);
return;
}
bool HpackDecoder2::EnforceMaxDecodeBufferSize() {
if (!error_detected_) {
size_t buffered_length = name_.BufferedLength() + value_.BufferedLength();
DVLOG(2) << "buffered_length=" << buffered_length
<< "; max=" << max_decode_buffer_size_bytes_;
if (buffered_length > max_decode_buffer_size_bytes_) {
DVLOG(1) << "Header length (" << buffered_length
<< ") is longer than permitted ("
<< max_decode_buffer_size_bytes_ << ")";
SetErrorDetected();
}
}
return !error_detected_;
}
void HpackDecoder2::HandleHeaderRepresentation(StringPiece name,
StringPiece value) {
DVLOG(2) << "HpackDecoder2::HandleHeaderRepresentation:\n name: " << name
<< "\n value: " << value;
total_header_bytes_ += name.size() + value.size();
header_seen_ = true;
if (handler_ == nullptr) {
DVLOG(3) << "HpackDecoder2::HandleHeaderRepresentation "
<< "adding to decoded_block";
decoded_block_.AppendValueOrAddHeader(name, value);
} else {
DVLOG(3) << "HpackDecoder2::HandleHeaderRepresentation "
<< "passing to handler";
DCHECK(decoded_block_.empty());
handler_->OnHeader(name, value);
}
}
} // namespace net
net/spdy/hpack/hpack_decoder2.h deleted 100644 → 0
View file @ b857e84f
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_SPDY_HPACK_HPACK_DECODER2_H_
#define NET_SPDY_HPACK_HPACK_DECODER2_H_
// HpackDecoder2
// An HpackDecoder decodes header sets as outlined in
// http://tools.ietf.org/html/rfc7541. This implementation uses the
// new HpackBlockDecoder in //net/http2/hpack/
#include <stddef.h>
#include <memory>
#include <string>
#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "net/base/net_export.h"
#include "net/http2/hpack/decoder/hpack_block_decoder.h"
#include "net/http2/hpack/decoder/hpack_decoder_string_buffer.h"
#include "net/http2/hpack/decoder/hpack_entry_decoder_listener.h"
#include "net/http2/hpack/http2_hpack_constants.h"
#include "net/http2/hpack/huffman/http2_hpack_huffman_decoder.h"
#include "net/spdy/hpack/hpack_constants.h"
#include "net/spdy/hpack/hpack_decoder_interface.h"
#include "net/spdy/hpack/hpack_header_table.h"
#include "net/spdy/spdy_header_block.h"
#include "net/spdy/spdy_headers_handler_interface.h"
namespace net {
namespace test {
class HpackDecoder2Peer;
} // namespace test
class NET_EXPORT_PRIVATE HpackDecoder2 : public HpackDecoderInterface,
HpackEntryDecoderListener {
public:
friend test::HpackDecoder2Peer;
HpackDecoder2();
~HpackDecoder2() override;
// Override the interface methods:
void ApplyHeaderTableSizeSetting(size_t size_setting) override;
void HandleControlFrameHeadersStart(
SpdyHeadersHandlerInterface* handler) override;
bool HandleControlFrameHeadersData(const char* headers_data,
size_t headers_data_length) override;
bool HandleControlFrameHeadersComplete(size_t* compressed_len) override;
const SpdyHeaderBlock& decoded_block() const override;
void SetHeaderTableDebugVisitor(
std::unique_ptr<HpackHeaderTable::DebugVisitorInterface> visitor)
override;
void set_max_decode_buffer_size_bytes(
size_t max_decode_buffer_size_bytes) override;
size_t EstimateMemoryUsage() const override;
protected:
// Override the HpackEntryDecoderListener methods:
void OnIndexedHeader(size_t index) override;
void OnStartLiteralHeader(HpackEntryType entry_type,
size_t maybe_name_index) override;
void OnNameStart(bool huffman_encoded, size_t len) override;
void OnNameData(const char* data, size_t len) override;
void OnNameEnd() override;
void OnValueStart(bool huffman_encoded, size_t len) override;
void OnValueData(const char* data, size_t len) override;
void OnValueEnd() override;
void OnDynamicTableSizeUpdate(size_t size) override;
private:
// Called when a complete header entry has been decoded, with the name and
// value of the entry. If check_header_order_ is true, confirms that
// pseudo-headers don't appear after normal headers, else it treats the
// headers as malformed, as per sections 8.1.2.3. of the HTTP2 specification.
// Calls handler_->OnHeader() if there is a handler, else adds the header
// to decoded_block_.
void HandleHeaderRepresentation(base::StringPiece name,
base::StringPiece value);
// Reset state in preparation for decoding a new HPACK block. Does not reset
// the dynamic table.
void Reset();
// Called when an error is detected while decoding. Replaces the listener
// in the HpackBlockDecoder with the no-op listener.
void SetErrorDetected();
// Enforce the limit on the maximum size of strings that can be buffered.
// It happens that this test is made after the strings have been buffered,
// but that isn't a problem because we don't pass enormous buffers into
// HandleControlFrameHeadersData.
bool EnforceMaxDecodeBufferSize();
HpackHeaderTable header_table_;
SpdyHeaderBlock decoded_block_;
// Scratch space for storing decoded literals.
HpackDecoderStringBuffer name_, value_;
// If non-NULL, handles decoded headers.
SpdyHeadersHandlerInterface* handler_;
HpackEntryDecoderNoOpListener no_op_listener_;
// Total bytes that have been received as input (i.e. HPACK encoded).
size_t total_hpack_bytes_;
// Total bytes of the name and value strings in the current HPACK block.
size_t total_header_bytes_;
// How much encoded data this decoder is willing to buffer.
size_t max_decode_buffer_size_bytes_ = 32 * 1024; // 32 KB
HpackBlockDecoder hpack_block_decoder_;
// Count of Dynamic Table Size Updates seen in the current HPACK block.
uint32_t size_update_count_;
// The type of the current header entry (with literals) that is being decoded.
HpackEntryType entry_type_;
// Has a header been seen in the current HPACK block?
bool header_seen_;
// Did the HpackBlockDecoder stop in the middle of an entry?
bool in_progress_;
// Has an error been detected while decoding the HPACK block?
bool error_detected_;
// Flag to keep track of having seen the header block start. Needed at the
// moment because HandleControlFrameHeadersStart won't be called if a handler
// is not being provided by the caller.
// TODO(jamessynge): Consider collapsing several of these bools into a single
// enum representing the state of the decoding process.
bool header_block_started_;
DISALLOW_COPY_AND_ASSIGN(HpackDecoder2);
};
} // namespace net
#endif // NET_SPDY_HPACK_HPACK_DECODER2_H_
net/spdy/hpack/hpack_decoder2_test.cc deleted 100644 → 0
View file @ b857e84f
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/spdy/hpack/hpack_decoder2.h"
// Tests of HpackDecoder2.
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "base/logging.h"
#include "base/strings/string_piece.h"
#include "net/http2/hpack/tools/hpack_block_builder.h"
#include "net/http2/tools/http2_random.h"
#include "net/spdy/hpack/hpack_encoder.h"
#include "net/spdy/hpack/hpack_entry.h"
#include "net/spdy/hpack/hpack_huffman_table.h"
#include "net/spdy/hpack/hpack_output_stream.h"
#include "net/spdy/spdy_test_utils.h"
#include "testing/gtest/include/gtest/gtest.h"
using base::StringPiece;
using std::string;
namespace net {
namespace test {
class HpackDecoder2Peer {
public:
explicit HpackDecoder2Peer(HpackDecoder2* decoder) : decoder_(decoder) {}
void HandleHeaderRepresentation(StringPiece name, StringPiece value) {
decoder_->HandleHeaderRepresentation(name, value);
}
HpackHeaderTable* header_table() { return &decoder_->header_table_; }
private:
HpackDecoder2* decoder_;
};
namespace {
using testing::ElementsAre;
using testing::Pair;
// Is HandleControlFrameHeadersStart to be called, and with what value?
enum StartChoice { START_WITH_HANDLER, START_WITHOUT_HANDLER, NO_START };
class HpackDecoder2Test
: public ::testing::TestWithParam<std::tuple<StartChoice, bool>> {
protected:
HpackDecoder2Test() : decoder_(), decoder_peer_(&decoder_) {}
void SetUp() override {
std::tie(start_choice_, randomly_split_input_buffer_) = GetParam();
}
void HandleControlFrameHeadersStart() {
switch (start_choice_) {
case START_WITH_HANDLER:
decoder_.HandleControlFrameHeadersStart(&handler_);
break;
case START_WITHOUT_HANDLER:
decoder_.HandleControlFrameHeadersStart(nullptr);
break;
case NO_START:
break;
}
}
bool HandleControlFrameHeadersData(StringPiece str) {
return decoder_.HandleControlFrameHeadersData(str.data(), str.size());
}
bool HandleControlFrameHeadersComplete(size_t* size) {
return decoder_.HandleControlFrameHeadersComplete(size);
}
bool DecodeHeaderBlock(StringPiece str) {
// Don't call this again if HandleControlFrameHeadersData failed previously.
EXPECT_FALSE(decode_has_failed_);
HandleControlFrameHeadersStart();
if (randomly_split_input_buffer_) {
do {
// Decode some fragment of the remaining bytes.
size_t bytes = str.length();
if (!str.empty()) {
bytes = (random_.Rand8() % str.length()) + 1;
}
EXPECT_LE(bytes, str.length());
if (!HandleControlFrameHeadersData(str.substr(0, bytes))) {
decode_has_failed_ = true;
return false;
}
str.remove_prefix(bytes);
} while (!str.empty());
} else if (!HandleControlFrameHeadersData(str)) {
decode_has_failed_ = true;
return false;
}
if (!HandleControlFrameHeadersComplete(nullptr)) {
decode_has_failed_ = true;
return false;
}
return true;
}
const SpdyHeaderBlock& decoded_block() const {
if (start_choice_ == START_WITH_HANDLER) {
return handler_.decoded_block();
} else {
return decoder_.decoded_block();
}
}
const SpdyHeaderBlock& DecodeBlockExpectingSuccess(StringPiece str) {
EXPECT_TRUE(DecodeHeaderBlock(str));
return decoded_block();
}
void expectEntry(size_t index,
size_t size,
const string& name,
const string& value) {
const HpackEntry* entry = decoder_peer_.header_table()->GetByIndex(index);
EXPECT_EQ(name, entry->name()) << "index " << index;
EXPECT_EQ(value, entry->value());
EXPECT_EQ(size, entry->Size());
EXPECT_EQ(index, decoder_peer_.header_table()->IndexOf(entry));
}
SpdyHeaderBlock MakeHeaderBlock(
const std::vector<std::pair<string, string>>& headers) {
SpdyHeaderBlock result;
for (const auto& kv : headers) {
result.AppendValueOrAddHeader(kv.first, kv.second);
}
return result;
}
Http2Random random_;
HpackDecoder2 decoder_;
test::HpackDecoder2Peer decoder_peer_;
TestHeadersHandler handler_;
StartChoice start_choice_;
bool randomly_split_input_buffer_;
bool decode_has_failed_ = false;
};
INSTANTIATE_TEST_CASE_P(
StartChoiceAndRandomlySplitChoice,
HpackDecoder2Test,
::testing::Combine(
::testing::Values(START_WITH_HANDLER, START_WITHOUT_HANDLER, NO_START),
::testing::Bool()));
TEST_P(HpackDecoder2Test, AddHeaderDataWithHandleControlFrameHeadersData) {
// The hpack decode buffer size is limited in size. This test verifies that
// adding encoded data under that limit is accepted, and data that exceeds the
// limit is rejected.
HandleControlFrameHeadersStart();
const size_t kMaxBufferSizeBytes = 50;
const string a_value = string(49, 'x');
decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
{
HpackBlockBuilder hbb;
hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
false, "a", false, a_value);
const auto& s = hbb.buffer();
EXPECT_TRUE(decoder_.HandleControlFrameHeadersData(s.data(), s.size()));
}
{
HpackBlockBuilder hbb;
hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
false, "b", false, string(51, 'x'));
const auto& s = hbb.buffer();
EXPECT_FALSE(decoder_.HandleControlFrameHeadersData(s.data(), s.size()));
}
SpdyHeaderBlock expected_block = MakeHeaderBlock({{"a", a_value}});
EXPECT_EQ(expected_block, decoded_block());
}
TEST_P(HpackDecoder2Test, NameTooLong) {
// Verify that a name longer than the allowed size generates an error.
const size_t kMaxBufferSizeBytes = 50;
const string name = string(2 * kMaxBufferSizeBytes, 'x');
const string value = "abc";
decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
HpackBlockBuilder hbb;
hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
false, name, false, value);
const size_t fragment_size = (3 * kMaxBufferSizeBytes) / 2;
const string fragment = hbb.buffer().substr(0, fragment_size);
HandleControlFrameHeadersStart();
EXPECT_FALSE(HandleControlFrameHeadersData(fragment));
}
TEST_P(HpackDecoder2Test, HeaderTooLongToBuffer) {
// Verify that a header longer than the allowed size generates an error if
// it isn't all in one input buffer.
const string name = "some-key";
const string value = "some-value";
const size_t kMaxBufferSizeBytes = name.size() + value.size() - 2;
decoder_.set_max_decode_buffer_size_bytes(kMaxBufferSizeBytes);
HpackBlockBuilder hbb;
hbb.AppendLiteralNameAndValue(HpackEntryType::kNeverIndexedLiteralHeader,
false, name, false, value);
const size_t fragment_size = hbb.size() - 1;
const string fragment = hbb.buffer().substr(0, fragment_size);
HandleControlFrameHeadersStart();
EXPECT_FALSE(HandleControlFrameHeadersData(fragment));
}
// Decode with incomplete data in buffer.
TEST_P(HpackDecoder2Test, DecodeWithIncompleteData) {
HandleControlFrameHeadersStart();
// No need to wait for more data.
EXPECT_TRUE(HandleControlFrameHeadersData("\x82\x85\x82"));
std::vector<std::pair<string, string>> expected_headers = {
{":method", "GET"}, {":path", "/index.html"}, {":method", "GET"}};
SpdyHeaderBlock expected_block1 = MakeHeaderBlock(expected_headers);
EXPECT_EQ(expected_block1, decoded_block());
// Full and partial headers, won't add partial to the headers.
EXPECT_TRUE(
HandleControlFrameHeadersData("\x40\x03goo"
"\x03gar\xbe\x40\x04spam"));
expected_headers.push_back({"goo", "gar"});
expected_headers.push_back({"goo", "gar"});
SpdyHeaderBlock expected_block2 = MakeHeaderBlock(expected_headers);
EXPECT_EQ(expected_block2, decoded_block());
// Add the needed data.
EXPECT_TRUE(HandleControlFrameHeadersData("\x04gggs"));
size_t size = 0;
EXPECT_TRUE(HandleControlFrameHeadersComplete(&size));
EXPECT_EQ(24u, size);
expected_headers.push_back({"spam", "gggs"});
SpdyHeaderBlock expected_block3 = MakeHeaderBlock(expected_headers);
EXPECT_EQ(expected_block3, decoded_block());
}
TEST_P(HpackDecoder2Test, HandleHeaderRepresentation) {
// Make sure the decoder is properly initialized.
HandleControlFrameHeadersStart();
HandleControlFrameHeadersData("");
// All cookie crumbs are joined.
decoder_peer_.HandleHeaderRepresentation("cookie", " part 1");
decoder_peer_.HandleHeaderRepresentation("cookie", "part 2 ");
decoder_peer_.HandleHeaderRepresentation("cookie", "part3");
// Already-delimited headers are passed through.
decoder_peer_.HandleHeaderRepresentation("passed-through",
string("foo\0baz", 7));
// Other headers are joined on \0. Case matters.
decoder_peer_.HandleHeaderRepresentation("joined", "not joined");
decoder_peer_.HandleHeaderRepresentation("joineD", "value 1");
decoder_peer_.HandleHeaderRepresentation("joineD", "value 2");
// Empty headers remain empty.
decoder_peer_.HandleHeaderRepresentation("empty", "");
// Joined empty headers work as expected.
decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
decoder_peer_.HandleHeaderRepresentation("empty-joined", "foo");
decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
decoder_peer_.HandleHeaderRepresentation("empty-joined", "");
// Non-contiguous cookie crumb.
decoder_peer_.HandleHeaderRepresentation("cookie", " fin!");
// Finish and emit all headers.
decoder_.HandleControlFrameHeadersComplete(nullptr);
// Resulting decoded headers are in the same order as the inputs.
EXPECT_THAT(decoded_block(),
ElementsAre(Pair("cookie", " part 1; part 2 ; part3; fin!"),
Pair("passed-through", StringPiece("foo\0baz", 7)),
Pair("joined", "not joined"),
Pair("joineD", StringPiece("value 1\0value 2", 15)),
Pair("empty", ""),
Pair("empty-joined", StringPiece("\0foo\0\0", 6))));
}
// Decoding indexed static table field should work.
TEST_P(HpackDecoder2Test, IndexedHeaderStatic) {
// Reference static table entries #2 and #5.
const SpdyHeaderBlock& header_set1 = DecodeBlockExpectingSuccess("\x82\x85");
SpdyHeaderBlock expected_header_set1;
expected_header_set1[":method"] = "GET";
expected_header_set1[":path"] = "/index.html";
EXPECT_EQ(expected_header_set1, header_set1);
// Reference static table entry #2.
const SpdyHeaderBlock& header_set2 = DecodeBlockExpectingSuccess("\x82");
SpdyHeaderBlock expected_header_set2;
expected_header_set2[":method"] = "GET";
EXPECT_EQ(expected_header_set2, header_set2);
}
TEST_P(HpackDecoder2Test, IndexedHeaderDynamic) {
// First header block: add an entry to header table.
const SpdyHeaderBlock& header_set1 = DecodeBlockExpectingSuccess(
"\x40\x03"
"foo"
"\x03"
"bar");
SpdyHeaderBlock expected_header_set1;
expected_header_set1["foo"] = "bar";
EXPECT_EQ(expected_header_set1, header_set1);
// Second header block: add another entry to header table.
const SpdyHeaderBlock& header_set2 = DecodeBlockExpectingSuccess(
"\xbe\x40\x04"
"spam"
"\x04"
"eggs");
SpdyHeaderBlock expected_header_set2;
expected_header_set2["foo"] = "bar";
expected_header_set2["spam"] = "eggs";
EXPECT_EQ(expected_header_set2, header_set2);
// Third header block: refer to most recently added entry.
const SpdyHeaderBlock& header_set3 = DecodeBlockExpectingSuccess("\xbe");
SpdyHeaderBlock expected_header_set3;
expected_header_set3["spam"] = "eggs";
EXPECT_EQ(expected_header_set3, header_set3);
}
// Test a too-large indexed header.
TEST_P(HpackDecoder2Test, InvalidIndexedHeader) {
// High-bit set, and a prefix of one more than the number of static entries.
EXPECT_FALSE(DecodeHeaderBlock("\xbe"));
}
TEST_P(HpackDecoder2Test, ContextUpdateMaximumSize) {
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table()->max_size());
string input;
{
// Maximum-size update with size 126. Succeeds.
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(126);
output_stream.TakeString(&input);
EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(126u, decoder_peer_.header_table()->max_size());
}
{
// Maximum-size update with kDefaultHeaderTableSizeSetting. Succeeds.
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting);
output_stream.TakeString(&input);
EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table()->max_size());
}
{
// Maximum-size update with kDefaultHeaderTableSizeSetting + 1. Fails.
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(kDefaultHeaderTableSizeSetting + 1);
output_stream.TakeString(&input);
EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table()->max_size());
}
}
// Two HeaderTableSizeUpdates may appear at the beginning of the block
TEST_P(HpackDecoder2Test, TwoTableSizeUpdates) {
string input;
{
// Should accept two table size updates, update to second one
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(0);
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(122);
output_stream.TakeString(&input);
EXPECT_TRUE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(122u, decoder_peer_.header_table()->max_size());
}
}
// Three HeaderTableSizeUpdates should result in an error
TEST_P(HpackDecoder2Test, ThreeTableSizeUpdatesError) {
string input;
{
// Should reject three table size updates, update to second one
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(5);
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(10);
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(15);
output_stream.TakeString(&input);
EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(10u, decoder_peer_.header_table()->max_size());
}
}
// HeaderTableSizeUpdates may only appear at the beginning of the block
// Any other updates should result in an error
TEST_P(HpackDecoder2Test, TableSizeUpdateSecondError) {
string input;
{
// Should reject a table size update appearing after a different entry
// The table size should remain as the default
HpackOutputStream output_stream;
output_stream.AppendBytes("\x82\x85");
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(123);
output_stream.TakeString(&input);
EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(kDefaultHeaderTableSizeSetting,
decoder_peer_.header_table()->max_size());
}
}
// HeaderTableSizeUpdates may only appear at the beginning of the block
// Any other updates should result in an error
TEST_P(HpackDecoder2Test, TableSizeUpdateFirstThirdError) {
string input;
{
// Should reject the second table size update
// if a different entry appears after the first update
// The table size should update to the first but not the second
HpackOutputStream output_stream;
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(60);
output_stream.AppendBytes("\x82\x85");
output_stream.AppendPrefix(kHeaderTableSizeUpdateOpcode);
output_stream.AppendUint32(125);
output_stream.TakeString(&input);
EXPECT_FALSE(DecodeHeaderBlock(StringPiece(input)));
EXPECT_EQ(60u, decoder_peer_.header_table()->max_size());
}
}
// Decoding two valid encoded literal headers with no indexing should
// work.
TEST_P(HpackDecoder2Test, LiteralHeaderNoIndexing) {
// First header with indexed name, second header with string literal
// name.
const char input[] = "\x04\x0c/sample/path\x00\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set =
DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
expected_header_set[":path2"] = "/sample/path/2";
EXPECT_EQ(expected_header_set, header_set);
}
// Decoding two valid encoded literal headers with incremental
// indexing and string literal names should work.
TEST_P(HpackDecoder2Test, LiteralHeaderIncrementalIndexing) {
const char input[] = "\x44\x0c/sample/path\x40\x06:path2\x0e/sample/path/2";
const SpdyHeaderBlock& header_set =
DecodeBlockExpectingSuccess(StringPiece(input, arraysize(input) - 1));
SpdyHeaderBlock expected_header_set;
expected_header_set[":path"] = "/sample/path";
expected_header_set[":path2"] = "/sample/path/2";
EXPECT_EQ(expected_header_set, header_set);
}
TEST_P(HpackDecoder2Test, LiteralHeaderWithIndexingInvalidNameIndex) {
decoder_.ApplyHeaderTableSizeSetting(0);
// Name is the last static index. Works.
EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x7d\x03ooo")));
// Name is one beyond the last static index. Fails.
EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x7e\x03ooo")));
}
TEST_P(HpackDecoder2Test, LiteralHeaderNoIndexingInvalidNameIndex) {
// Name is the last static index. Works.
EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x0f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x0f\x2f\x03ooo")));
}
TEST_P(HpackDecoder2Test, LiteralHeaderNeverIndexedInvalidNameIndex) {
// Name is the last static index. Works.
EXPECT_TRUE(DecodeHeaderBlock(StringPiece("\x1f\x2e\x03ooo")));
// Name is one beyond the last static index. Fails.
EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\x1f\x2f\x03ooo")));
}
TEST_P(HpackDecoder2Test, TruncatedIndex) {
// Indexed Header, varint for index requires multiple bytes,
// but only one provided.
EXPECT_FALSE(DecodeHeaderBlock(StringPiece("\xff", 1)));
}
TEST_P(HpackDecoder2Test, TruncatedHuffmanLiteral) {
// Literal value, Huffman encoded, but with the last byte missing (i.e.
// drop the final ff shown below).
//
// 41 | == Literal indexed ==
// | Indexed name (idx = 1)
// | :authority
// 8c | Literal value (len = 12)
// | Huffman encoded:
// f1e3 c2e5 f23a 6ba0 ab90 f4ff | .....:k.....
// | Decoded:
// | www.example.com
// | -> :authority: www.example.com
string first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
EXPECT_TRUE(DecodeHeaderBlock(first));
first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4");
EXPECT_FALSE(DecodeHeaderBlock(first));
}
TEST_P(HpackDecoder2Test, HuffmanEOSError) {
// Literal value, Huffman encoded, but with an additional ff byte at the end
// of the string, i.e. an EOS that is longer than permitted.
//
// 41 | == Literal indexed ==
// | Indexed name (idx = 1)
// | :authority
// 8d | Literal value (len = 13)
// | Huffman encoded:
// f1e3 c2e5 f23a 6ba0 ab90 f4ff | .....:k.....
// | Decoded:
// | www.example.com
// | -> :authority: www.example.com
string first = a2b_hex("418cf1e3c2e5f23a6ba0ab90f4ff");
EXPECT_TRUE(DecodeHeaderBlock(first));
first = a2b_hex("418df1e3c2e5f23a6ba0ab90f4ffff");
EXPECT_FALSE(DecodeHeaderBlock(first));
}
// Round-tripping the header set from RFC 7541 C.3.1 should work.
// http://httpwg.org/specs/rfc7541.html#rfc.section.C.3.1
TEST_P(HpackDecoder2Test, BasicC31) {
HpackEncoder encoder(ObtainHpackHuffmanTable());
SpdyHeaderBlock expected_header_set;
expected_header_set[":method"] = "GET";
expected_header_set[":scheme"] = "http";
expected_header_set[":path"] = "/";
expected_header_set[":authority"] = "www.example.com";
string encoded_header_set;
EXPECT_TRUE(
encoder.EncodeHeaderSet(expected_header_set, &encoded_header_set));
EXPECT_TRUE(DecodeHeaderBlock(encoded_header_set));
EXPECT_EQ(expected_header_set, decoded_block());
}
// RFC 7541, Section C.4: Request Examples with Huffman Coding
// http://httpwg.org/specs/rfc7541.html#rfc.section.C.4
TEST_P(HpackDecoder2Test, SectionC4RequestHuffmanExamples) {
// TODO(jamessynge): Use net/http2/hpack/tools/hpack_example.h to parse the
// example directly, instead of having it as a comment.
// 82 | == Indexed - Add ==
// | idx = 2
// | -> :method: GET
// 86 | == Indexed - Add ==
// | idx = 6
// | -> :scheme: http
// 84 | == Indexed - Add ==
// | idx = 4
// | -> :path: /
// 41 | == Literal indexed ==
// | Indexed name (idx = 1)
// | :authority
// 8c | Literal value (len = 12)
// | Huffman encoded:
// f1e3 c2e5 f23a 6ba0 ab90 f4ff | .....:k.....
// | Decoded:
// | www.example.com
// | -> :authority: www.example.com
string first = a2b_hex("828684418cf1e3c2e5f23a6ba0ab90f4ff");
const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
EXPECT_THAT(first_header_set,
ElementsAre(
// clang-format off
Pair(":method", "GET"),
Pair(":scheme", "http"),
Pair(":path", "/"),
Pair(":authority", "www.example.com")));
// clang-format on
expectEntry(62, 57, ":authority", "www.example.com");
EXPECT_EQ(57u, decoder_peer_.header_table()->size());
// 82 | == Indexed - Add ==
// | idx = 2
// | -> :method: GET
// 86 | == Indexed - Add ==
// | idx = 6
// | -> :scheme: http
// 84 | == Indexed - Add ==
// | idx = 4
// | -> :path: /
// be | == Indexed - Add ==
// | idx = 62
// | -> :authority: www.example.com
// 58 | == Literal indexed ==
// | Indexed name (idx = 24)
// | cache-control
// 86 | Literal value (len = 8)
// | Huffman encoded:
// a8eb 1064 9cbf | ...d..
// | Decoded:
// | no-cache
// | -> cache-control: no-cache
string second = a2b_hex("828684be5886a8eb10649cbf");
const SpdyHeaderBlock& second_header_set =
DecodeBlockExpectingSuccess(second);
EXPECT_THAT(second_header_set,
ElementsAre(
// clang-format off
Pair(":method", "GET"),
Pair(":scheme", "http"),
Pair(":path", "/"),
Pair(":authority", "www.example.com"),
Pair("cache-control", "no-cache")));
// clang-format on
expectEntry(62, 53, "cache-control", "no-cache");
expectEntry(63, 57, ":authority", "www.example.com");
EXPECT_EQ(110u, decoder_peer_.header_table()->size());
// 82 | == Indexed - Add ==
// | idx = 2
// | -> :method: GET
// 87 | == Indexed - Add ==
// | idx = 7
// | -> :scheme: https
// 85 | == Indexed - Add ==
// | idx = 5
// | -> :path: /index.html
// bf | == Indexed - Add ==
// | idx = 63
// | -> :authority: www.example.com
// 40 | == Literal indexed ==
// 88 | Literal name (len = 10)
// | Huffman encoded:
// 25a8 49e9 5ba9 7d7f | %.I.[.}.
// | Decoded:
// | custom-key
// 89 | Literal value (len = 12)
// | Huffman encoded:
// 25a8 49e9 5bb8 e8b4 bf | %.I.[....
// | Decoded:
// | custom-value
// | -> custom-key: custom-value
string third = a2b_hex("828785bf408825a849e95ba97d7f8925a849e95bb8e8b4bf");
const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
EXPECT_THAT(
third_header_set,
ElementsAre(
// clang-format off
Pair(":method", "GET"),
Pair(":scheme", "https"),
Pair(":path", "/index.html"),
Pair(":authority", "www.example.com"),
Pair("custom-key", "custom-value")));
// clang-format on
expectEntry(62, 54, "custom-key", "custom-value");
expectEntry(63, 53, "cache-control", "no-cache");
expectEntry(64, 57, ":authority", "www.example.com");
EXPECT_EQ(164u, decoder_peer_.header_table()->size());
}
// RFC 7541, Section C.6: Response Examples with Huffman Coding
// http://httpwg.org/specs/rfc7541.html#rfc.section.C.6
TEST_P(HpackDecoder2Test, SectionC6ResponseHuffmanExamples) {
decoder_.ApplyHeaderTableSizeSetting(256);
// 48 | == Literal indexed ==
// | Indexed name (idx = 8)
// | :status
// 82 | Literal value (len = 3)
// | Huffman encoded:
// 6402 | d.
// | Decoded:
// | 302
// | -> :status: 302
// 58 | == Literal indexed ==
// | Indexed name (idx = 24)
// | cache-control
// 85 | Literal value (len = 7)
// | Huffman encoded:
// aec3 771a 4b | ..w.K
// | Decoded:
// | private
// | -> cache-control: private
// 61 | == Literal indexed ==
// | Indexed name (idx = 33)
// | date
// 96 | Literal value (len = 29)
// | Huffman encoded:
// d07a be94 1054 d444 a820 0595 040b 8166 | .z...T.D. .....f
// e082 a62d 1bff | ...-..
// | Decoded:
// | Mon, 21 Oct 2013 20:13:21
// | GMT
// | -> date: Mon, 21 Oct 2013
// | 20:13:21 GMT
// 6e | == Literal indexed ==
// | Indexed name (idx = 46)
// | location
// 91 | Literal value (len = 23)
// | Huffman encoded:
// 9d29 ad17 1863 c78f 0b97 c8e9 ae82 ae43 | .)...c.........C
// d3 | .
// | Decoded:
// | https://www.example.com
// | -> location: https://www.e
// | xample.com
string first = a2b_hex(
"488264025885aec3771a4b6196d07abe"
"941054d444a8200595040b8166e082a6"
"2d1bff6e919d29ad171863c78f0b97c8"
"e9ae82ae43d3");
const SpdyHeaderBlock& first_header_set = DecodeBlockExpectingSuccess(first);
EXPECT_THAT(first_header_set,
ElementsAre(
// clang-format off
Pair(":status", "302"),
Pair("cache-control", "private"),
Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
Pair("location", "https://www.example.com")));
// clang-format on
expectEntry(62, 63, "location", "https://www.example.com");
expectEntry(63, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
expectEntry(64, 52, "cache-control", "private");
expectEntry(65, 42, ":status", "302");
EXPECT_EQ(222u, decoder_peer_.header_table()->size());
// 48 | == Literal indexed ==
// | Indexed name (idx = 8)
// | :status
// 83 | Literal value (len = 3)
// | Huffman encoded:
// 640e ff | d..
// | Decoded:
// | 307
// | - evict: :status: 302
// | -> :status: 307
// c1 | == Indexed - Add ==
// | idx = 65
// | -> cache-control: private
// c0 | == Indexed - Add ==
// | idx = 64
// | -> date: Mon, 21 Oct 2013
// | 20:13:21 GMT
// bf | == Indexed - Add ==
// | idx = 63
// | -> location:
// | https://www.example.com
string second = a2b_hex("4883640effc1c0bf");
const SpdyHeaderBlock& second_header_set =
DecodeBlockExpectingSuccess(second);
EXPECT_THAT(second_header_set,
ElementsAre(
// clang-format off
Pair(":status", "307"),
Pair("cache-control", "private"),
Pair("date", "Mon, 21 Oct 2013 20:13:21 GMT"),
Pair("location", "https://www.example.com")));
// clang-format on
expectEntry(62, 42, ":status", "307");
expectEntry(63, 63, "location", "https://www.example.com");
expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:21 GMT");
expectEntry(65, 52, "cache-control", "private");
EXPECT_EQ(222u, decoder_peer_.header_table()->size());
// 88 | == Indexed - Add ==
// | idx = 8
// | -> :status: 200
// c1 | == Indexed - Add ==
// | idx = 65
// | -> cache-control: private
// 61 | == Literal indexed ==
// | Indexed name (idx = 33)
// | date
// 96 | Literal value (len = 22)
// | Huffman encoded:
// d07a be94 1054 d444 a820 0595 040b 8166 | .z...T.D. .....f
// e084 a62d 1bff | ...-..
// | Decoded:
// | Mon, 21 Oct 2013 20:13:22
// | GMT
// | - evict: cache-control:
// | private
// | -> date: Mon, 21 Oct 2013
// | 20:13:22 GMT
// c0 | == Indexed - Add ==
// | idx = 64
// | -> location:
// | https://www.example.com
// 5a | == Literal indexed ==
// | Indexed name (idx = 26)
// | content-encoding
// 83 | Literal value (len = 3)
// | Huffman encoded:
// 9bd9 ab | ...
// | Decoded:
// | gzip
// | - evict: date: Mon, 21 Oct
// | 2013 20:13:21 GMT
// | -> content-encoding: gzip
// 77 | == Literal indexed ==
// | Indexed name (idx = 55)
// | set-cookie
// ad | Literal value (len = 45)
// | Huffman encoded:
// 94e7 821d d7f2 e6c7 b335 dfdf cd5b 3960 | .........5...[9`
// d5af 2708 7f36 72c1 ab27 0fb5 291f 9587 | ..'..6r..'..)...
// 3160 65c0 03ed 4ee5 b106 3d50 07 | 1`e...N...=P.
// | Decoded:
// | foo=ASDJKHQKBZXOQWEOPIUAXQ
// | WEOIU; max-age=3600; versi
// | on=1
// | - evict: location:
// | https://www.example.com
// | - evict: :status: 307
// | -> set-cookie: foo=ASDJKHQ
// | KBZXOQWEOPIUAXQWEOIU;
// | max-age=3600; version=1
string third = a2b_hex(
"88c16196d07abe941054d444a8200595"
"040b8166e084a62d1bffc05a839bd9ab"
"77ad94e7821dd7f2e6c7b335dfdfcd5b"
"3960d5af27087f3672c1ab270fb5291f"
"9587316065c003ed4ee5b1063d5007");
const SpdyHeaderBlock& third_header_set = DecodeBlockExpectingSuccess(third);
EXPECT_THAT(third_header_set,
ElementsAre(
// clang-format off
Pair(":status", "200"),
Pair("cache-control", "private"),
Pair("date", "Mon, 21 Oct 2013 20:13:22 GMT"),
Pair("location", "https://www.example.com"),
Pair("content-encoding", "gzip"),
Pair("set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
" max-age=3600; version=1")));
// clang-format on
expectEntry(62, 98, "set-cookie",
"foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU;"
" max-age=3600; version=1");
expectEntry(63, 52, "content-encoding", "gzip");
expectEntry(64, 65, "date", "Mon, 21 Oct 2013 20:13:22 GMT");
EXPECT_EQ(215u, decoder_peer_.header_table()->size());
}
// Regression test: Found that entries with dynamic indexed names and literal
// values caused "use after free" MSAN failures if the name was evicted as it
// was being re-used.
TEST_P(HpackDecoder2Test, ReuseNameOfEvictedEntry) {
// Each entry is measured as 32 bytes plus the sum of the lengths of the name
// and the value. Set the size big enough for at most one entry, and a fairly
// small one at that (31 ASCII characters).
decoder_.ApplyHeaderTableSizeSetting(63);
HpackBlockBuilder hbb;
const StringPiece name("some-name");
const StringPiece value1("some-value");
const StringPiece value2("another-value");
const StringPiece value3("yet-another-value");
// Add an entry that will become the first in the dynamic table, entry 62.
hbb.AppendLiteralNameAndValue(HpackEntryType::kIndexedLiteralHeader, false,
name, false, value1);
// Confirm that entry has been added by re-using it.
hbb.AppendIndexedHeader(62);
// Add another entry referring to the name of the first. This will evict the
// first.
hbb.AppendNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader, 62,
false, value2);
// Confirm that entry has been added by re-using it.
hbb.AppendIndexedHeader(62);
// Add another entry referring to the name of the second. This will evict the
// second.
hbb.AppendNameIndexAndLiteralValue(HpackEntryType::kIndexedLiteralHeader, 62,
false, value3);
// Confirm that entry has been added by re-using it.
hbb.AppendIndexedHeader(62);
EXPECT_TRUE(DecodeHeaderBlock(hbb.buffer()));
SpdyHeaderBlock expected_header_set;
expected_header_set.AppendValueOrAddHeader(name, value1);
expected_header_set.AppendValueOrAddHeader(name, value1);
expected_header_set.AppendValueOrAddHeader(name, value2);
expected_header_set.AppendValueOrAddHeader(name, value2);
expected_header_set.AppendValueOrAddHeader(name, value3);
expected_header_set.AppendValueOrAddHeader(name, value3);
// SpdyHeaderBlock stores these 6 strings as '\0' separated values.
// Make sure that is what happened.
string joined_values = expected_header_set[name].as_string();
EXPECT_EQ(joined_values.size(),
2 * value1.size() + 2 * value2.size() + 2 * value3.size() + 5);
EXPECT_EQ(expected_header_set, decoded_block());
}
} // namespace
} // namespace test
} // namespace net
net/spdy/spdy_flags.cc
View file @ a136ffb8
...@@ -12,9 +12,6 @@ bool FLAGS_chromium_http2_flag_log_compressed_size = true; ...@@ -12,9 +12,6 @@ bool FLAGS_chromium_http2_flag_log_compressed_size = true;
// If true, remove use of SpdyFrameBuilder::OverwriteLength(). // If true, remove use of SpdyFrameBuilder::OverwriteLength().
bool FLAGS_chromium_http2_flag_remove_rewritelength = true; bool FLAGS_chromium_http2_flag_remove_rewritelength = true;
// Use //net/http2/hpack/decoder as HPACK entry decoder.
bool FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
// Use //net/http2/hpack/decoder as complete HPACK decoder. // Use //net/http2/hpack/decoder as complete HPACK decoder.
bool FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true; bool FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true;
......
net/spdy/spdy_flags.h
View file @ a136ffb8
...@@ -11,8 +11,6 @@ namespace net { ...@@ -11,8 +11,6 @@ namespace net {
NET_EXPORT_PRIVATE extern bool FLAGS_chromium_http2_flag_log_compressed_size; NET_EXPORT_PRIVATE extern bool FLAGS_chromium_http2_flag_log_compressed_size;
NET_EXPORT_PRIVATE extern bool FLAGS_chromium_http2_flag_remove_rewritelength; NET_EXPORT_PRIVATE extern bool FLAGS_chromium_http2_flag_remove_rewritelength;
NET_EXPORT_PRIVATE extern bool
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2;
NET_EXPORT_PRIVATE extern bool NET_EXPORT_PRIVATE extern bool
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3; FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3;
NET_EXPORT_PRIVATE extern bool FLAGS_use_http2_frame_decoder_adapter; NET_EXPORT_PRIVATE extern bool FLAGS_use_http2_frame_decoder_adapter;
......
net/spdy/spdy_framer.cc
View file @ a136ffb8
...@@ -25,7 +25,6 @@ ...@@ -25,7 +25,6 @@
#include "net/quic/core/quic_flags.h" #include "net/quic/core/quic_flags.h"
#include "net/spdy/hpack/hpack_constants.h" #include "net/spdy/hpack/hpack_constants.h"
#include "net/spdy/hpack/hpack_decoder.h" #include "net/spdy/hpack/hpack_decoder.h"
#include "net/spdy/hpack/hpack_decoder2.h"
#include "net/spdy/hpack/hpack_decoder3.h" #include "net/spdy/hpack/hpack_decoder3.h"
#include "net/spdy/http2_frame_decoder_adapter.h" #include "net/spdy/http2_frame_decoder_adapter.h"
#include "net/spdy/platform/api/spdy_estimate_memory_usage.h" #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
...@@ -2403,11 +2402,7 @@ HpackEncoder* SpdyFramer::GetHpackEncoder() { ...@@ -2403,11 +2402,7 @@ HpackEncoder* SpdyFramer::GetHpackEncoder() {
HpackDecoderInterface* SpdyFramer::GetHpackDecoder() { HpackDecoderInterface* SpdyFramer::GetHpackDecoder() {
if (hpack_decoder_.get() == nullptr) { if (hpack_decoder_.get() == nullptr) {
if (FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3) { if (FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3) {
SPDY_BUG_IF(FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2)
<< "Both alternate decoders are enabled.";
hpack_decoder_.reset(new HpackDecoder3()); hpack_decoder_.reset(new HpackDecoder3());
} else if (FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2) {
hpack_decoder_.reset(new HpackDecoder2());
} else { } else {
hpack_decoder_.reset(new HpackDecoder()); hpack_decoder_.reset(new HpackDecoder());
} }
......
net/spdy/spdy_framer_test.cc
View file @ a136ffb8
...@@ -636,7 +636,7 @@ StringPiece GetSerializedHeaders(const SpdySerializedFrame& frame, ...@@ -636,7 +636,7 @@ StringPiece GetSerializedHeaders(const SpdySerializedFrame& frame,
} }
enum DecoderChoice { DECODER_SELF, DECODER_NESTED, DECODER_HTTP2 }; enum DecoderChoice { DECODER_SELF, DECODER_NESTED, DECODER_HTTP2 };
enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3 }; enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_3 };
class SpdyFramerTest class SpdyFramerTest
: public ::testing::TestWithParam<std::tuple<DecoderChoice, HpackChoice>> { : public ::testing::TestWithParam<std::tuple<DecoderChoice, HpackChoice>> {
...@@ -659,15 +659,9 @@ class SpdyFramerTest ...@@ -659,15 +659,9 @@ class SpdyFramerTest
} }
switch (std::get<1>(param)) { switch (std::get<1>(param)) {
case HPACK_DECODER_1: case HPACK_DECODER_1:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
break;
case HPACK_DECODER_2:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false; FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = false;
break; break;
case HPACK_DECODER_3: case HPACK_DECODER_3:
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true; FLAGS_chromium_http2_flag_spdy_use_hpack_decoder3 = true;
break; break;
} }
...@@ -695,12 +689,13 @@ class SpdyFramerTest ...@@ -695,12 +689,13 @@ class SpdyFramerTest
} }
}; };
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(SpdyFramerTests,
SpdyFramerTests,
SpdyFramerTest, SpdyFramerTest,
::testing::Combine( ::testing::Combine(::testing::Values(DECODER_SELF,
::testing::Values(DECODER_SELF, DECODER_NESTED, DECODER_HTTP2), DECODER_NESTED,
::testing::Values(HPACK_DECODER_1, HPACK_DECODER_2, HPACK_DECODER_3))); DECODER_HTTP2),
::testing::Values(HPACK_DECODER_1,
HPACK_DECODER_3)));
// Test that we can encode and decode a SpdyHeaderBlock in serialized form. // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
TEST_P(SpdyFramerTest, HeaderBlockInBuffer) { TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment