blob: 73d50075ad305efc7c8a9f1f153b5a145ee39270 [file] [log] [blame]
// Copyright (c) 2018 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.
// Decoder to test QPACK Offline Interop corpus
//
// See https://github.com/quicwg/base-drafts/wiki/QPACK-Offline-Interop for
// description of test data format.
//
// Example usage
//
// cd $TEST_DATA
// git clone https://github.com/qpackers/qifs.git
// TEST_ENCODED_DATA=$TEST_DATA/qifs/encoded/qpack-06
// TEST_QIF_DATA=$TEST_DATA/qifs/qifs
// $BIN/qpack_offline_decoder \
// $TEST_ENCODED_DATA/f5/fb-req.qifencoded.4096.100.0 \
// $TEST_QIF_DATA/fb-req.qif
// $TEST_ENCODED_DATA/h2o/fb-req-hq.out.512.0.1 \
// $TEST_QIF_DATA/fb-req-hq.qif
// $TEST_ENCODED_DATA/ls-qpack/fb-resp-hq.out.0.0.0 \
// $TEST_QIF_DATA/fb-resp-hq.qif
// $TEST_ENCODED_DATA/proxygen/netbsd.qif.proxygen.out.4096.0.0 \
// $TEST_QIF_DATA/netbsd.qif
//
#include "quiche/quic/test_tools/qpack/qpack_offline_decoder.h"
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/match.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/quic/test_tools/qpack/qpack_test_utils.h"
#include "quiche/common/platform/api/quiche_file_utils.h"
#include "quiche/common/quiche_endian.h"
namespace quic {
QpackOfflineDecoder::QpackOfflineDecoder()
: encoder_stream_error_detected_(false) {}
bool QpackOfflineDecoder::DecodeAndVerifyOfflineData(
absl::string_view input_filename,
absl::string_view expected_headers_filename) {
if (!ParseInputFilename(input_filename)) {
QUIC_LOG(ERROR) << "Error parsing input filename " << input_filename;
return false;
}
if (!DecodeHeaderBlocksFromFile(input_filename)) {
QUIC_LOG(ERROR) << "Error decoding header blocks in " << input_filename;
return false;
}
if (!VerifyDecodedHeaderLists(expected_headers_filename)) {
QUIC_LOG(ERROR) << "Header lists decoded from " << input_filename
<< " to not match expected headers parsed from "
<< expected_headers_filename;
return false;
}
return true;
}
void QpackOfflineDecoder::OnEncoderStreamError(
QuicErrorCode error_code, absl::string_view error_message) {
QUIC_LOG(ERROR) << "Encoder stream error: "
<< QuicErrorCodeToString(error_code) << " " << error_message;
encoder_stream_error_detected_ = true;
}
bool QpackOfflineDecoder::ParseInputFilename(absl::string_view input_filename) {
std::vector<absl::string_view> pieces = absl::StrSplit(input_filename, '.');
if (pieces.size() < 3) {
QUIC_LOG(ERROR) << "Not enough fields in input filename " << input_filename;
return false;
}
auto piece_it = pieces.rbegin();
// Acknowledgement mode: 1 for immediate, 0 for none.
if (*piece_it != "0" && *piece_it != "1") {
QUIC_LOG(ERROR)
<< "Header acknowledgement field must be 0 or 1 in input filename "
<< input_filename;
return false;
}
++piece_it;
// Maximum allowed number of blocked streams.
uint64_t max_blocked_streams = 0;
if (!absl::SimpleAtoi(*piece_it, &max_blocked_streams)) {
QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
<< "\" as an integer.";
return false;
}
++piece_it;
// Maximum Dynamic Table Capacity in bytes
uint64_t maximum_dynamic_table_capacity = 0;
if (!absl::SimpleAtoi(*piece_it, &maximum_dynamic_table_capacity)) {
QUIC_LOG(ERROR) << "Error parsing part of input filename \"" << *piece_it
<< "\" as an integer.";
return false;
}
qpack_decoder_ = std::make_unique<QpackDecoder>(
maximum_dynamic_table_capacity, max_blocked_streams, this);
qpack_decoder_->set_qpack_stream_sender_delegate(
&decoder_stream_sender_delegate_);
// The initial dynamic table capacity is zero according to
// https://quicwg.org/base-drafts/draft-ietf-quic-qpack.html#eviction.
// However, for historical reasons, offline interop encoders use
// |maximum_dynamic_table_capacity| as initial capacity.
qpack_decoder_->OnSetDynamicTableCapacity(maximum_dynamic_table_capacity);
return true;
}
bool QpackOfflineDecoder::DecodeHeaderBlocksFromFile(
absl::string_view input_filename) {
// Store data in |input_data_storage|; use a absl::string_view to
// efficiently keep track of remaining portion yet to be decoded.
std::optional<std::string> input_data_storage =
quiche::ReadFileContents(input_filename);
QUICHE_DCHECK(input_data_storage.has_value());
absl::string_view input_data(*input_data_storage);
while (!input_data.empty()) {
// Parse stream_id and length.
if (input_data.size() < sizeof(uint64_t) + sizeof(uint32_t)) {
QUIC_LOG(ERROR) << "Unexpected end of input file.";
return false;
}
uint64_t stream_id = quiche::QuicheEndian::NetToHost64(
*reinterpret_cast<const uint64_t*>(input_data.data()));
input_data = input_data.substr(sizeof(uint64_t));
uint32_t length = quiche::QuicheEndian::NetToHost32(
*reinterpret_cast<const uint32_t*>(input_data.data()));
input_data = input_data.substr(sizeof(uint32_t));
if (input_data.size() < length) {
QUIC_LOG(ERROR) << "Unexpected end of input file.";
return false;
}
// Parse data.
absl::string_view data = input_data.substr(0, length);
input_data = input_data.substr(length);
// Process data.
if (stream_id == 0) {
qpack_decoder_->encoder_stream_receiver()->Decode(data);
if (encoder_stream_error_detected_) {
QUIC_LOG(ERROR) << "Error detected on encoder stream.";
return false;
}
} else {
auto headers_handler = std::make_unique<test::TestHeadersHandler>();
auto progressive_decoder = qpack_decoder_->CreateProgressiveDecoder(
stream_id, headers_handler.get());
progressive_decoder->Decode(data);
progressive_decoder->EndHeaderBlock();
if (headers_handler->decoding_error_detected()) {
QUIC_LOG(ERROR) << "Sync decoding error on stream " << stream_id << ": "
<< headers_handler->error_message();
return false;
}
decoders_.push_back({std::move(headers_handler),
std::move(progressive_decoder), stream_id});
}
// Move decoded header lists from TestHeadersHandlers and append them to
// |decoded_header_lists_| while preserving the order in |decoders_|.
while (!decoders_.empty() &&
decoders_.front().headers_handler->decoding_completed()) {
Decoder* decoder = &decoders_.front();
if (decoder->headers_handler->decoding_error_detected()) {
QUIC_LOG(ERROR) << "Async decoding error on stream "
<< decoder->stream_id << ": "
<< decoder->headers_handler->error_message();
return false;
}
if (!decoder->headers_handler->decoding_completed()) {
QUIC_LOG(ERROR) << "Decoding incomplete after reading entire"
" file, on stream "
<< decoder->stream_id;
return false;
}
decoded_header_lists_.push_back(
decoder->headers_handler->ReleaseHeaderList());
decoders_.pop_front();
}
}
if (!decoders_.empty()) {
QUICHE_DCHECK(!decoders_.front().headers_handler->decoding_completed());
QUIC_LOG(ERROR) << "Blocked decoding uncomplete after reading entire"
" file, on stream "
<< decoders_.front().stream_id;
return false;
}
return true;
}
bool QpackOfflineDecoder::VerifyDecodedHeaderLists(
absl::string_view expected_headers_filename) {
// Store data in |expected_headers_data_storage|; use a
// absl::string_view to efficiently keep track of remaining portion
// yet to be decoded.
std::optional<std::string> expected_headers_data_storage =
quiche::ReadFileContents(expected_headers_filename);
QUICHE_DCHECK(expected_headers_data_storage.has_value());
absl::string_view expected_headers_data(*expected_headers_data_storage);
while (!decoded_header_lists_.empty()) {
spdy::Http2HeaderBlock decoded_header_list =
std::move(decoded_header_lists_.front());
decoded_header_lists_.pop_front();
spdy::Http2HeaderBlock expected_header_list;
if (!ReadNextExpectedHeaderList(&expected_headers_data,
&expected_header_list)) {
QUIC_LOG(ERROR)
<< "Error parsing expected header list to match next decoded "
"header list.";
return false;
}
if (!CompareHeaderBlocks(std::move(decoded_header_list),
std::move(expected_header_list))) {
QUIC_LOG(ERROR) << "Decoded header does not match expected header.";
return false;
}
}
if (!expected_headers_data.empty()) {
QUIC_LOG(ERROR)
<< "Not enough encoded header lists to match expected ones.";
return false;
}
return true;
}
bool QpackOfflineDecoder::ReadNextExpectedHeaderList(
absl::string_view* expected_headers_data,
spdy::Http2HeaderBlock* expected_header_list) {
while (true) {
absl::string_view::size_type endline = expected_headers_data->find('\n');
// Even last header list must be followed by an empty line.
if (endline == absl::string_view::npos) {
QUIC_LOG(ERROR) << "Unexpected end of expected header list file.";
return false;
}
if (endline == 0) {
// Empty line indicates end of header list.
*expected_headers_data = expected_headers_data->substr(1);
return true;
}
absl::string_view header_field = expected_headers_data->substr(0, endline);
std::vector<absl::string_view> pieces = absl::StrSplit(header_field, '\t');
if (pieces.size() != 2) {
QUIC_LOG(ERROR) << "Header key and value must be separated by TAB.";
return false;
}
expected_header_list->AppendValueOrAddHeader(pieces[0], pieces[1]);
*expected_headers_data = expected_headers_data->substr(endline + 1);
}
}
bool QpackOfflineDecoder::CompareHeaderBlocks(
spdy::Http2HeaderBlock decoded_header_list,
spdy::Http2HeaderBlock expected_header_list) {
if (decoded_header_list == expected_header_list) {
return true;
}
// The h2o decoder reshuffles the "content-length" header and pseudo-headers,
// see
// https://github.com/qpackers/qifs/blob/master/encoded/qpack-03/h2o/README.md.
// Remove such headers one by one if they match.
const char* kContentLength = "content-length";
const char* kPseudoHeaderPrefix = ":";
for (spdy::Http2HeaderBlock::iterator decoded_it =
decoded_header_list.begin();
decoded_it != decoded_header_list.end();) {
const absl::string_view key = decoded_it->first;
if (key != kContentLength && !absl::StartsWith(key, kPseudoHeaderPrefix)) {
++decoded_it;
continue;
}
spdy::Http2HeaderBlock::iterator expected_it =
expected_header_list.find(key);
if (expected_it == expected_header_list.end() ||
decoded_it->second != expected_it->second) {
++decoded_it;
continue;
}
// Http2HeaderBlock does not support erasing by iterator, only by key.
++decoded_it;
expected_header_list.erase(key);
// This will invalidate |key|.
decoded_header_list.erase(key);
}
return decoded_header_list == expected_header_list;
}
} // namespace quic