1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/quic/tools/quic_simple_server_session.h"
6
7 #include <utility>
8
9 #include "absl/memory/memory.h"
10 #include "quiche/quic/core/http/quic_server_initiated_spdy_stream.h"
11 #include "quiche/quic/core/http/quic_spdy_session.h"
12 #include "quiche/quic/core/quic_connection.h"
13 #include "quiche/quic/core/quic_stream_priority.h"
14 #include "quiche/quic/core/quic_types.h"
15 #include "quiche/quic/core/quic_utils.h"
16 #include "quiche/quic/platform/api/quic_flags.h"
17 #include "quiche/quic/platform/api/quic_logging.h"
18 #include "quiche/quic/tools/quic_simple_server_stream.h"
19
20 namespace quic {
21
QuicSimpleServerSession(const QuicConfig & config,const ParsedQuicVersionVector & supported_versions,QuicConnection * connection,QuicSession::Visitor * visitor,QuicCryptoServerStreamBase::Helper * helper,const QuicCryptoServerConfig * crypto_config,QuicCompressedCertsCache * compressed_certs_cache,QuicSimpleServerBackend * quic_simple_server_backend)22 QuicSimpleServerSession::QuicSimpleServerSession(
23 const QuicConfig& config, const ParsedQuicVersionVector& supported_versions,
24 QuicConnection* connection, QuicSession::Visitor* visitor,
25 QuicCryptoServerStreamBase::Helper* helper,
26 const QuicCryptoServerConfig* crypto_config,
27 QuicCompressedCertsCache* compressed_certs_cache,
28 QuicSimpleServerBackend* quic_simple_server_backend)
29 : QuicServerSessionBase(config, supported_versions, connection, visitor,
30 helper, crypto_config, compressed_certs_cache),
31 quic_simple_server_backend_(quic_simple_server_backend) {
32 QUICHE_DCHECK(quic_simple_server_backend_);
33 set_max_streams_accepted_per_loop(5u);
34 }
35
~QuicSimpleServerSession()36 QuicSimpleServerSession::~QuicSimpleServerSession() { DeleteConnection(); }
37
38 std::unique_ptr<QuicCryptoServerStreamBase>
CreateQuicCryptoServerStream(const QuicCryptoServerConfig * crypto_config,QuicCompressedCertsCache * compressed_certs_cache)39 QuicSimpleServerSession::CreateQuicCryptoServerStream(
40 const QuicCryptoServerConfig* crypto_config,
41 QuicCompressedCertsCache* compressed_certs_cache) {
42 return CreateCryptoServerStream(crypto_config, compressed_certs_cache, this,
43 stream_helper());
44 }
45
OnStreamFrame(const QuicStreamFrame & frame)46 void QuicSimpleServerSession::OnStreamFrame(const QuicStreamFrame& frame) {
47 if (!IsIncomingStream(frame.stream_id) && !WillNegotiateWebTransport()) {
48 QUIC_LOG(WARNING) << "Client shouldn't send data on server push stream";
49 connection()->CloseConnection(
50 QUIC_INVALID_STREAM_ID, "Client sent data on server push stream",
51 ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
52 return;
53 }
54 QuicSpdySession::OnStreamFrame(frame);
55 }
56
CreateIncomingStream(QuicStreamId id)57 QuicSpdyStream* QuicSimpleServerSession::CreateIncomingStream(QuicStreamId id) {
58 if (!ShouldCreateIncomingStream(id)) {
59 return nullptr;
60 }
61
62 QuicSpdyStream* stream = new QuicSimpleServerStream(
63 id, this, BIDIRECTIONAL, quic_simple_server_backend_);
64 ActivateStream(absl::WrapUnique(stream));
65 return stream;
66 }
67
CreateIncomingStream(PendingStream * pending)68 QuicSpdyStream* QuicSimpleServerSession::CreateIncomingStream(
69 PendingStream* pending) {
70 QuicSpdyStream* stream =
71 new QuicSimpleServerStream(pending, this, quic_simple_server_backend_);
72 ActivateStream(absl::WrapUnique(stream));
73 return stream;
74 }
75
CreateOutgoingBidirectionalStream()76 QuicSpdyStream* QuicSimpleServerSession::CreateOutgoingBidirectionalStream() {
77 if (!WillNegotiateWebTransport()) {
78 QUIC_BUG(QuicSimpleServerSession CreateOutgoingBidirectionalStream without
79 WebTransport support)
80 << "QuicSimpleServerSession::CreateOutgoingBidirectionalStream called "
81 "in a session without WebTransport support.";
82 return nullptr;
83 }
84 if (!ShouldCreateOutgoingBidirectionalStream()) {
85 return nullptr;
86 }
87
88 QuicServerInitiatedSpdyStream* stream = new QuicServerInitiatedSpdyStream(
89 GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL);
90 ActivateStream(absl::WrapUnique(stream));
91 return stream;
92 }
93
94 QuicSimpleServerStream*
CreateOutgoingUnidirectionalStream()95 QuicSimpleServerSession::CreateOutgoingUnidirectionalStream() {
96 if (!ShouldCreateOutgoingUnidirectionalStream()) {
97 return nullptr;
98 }
99
100 QuicSimpleServerStream* stream = new QuicSimpleServerStream(
101 GetNextOutgoingUnidirectionalStreamId(), this, WRITE_UNIDIRECTIONAL,
102 quic_simple_server_backend_);
103 ActivateStream(absl::WrapUnique(stream));
104 return stream;
105 }
106
ProcessBidirectionalPendingStream(PendingStream * pending)107 QuicStream* QuicSimpleServerSession::ProcessBidirectionalPendingStream(
108 PendingStream* pending) {
109 QUICHE_DCHECK(IsEncryptionEstablished());
110 return CreateIncomingStream(pending);
111 }
112
113 } // namespace quic
114