blob: adc334828b6eca8ea582f328bc319e1d6dca73ce [file] [log] [blame]
// Copyright 2014 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 "quiche/quic/core/http/quic_spdy_client_session_base.h"
#include <string>
#include "quiche/quic/core/http/quic_client_promised_info.h"
#include "quiche/quic/core/http/spdy_server_push_utils.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_logging.h"
using spdy::Http2HeaderBlock;
namespace quic {
QuicSpdyClientSessionBase::QuicSpdyClientSessionBase(
QuicConnection* connection, QuicSession::Visitor* visitor,
QuicClientPushPromiseIndex* push_promise_index, const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions)
: QuicSpdySession(connection, visitor, config, supported_versions),
push_promise_index_(push_promise_index),
largest_promised_stream_id_(
QuicUtils::GetInvalidStreamId(connection->transport_version())) {}
QuicSpdyClientSessionBase::~QuicSpdyClientSessionBase() {
// all promised streams for this session
for (auto& it : promised_by_id_) {
QUIC_DVLOG(1) << "erase stream " << it.first << " url " << it.second->url();
push_promise_index_->promised_by_url()->erase(it.second->url());
}
DeleteConnection();
}
void QuicSpdyClientSessionBase::OnConfigNegotiated() {
QuicSpdySession::OnConfigNegotiated();
}
void QuicSpdyClientSessionBase::OnInitialHeadersComplete(
QuicStreamId stream_id, const Http2HeaderBlock& response_headers) {
// Note that the strong ordering of the headers stream means that
// QuicSpdyClientStream::OnPromiseHeadersComplete must have already
// been called (on the associated stream) if this is a promised
// stream. However, this stream may not have existed at this time,
// hence the need to query the session.
QuicClientPromisedInfo* promised = GetPromisedById(stream_id);
if (!promised) return;
promised->OnResponseHeaders(response_headers);
}
void QuicSpdyClientSessionBase::OnPromiseHeaderList(
QuicStreamId stream_id, QuicStreamId promised_stream_id, size_t frame_len,
const QuicHeaderList& header_list) {
if (IsStaticStream(stream_id)) {
connection()->CloseConnection(
QUIC_INVALID_HEADERS_STREAM_DATA, "stream is static",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
return;
}
// In HTTP3, push promises are received on individual streams, so they could
// be arrive out of order.
if (!VersionUsesHttp3(transport_version()) &&
promised_stream_id !=
QuicUtils::GetInvalidStreamId(transport_version()) &&
largest_promised_stream_id_ !=
QuicUtils::GetInvalidStreamId(transport_version()) &&
promised_stream_id <= largest_promised_stream_id_) {
connection()->CloseConnection(
QUIC_INVALID_STREAM_ID,
"Received push stream id lesser or equal to the"
" last accepted before",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
return;
}
if (!IsIncomingStream(promised_stream_id)) {
connection()->CloseConnection(
QUIC_INVALID_STREAM_ID, "Received push stream id for outgoing stream.",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
return;
}
if (VersionUsesHttp3(transport_version())) {
// Received push stream id is higher than MAX_PUSH_ID
// because no MAX_PUSH_ID frame is ever sent.
connection()->CloseConnection(
QUIC_INVALID_STREAM_ID,
"Received push stream id higher than MAX_PUSH_ID.",
ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
return;
}
largest_promised_stream_id_ = promised_stream_id;
QuicSpdyStream* stream = GetOrCreateSpdyDataStream(stream_id);
if (!stream) {
// It's quite possible to receive headers after a stream has been reset.
return;
}
stream->OnPromiseHeaderList(promised_stream_id, frame_len, header_list);
}
bool QuicSpdyClientSessionBase::HandlePromised(
QuicStreamId /* associated_id */, QuicStreamId promised_id,
const Http2HeaderBlock& headers) {
// TODO(b/136295430): Do not treat |promised_id| as a stream ID when using
// IETF QUIC.
// Due to pathalogical packet re-ordering, it is possible that
// frames for the promised stream have already arrived, and the
// promised stream could be active or closed.
if (IsClosedStream(promised_id)) {
// There was a RST on the data stream already, perhaps
// QUIC_REFUSED_STREAM?
QUIC_DVLOG(1) << "Promise ignored for stream " << promised_id
<< " that is already closed";
return false;
}
if (push_promise_index_->promised_by_url()->size() >= get_max_promises()) {
QUIC_DVLOG(1) << "Too many promises, rejecting promise for stream "
<< promised_id;
ResetPromised(promised_id, QUIC_REFUSED_STREAM);
return false;
}
const std::string url =
SpdyServerPushUtils::GetPromisedUrlFromHeaders(headers);
QuicClientPromisedInfo* old_promised = GetPromisedByUrl(url);
if (old_promised) {
QUIC_DVLOG(1) << "Promise for stream " << promised_id
<< " is duplicate URL " << url
<< " of previous promise for stream " << old_promised->id();
ResetPromised(promised_id, QUIC_DUPLICATE_PROMISE_URL);
return false;
}
if (GetPromisedById(promised_id)) {
// OnPromiseHeadersComplete() would have closed the connection if
// promised id is a duplicate.
QUIC_BUG(quic_bug_10412_1) << "Duplicate promise for id " << promised_id;
return false;
}
QuicClientPromisedInfo* promised =
new QuicClientPromisedInfo(this, promised_id, url);
std::unique_ptr<QuicClientPromisedInfo> promised_owner(promised);
promised->Init();
QUIC_DVLOG(1) << "stream " << promised_id << " emplace url " << url;
(*push_promise_index_->promised_by_url())[url] = promised;
promised_by_id_[promised_id] = std::move(promised_owner);
bool result = promised->OnPromiseHeaders(headers);
if (result) {
QUICHE_DCHECK(promised_by_id_.find(promised_id) != promised_by_id_.end());
}
return result;
}
QuicClientPromisedInfo* QuicSpdyClientSessionBase::GetPromisedByUrl(
const std::string& url) {
auto it = push_promise_index_->promised_by_url()->find(url);
if (it != push_promise_index_->promised_by_url()->end()) {
return it->second;
}
return nullptr;
}
QuicClientPromisedInfo* QuicSpdyClientSessionBase::GetPromisedById(
const QuicStreamId id) {
auto it = promised_by_id_.find(id);
if (it != promised_by_id_.end()) {
return it->second.get();
}
return nullptr;
}
QuicSpdyStream* QuicSpdyClientSessionBase::GetPromisedStream(
const QuicStreamId id) {
QuicStream* stream = GetActiveStream(id);
if (stream != nullptr) {
return static_cast<QuicSpdyStream*>(stream);
}
return nullptr;
}
void QuicSpdyClientSessionBase::DeletePromised(
QuicClientPromisedInfo* promised) {
push_promise_index_->promised_by_url()->erase(promised->url());
// Since promised_by_id_ contains the unique_ptr, this will destroy
// promised.
// ToDo: Consider implementing logic to send a new MAX_PUSH_ID frame to allow
// another stream to be promised.
promised_by_id_.erase(promised->id());
if (!VersionUsesHttp3(transport_version())) {
headers_stream()->MaybeReleaseSequencerBuffer();
}
}
void QuicSpdyClientSessionBase::OnPushStreamTimedOut(
QuicStreamId /*stream_id*/) {}
void QuicSpdyClientSessionBase::ResetPromised(
QuicStreamId id, QuicRstStreamErrorCode error_code) {
QUICHE_DCHECK(QuicUtils::IsServerInitiatedStreamId(transport_version(), id));
ResetStream(id, error_code);
if (!IsOpenStream(id) && !IsClosedStream(id)) {
MaybeIncreaseLargestPeerStreamId(id);
}
}
void QuicSpdyClientSessionBase::OnStreamClosed(QuicStreamId stream_id) {
QuicSpdySession::OnStreamClosed(stream_id);
if (!VersionUsesHttp3(transport_version())) {
headers_stream()->MaybeReleaseSequencerBuffer();
}
}
bool QuicSpdyClientSessionBase::ShouldReleaseHeadersStreamSequencerBuffer() {
return !HasActiveRequestStreams() && promised_by_id_.empty();
}
bool QuicSpdyClientSessionBase::ShouldKeepConnectionAlive() const {
return QuicSpdySession::ShouldKeepConnectionAlive() ||
num_outgoing_draining_streams() > 0;
}
bool QuicSpdyClientSessionBase::OnSettingsFrame(const SettingsFrame& frame) {
if (!was_zero_rtt_rejected()) {
if (max_outbound_header_list_size() != std::numeric_limits<size_t>::max() &&
frame.values.find(SETTINGS_MAX_FIELD_SECTION_SIZE) ==
frame.values.end()) {
CloseConnectionWithDetails(
QUIC_HTTP_ZERO_RTT_RESUMPTION_SETTINGS_MISMATCH,
"Server accepted 0-RTT but omitted non-default "
"SETTINGS_MAX_FIELD_SECTION_SIZE");
return false;
}
if (qpack_encoder()->maximum_blocked_streams() != 0 &&
frame.values.find(SETTINGS_QPACK_BLOCKED_STREAMS) ==
frame.values.end()) {
CloseConnectionWithDetails(
QUIC_HTTP_ZERO_RTT_RESUMPTION_SETTINGS_MISMATCH,
"Server accepted 0-RTT but omitted non-default "
"SETTINGS_QPACK_BLOCKED_STREAMS");
return false;
}
if (qpack_encoder()->MaximumDynamicTableCapacity() != 0 &&
frame.values.find(SETTINGS_QPACK_MAX_TABLE_CAPACITY) ==
frame.values.end()) {
CloseConnectionWithDetails(
QUIC_HTTP_ZERO_RTT_RESUMPTION_SETTINGS_MISMATCH,
"Server accepted 0-RTT but omitted non-default "
"SETTINGS_QPACK_MAX_TABLE_CAPACITY");
return false;
}
}
if (!QuicSpdySession::OnSettingsFrame(frame)) {
return false;
}
std::string settings_frame = HttpEncoder::SerializeSettingsFrame(frame);
auto serialized_data = std::make_unique<ApplicationState>(
settings_frame.data(), settings_frame.data() + settings_frame.length());
GetMutableCryptoStream()->SetServerApplicationStateForResumption(
std::move(serialized_data));
return true;
}
} // namespace quic