blob: 4b21ccaded1fdebfa4856f603de3bed762fefd79 [file] [log] [blame]
// Copyright (c) 2013 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/third_party/quiche/src/quic/tools/quic_simple_server_stream.h"
#include <list>
#include <memory>
#include <utility>
#include "absl/base/macros.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
#include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
#include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/crypto_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_connection_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/tools/quic_backend_response.h"
#include "net/third_party/quiche/src/quic/tools/quic_memory_cache_backend.h"
#include "net/third_party/quiche/src/quic/tools/quic_simple_server_session.h"
using testing::_;
using testing::AnyNumber;
using testing::InSequence;
using testing::Invoke;
using testing::StrictMock;
namespace quic {
namespace test {
const size_t kFakeFrameLen = 60;
const size_t kErrorLength = strlen(QuicSimpleServerStream::kErrorResponseBody);
const size_t kDataFrameHeaderLength = 2;
class TestStream : public QuicSimpleServerStream {
public:
TestStream(QuicStreamId stream_id,
QuicSpdySession* session,
StreamType type,
QuicSimpleServerBackend* quic_simple_server_backend)
: QuicSimpleServerStream(stream_id,
session,
type,
quic_simple_server_backend) {}
~TestStream() override = default;
MOCK_METHOD(void, WriteHeadersMock, (bool fin), ());
size_t WriteHeaders(spdy::Http2HeaderBlock /*header_block*/,
bool fin,
QuicReferenceCountedPointer<QuicAckListenerInterface>
/*ack_listener*/) override {
WriteHeadersMock(fin);
return 0;
}
// Expose protected QuicSimpleServerStream methods.
void DoSendResponse() { SendResponse(); }
void DoSendErrorResponse() { SendErrorResponse(); }
spdy::Http2HeaderBlock* mutable_headers() { return &request_headers_; }
void set_body(std::string body) { body_ = std::move(body); }
const std::string& body() const { return body_; }
int content_length() const { return content_length_; }
absl::string_view GetHeader(absl::string_view key) const {
auto it = request_headers_.find(key);
DCHECK(it != request_headers_.end());
return it->second;
}
};
namespace {
class MockQuicSimpleServerSession : public QuicSimpleServerSession {
public:
const size_t kMaxStreamsForTest = 100;
MockQuicSimpleServerSession(
QuicConnection* connection,
MockQuicSessionVisitor* owner,
MockQuicCryptoServerStreamHelper* helper,
QuicCryptoServerConfig* crypto_config,
QuicCompressedCertsCache* compressed_certs_cache,
QuicSimpleServerBackend* quic_simple_server_backend)
: QuicSimpleServerSession(DefaultQuicConfig(),
CurrentSupportedVersions(),
connection,
owner,
helper,
crypto_config,
compressed_certs_cache,
quic_simple_server_backend) {
if (VersionHasIetfQuicFrames(connection->transport_version())) {
QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
this, kMaxStreamsForTest);
QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
this, kMaxStreamsForTest);
} else {
QuicSessionPeer::SetMaxOpenIncomingStreams(this, kMaxStreamsForTest);
QuicSessionPeer::SetMaxOpenOutgoingStreams(this, kMaxStreamsForTest);
}
ON_CALL(*this, WritevData(_, _, _, _, _, _))
.WillByDefault(Invoke(this, &MockQuicSimpleServerSession::ConsumeData));
}
MockQuicSimpleServerSession(const MockQuicSimpleServerSession&) = delete;
MockQuicSimpleServerSession& operator=(const MockQuicSimpleServerSession&) =
delete;
~MockQuicSimpleServerSession() override = default;
MOCK_METHOD(void,
OnConnectionClosed,
(const QuicConnectionCloseFrame& frame,
ConnectionCloseSource source),
(override));
MOCK_METHOD(QuicSpdyStream*,
CreateIncomingStream,
(QuicStreamId id),
(override));
MOCK_METHOD(QuicConsumedData,
WritevData,
(QuicStreamId id,
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
TransmissionType type,
absl::optional<EncryptionLevel> level),
(override));
MOCK_METHOD(void,
OnStreamHeaderList,
(QuicStreamId stream_id,
bool fin,
size_t frame_len,
const QuicHeaderList& header_list),
(override));
MOCK_METHOD(void,
OnStreamHeadersPriority,
(QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& precedence),
(override));
MOCK_METHOD(void,
SendRstStream,
(QuicStreamId stream_id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written,
bool send_rst_only),
(override));
MOCK_METHOD(void,
MaybeSendRstStreamFrame,
(QuicStreamId stream_id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written),
(override));
MOCK_METHOD(void,
MaybeSendStopSendingFrame,
(QuicStreamId stream_id, QuicRstStreamErrorCode error),
(override));
// Matchers cannot be used on non-copyable types like Http2HeaderBlock.
void PromisePushResources(
const std::string& request_url,
const std::list<QuicBackendResponse::ServerPushInfo>& resources,
QuicStreamId original_stream_id,
const spdy::SpdyStreamPrecedence& original_precedence,
const spdy::Http2HeaderBlock& original_request_headers) override {
original_request_headers_ = original_request_headers.Clone();
PromisePushResourcesMock(request_url, resources, original_stream_id,
original_precedence, original_request_headers);
}
MOCK_METHOD(void,
PromisePushResourcesMock,
(const std::string&,
const std::list<QuicBackendResponse::ServerPushInfo>&,
QuicStreamId,
const spdy::SpdyStreamPrecedence&,
const spdy::Http2HeaderBlock&),
());
using QuicSession::ActivateStream;
QuicConsumedData ConsumeData(QuicStreamId id,
size_t write_length,
QuicStreamOffset offset,
StreamSendingState state,
TransmissionType /*type*/,
absl::optional<EncryptionLevel> /*level*/) {
if (write_length > 0) {
auto buf = std::make_unique<char[]>(write_length);
QuicStream* stream = GetOrCreateStream(id);
DCHECK(stream);
QuicDataWriter writer(write_length, buf.get(), quiche::HOST_BYTE_ORDER);
stream->WriteStreamData(offset, write_length, &writer);
} else {
DCHECK(state != NO_FIN);
}
return QuicConsumedData(write_length, state != NO_FIN);
}
spdy::Http2HeaderBlock original_request_headers_;
};
class QuicSimpleServerStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
public:
QuicSimpleServerStreamTest()
: connection_(
new StrictMock<MockQuicConnection>(&helper_,
&alarm_factory_,
Perspective::IS_SERVER,
SupportedVersions(GetParam()))),
crypto_config_(new QuicCryptoServerConfig(
QuicCryptoServerConfig::TESTING,
QuicRandom::GetInstance(),
crypto_test_utils::ProofSourceForTesting(),
KeyExchangeSource::Default())),
compressed_certs_cache_(
QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
session_(connection_,
&session_owner_,
&session_helper_,
crypto_config_.get(),
&compressed_certs_cache_,
&memory_cache_backend_),
quic_response_(new QuicBackendResponse),
body_("hello world") {
connection_->set_visitor(&session_);
header_list_.OnHeaderBlockStart();
header_list_.OnHeader(":authority", "www.google.com");
header_list_.OnHeader(":path", "/");
header_list_.OnHeader(":method", "POST");
header_list_.OnHeader("content-length", "11");
header_list_.OnHeaderBlockEnd(128, 128);
// New streams rely on having the peer's flow control receive window
// negotiated in the config.
session_.config()->SetInitialStreamFlowControlWindowToSend(
kInitialStreamFlowControlWindowForTest);
session_.config()->SetInitialSessionFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
session_.Initialize();
connection_->SetEncrypter(
quic::ENCRYPTION_FORWARD_SECURE,
std::make_unique<quic::NullEncrypter>(connection_->perspective()));
if (connection_->version().SupportsAntiAmplificationLimit()) {
QuicConnectionPeer::SetAddressValidated(connection_);
}
stream_ = new StrictMock<TestStream>(
GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0),
&session_, BIDIRECTIONAL, &memory_cache_backend_);
// Register stream_ in dynamic_stream_map_ and pass ownership to session_.
session_.ActivateStream(QuicWrapUnique(stream_));
QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesIncomingBidirectional(
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesOutgoingBidirectional(
session_.config(), kMinimumFlowControlSendWindow);
QuicConfigPeer::SetReceivedMaxUnidirectionalStreams(session_.config(), 10);
session_.OnConfigNegotiated();
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
}
const std::string& StreamBody() { return stream_->body(); }
std::string StreamHeadersValue(const std::string& key) {
return (*stream_->mutable_headers())[key].as_string();
}
bool UsesHttp3() const {
return VersionUsesHttp3(connection_->transport_version());
}
spdy::Http2HeaderBlock response_headers_;
MockQuicConnectionHelper helper_;
MockAlarmFactory alarm_factory_;
StrictMock<MockQuicConnection>* connection_;
StrictMock<MockQuicSessionVisitor> session_owner_;
StrictMock<MockQuicCryptoServerStreamHelper> session_helper_;
std::unique_ptr<QuicCryptoServerConfig> crypto_config_;
QuicCompressedCertsCache compressed_certs_cache_;
QuicMemoryCacheBackend memory_cache_backend_;
StrictMock<MockQuicSimpleServerSession> session_;
StrictMock<TestStream>* stream_; // Owned by session_.
std::unique_ptr<QuicBackendResponse> quic_response_;
std::string body_;
QuicHeaderList header_list_;
};
INSTANTIATE_TEST_SUITE_P(Tests,
QuicSimpleServerStreamTest,
::testing::ValuesIn(AllSupportedVersions()),
::testing::PrintToStringParamName());
TEST_P(QuicSimpleServerStreamTest, TestFraming) {
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer);
std::string header = std::string(buffer.get(), header_length);
std::string data = UsesHttp3() ? header + body_ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
EXPECT_EQ("11", StreamHeadersValue("content-length"));
EXPECT_EQ("/", StreamHeadersValue(":path"));
EXPECT_EQ("POST", StreamHeadersValue(":method"));
EXPECT_EQ(body_, StreamBody());
}
TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) {
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer);
std::string header = std::string(buffer.get(), header_length);
std::string data = UsesHttp3() ? header + body_ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
EXPECT_EQ("11", StreamHeadersValue("content-length"));
EXPECT_EQ("/", StreamHeadersValue(":path"));
EXPECT_EQ("POST", StreamHeadersValue(":method"));
EXPECT_EQ(body_, StreamBody());
}
TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
EXPECT_FALSE(stream_->fin_received());
EXPECT_FALSE(stream_->rst_received());
QuicStreamPeer::SetFinSent(stream_);
stream_->CloseWriteSide();
if (!session_.split_up_send_rst()) {
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _))
.Times(1);
} else {
if (session_.version().UsesHttp3()) {
EXPECT_CALL(session_, MaybeSendStopSendingFrame(_, QUIC_STREAM_NO_ERROR))
.Times(1);
} else {
EXPECT_CALL(session_, MaybeSendRstStreamFrame(_, QUIC_STREAM_NO_ERROR, _))
.Times(1);
}
}
stream_->StopReading();
}
TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
InSequence seq;
std::string large_body = "hello world!!!!!!";
// We'll automatically write out an error (headers + body)
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_,
WritevData(_, kDataFrameHeaderLength, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, kErrorLength, _, FIN, _, _));
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body_.length(), &buffer);
std::string header = std::string(buffer.get(), header_length);
std::string data = UsesHttp3() ? header + body_ : body_;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, data));
// Content length is still 11. This will register as an error and we won't
// accept the bytes.
header_length =
HttpEncoder::SerializeDataFrameHeader(large_body.length(), &buffer);
header = std::string(buffer.get(), header_length);
std::string data2 = UsesHttp3() ? header + large_body : large_body;
stream_->OnStreamFrame(
QuicStreamFrame(stream_->id(), /*fin=*/true, data.size(), data2));
EXPECT_EQ("11", StreamHeadersValue("content-length"));
EXPECT_EQ("/", StreamHeadersValue(":path"));
EXPECT_EQ("POST", StreamHeadersValue(":method"));
}
TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
// Send an illegal response with response status not supported by HTTP/2.
spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
(*request_headers)[":path"] = "/bar";
(*request_headers)[":authority"] = "www.google.com";
(*request_headers)[":method"] = "GET";
// HTTP/2 only supports integer responsecode, so "200 OK" is illegal.
response_headers_[":status"] = "200 OK";
response_headers_["content-length"] = "5";
std::string body = "Yummm";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer);
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
QuicStreamPeer::SetFinReceived(stream_);
InSequence s;
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_, WritevData(_, header_length, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, kErrorLength, _, FIN, _, _));
stream_->DoSendResponse();
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus2) {
// Send an illegal response with response status not supported by HTTP/2.
spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
(*request_headers)[":path"] = "/bar";
(*request_headers)[":authority"] = "www.google.com";
(*request_headers)[":method"] = "GET";
// HTTP/2 only supports 3-digit-integer, so "+200" is illegal.
response_headers_[":status"] = "+200";
response_headers_["content-length"] = "5";
std::string body = "Yummm";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer);
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
QuicStreamPeer::SetFinReceived(stream_);
InSequence s;
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_, WritevData(_, header_length, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, kErrorLength, _, FIN, _, _));
stream_->DoSendResponse();
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, SendPushResponseWith404Response) {
// Create a new promised stream with even id().
auto promised_stream = new StrictMock<TestStream>(
GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 3),
&session_, WRITE_UNIDIRECTIONAL, &memory_cache_backend_);
session_.ActivateStream(QuicWrapUnique(promised_stream));
// Send a push response with response status 404, which will be regarded as
// invalid server push response.
spdy::Http2HeaderBlock* request_headers = promised_stream->mutable_headers();
(*request_headers)[":path"] = "/bar";
(*request_headers)[":authority"] = "www.google.com";
(*request_headers)[":method"] = "GET";
response_headers_[":status"] = "404";
response_headers_["content-length"] = "8";
std::string body = "NotFound";
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
InSequence s;
if (!session_.split_up_send_rst()) {
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_CANCELLED, 0, _));
} else {
if (session_.version().UsesHttp3()) {
EXPECT_CALL(session_, MaybeSendStopSendingFrame(promised_stream->id(),
QUIC_STREAM_CANCELLED));
}
EXPECT_CALL(session_, MaybeSendRstStreamFrame(promised_stream->id(),
QUIC_STREAM_CANCELLED, 0));
}
promised_stream->DoSendResponse();
}
TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
// Add a request and response with valid headers.
spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
(*request_headers)[":path"] = "/bar";
(*request_headers)[":authority"] = "www.google.com";
(*request_headers)[":method"] = "GET";
response_headers_[":status"] = "200";
response_headers_["content-length"] = "5";
std::string body = "Yummm";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer);
memory_cache_backend_.AddResponse("www.google.com", "/bar",
std::move(response_headers_), body);
QuicStreamPeer::SetFinReceived(stream_);
InSequence s;
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_, WritevData(_, header_length, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, body.length(), _, FIN, _, _));
stream_->DoSendResponse();
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, SendResponseWithPushResources) {
// Tests that if a response has push resources to be send, SendResponse() will
// call PromisePushResources() to handle these resources.
// Add a request and response with valid headers into cache.
std::string host = "www.google.com";
std::string request_path = "/foo";
std::string body = "Yummm";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(body.length(), &buffer);
QuicBackendResponse::ServerPushInfo push_info(
QuicUrl(host, "/bar"), spdy::Http2HeaderBlock(),
QuicStream::kDefaultPriority, "Push body");
std::list<QuicBackendResponse::ServerPushInfo> push_resources;
push_resources.push_back(push_info);
memory_cache_backend_.AddSimpleResponseWithServerPushResources(
host, request_path, 200, body, push_resources);
spdy::Http2HeaderBlock* request_headers = stream_->mutable_headers();
(*request_headers)[":path"] = request_path;
(*request_headers)[":authority"] = host;
(*request_headers)[":method"] = "GET";
QuicStreamPeer::SetFinReceived(stream_);
InSequence s;
EXPECT_CALL(session_, PromisePushResourcesMock(
host + request_path, _,
GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0),
_, _));
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_, WritevData(_, header_length, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, body.length(), _, FIN, _, _));
stream_->DoSendResponse();
EXPECT_EQ(*request_headers, session_.original_request_headers_);
}
TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) {
// EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
if (GetParam() != AllSupportedVersions()[0]) {
return;
}
// Calling PushResponse() on a client initialted stream is never supposed to
// happen.
EXPECT_QUIC_BUG(stream_->PushResponse(spdy::Http2HeaderBlock()),
"Client initiated stream"
" shouldn't be used as promised stream.");
}
TEST_P(QuicSimpleServerStreamTest, PushResponseOnServerInitiatedStream) {
// Tests that PushResponse() should take the given headers as request headers
// and fetch response from cache, and send it out.
// Create a stream with even stream id and test against this stream.
const QuicStreamId kServerInitiatedStreamId =
GetNthServerInitiatedUnidirectionalStreamId(
connection_->transport_version(), 3);
// Create a server initiated stream and pass it to session_.
auto server_initiated_stream =
new StrictMock<TestStream>(kServerInitiatedStreamId, &session_,
WRITE_UNIDIRECTIONAL, &memory_cache_backend_);
session_.ActivateStream(QuicWrapUnique(server_initiated_stream));
const std::string kHost = "www.foo.com";
const std::string kPath = "/bar";
spdy::Http2HeaderBlock headers;
headers[":path"] = kPath;
headers[":authority"] = kHost;
headers[":method"] = "GET";
response_headers_[":status"] = "200";
response_headers_["content-length"] = "5";
const std::string kBody = "Hello";
std::unique_ptr<char[]> buffer;
QuicByteCount header_length =
HttpEncoder::SerializeDataFrameHeader(kBody.length(), &buffer);
memory_cache_backend_.AddResponse(kHost, kPath, std::move(response_headers_),
kBody);
// Call PushResponse() should trigger stream to fetch response from cache
// and send it back.
InSequence s;
EXPECT_CALL(*server_initiated_stream, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_, WritevData(kServerInitiatedStreamId, header_length, _,
NO_FIN, _, _));
}
EXPECT_CALL(session_,
WritevData(kServerInitiatedStreamId, kBody.size(), _, FIN, _, _));
server_initiated_stream->PushResponse(std::move(headers));
EXPECT_EQ(kPath, server_initiated_stream->GetHeader(":path"));
EXPECT_EQ("GET", server_initiated_stream->GetHeader(":method"));
}
TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
QuicStreamPeer::SetFinReceived(stream_);
InSequence s;
EXPECT_CALL(*stream_, WriteHeadersMock(false));
if (UsesHttp3()) {
EXPECT_CALL(session_,
WritevData(_, kDataFrameHeaderLength, _, NO_FIN, _, _));
}
EXPECT_CALL(session_, WritevData(_, kErrorLength, _, FIN, _, _));
stream_->DoSendErrorResponse();
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
spdy::Http2HeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
header_list_.OnHeader("content-length", absl::string_view("11\00012", 5));
EXPECT_CALL(*stream_, WriteHeadersMock(false));
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(true, kFakeFrameLen, header_list_);
EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->reading_stopped());
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
spdy::Http2HeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
header_list_.OnHeader("content-length", absl::string_view("\00012", 3));
EXPECT_CALL(*stream_, WriteHeadersMock(false));
EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
.WillRepeatedly(
Invoke(&session_, &MockQuicSimpleServerSession::ConsumeData));
stream_->OnStreamHeaderList(true, kFakeFrameLen, header_list_);
EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_TRUE(stream_->reading_stopped());
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, ValidMultipleContentLength) {
spdy::Http2HeaderBlock request_headers;
// \000 is a way to write the null byte when followed by a literal digit.
header_list_.OnHeader("content-length", absl::string_view("11\00011", 5));
stream_->OnStreamHeaderList(false, kFakeFrameLen, header_list_);
EXPECT_EQ(11, stream_->content_length());
EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
EXPECT_FALSE(stream_->reading_stopped());
EXPECT_FALSE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest,
DoNotSendQuicRstStreamNoErrorWithRstReceived) {
EXPECT_FALSE(stream_->reading_stopped());
EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _, _)).Times(0);
if (VersionUsesHttp3(connection_->transport_version())) {
// Unidirectional stream type and then a Stream Cancellation instruction is
// sent on the QPACK decoder stream. Ignore these writes without any
// assumption on their number or size.
auto* qpack_decoder_stream =
QuicSpdySessionPeer::GetQpackDecoderSendStream(&session_);
EXPECT_CALL(session_, WritevData(qpack_decoder_stream->id(), _, _, _, _, _))
.Times(AnyNumber());
}
if (!session_.split_up_send_rst()) {
EXPECT_CALL(session_, SendRstStream(_,
session_.version().UsesHttp3()
? QUIC_STREAM_CANCELLED
: QUIC_RST_ACKNOWLEDGEMENT,
_, _))
.Times(1);
} else {
EXPECT_CALL(session_,
MaybeSendRstStreamFrame(_,
session_.version().UsesHttp3()
? QUIC_STREAM_CANCELLED
: QUIC_RST_ACKNOWLEDGEMENT,
_))
.Times(1);
}
QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
QUIC_STREAM_CANCELLED, 1234);
stream_->OnStreamReset(rst_frame);
if (VersionHasIetfQuicFrames(connection_->transport_version())) {
EXPECT_CALL(session_owner_, OnStopSendingReceived(_));
// Create and inject a STOP SENDING frame to complete the close
// of the stream. This is only needed for version 99/IETF QUIC.
QuicStopSendingFrame stop_sending(kInvalidControlFrameId, stream_->id(),
QUIC_STREAM_CANCELLED);
session_.OnStopSendingFrame(stop_sending);
}
EXPECT_TRUE(stream_->reading_stopped());
EXPECT_TRUE(stream_->write_side_closed());
}
TEST_P(QuicSimpleServerStreamTest, InvalidHeadersWithFin) {
char arr[] = {
0x3a, 0x68, 0x6f, 0x73, // :hos
0x74, 0x00, 0x00, 0x00, // t...
0x00, 0x00, 0x00, 0x00, // ....
0x07, 0x3a, 0x6d, 0x65, // .:me
0x74, 0x68, 0x6f, 0x64, // thod
0x00, 0x00, 0x00, 0x03, // ....
0x47, 0x45, 0x54, 0x00, // GET.
0x00, 0x00, 0x05, 0x3a, // ...:
0x70, 0x61, 0x74, 0x68, // path
0x00, 0x00, 0x00, 0x04, // ....
0x2f, 0x66, 0x6f, 0x6f, // /foo
0x00, 0x00, 0x00, 0x07, // ....
0x3a, 0x73, 0x63, 0x68, // :sch
0x65, 0x6d, 0x65, 0x00, // eme.
0x00, 0x00, 0x00, 0x00, // ....
0x00, 0x00, 0x08, 0x3a, // ...:
0x76, 0x65, 0x72, 0x73, // vers
0x96, 0x6f, 0x6e, 0x00, // <i(69)>on.
0x00, 0x00, 0x08, 0x48, // ...H
0x54, 0x54, 0x50, 0x2f, // TTP/
0x31, 0x2e, 0x31, // 1.1
};
absl::string_view data(arr, ABSL_ARRAYSIZE(arr));
QuicStreamFrame frame(stream_->id(), true, 0, data);
// Verify that we don't crash when we get a invalid headers in stream frame.
stream_->OnStreamFrame(frame);
}
} // namespace
} // namespace test
} // namespace quic