1 // Copyright 2023 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 #ifndef QUICHE_QUIC_CORE_QUIC_GENERIC_CLIENT_SESSION_H_ 6 #define QUICHE_QUIC_CORE_QUIC_GENERIC_CLIENT_SESSION_H_ 7 8 #include <cstdint> 9 #include <memory> 10 11 #include "absl/algorithm/container.h" 12 #include "absl/strings/string_view.h" 13 #include "quiche/quic/core/crypto/quic_crypto_client_config.h" 14 #include "quiche/quic/core/crypto/quic_crypto_server_config.h" 15 #include "quiche/quic/core/quic_config.h" 16 #include "quiche/quic/core/quic_connection.h" 17 #include "quiche/quic/core/quic_crypto_client_stream.h" 18 #include "quiche/quic/core/quic_crypto_server_stream_base.h" 19 #include "quiche/quic/core/quic_crypto_stream.h" 20 #include "quiche/quic/core/quic_datagram_queue.h" 21 #include "quiche/quic/core/quic_error_codes.h" 22 #include "quiche/quic/core/quic_session.h" 23 #include "quiche/quic/core/quic_stream.h" 24 #include "quiche/quic/core/quic_types.h" 25 #include "quiche/quic/core/quic_versions.h" 26 #include "quiche/quic/core/web_transport_stats.h" 27 #include "quiche/quic/platform/api/quic_bug_tracker.h" 28 #include "quiche/common/quiche_callbacks.h" 29 #include "quiche/web_transport/web_transport.h" 30 31 namespace quic { 32 33 class QuicGenericStream; 34 35 // Returns QUIC versions to be used with QuicGenericSessionBase. 36 QUICHE_EXPORT ParsedQuicVersionVector GetQuicVersionsForGenericSession(); 37 38 using CreateWebTransportSessionVisitorCallback = 39 quiche::UnretainedCallback<std::unique_ptr<webtransport::SessionVisitor>( 40 webtransport::Session& session)>; 41 42 // QuicGenericSessionBase lets users access raw QUIC connections via 43 // WebTransport API. 44 class QUICHE_EXPORT QuicGenericSessionBase : public QuicSession, 45 public webtransport::Session { 46 public: 47 QuicGenericSessionBase( 48 QuicConnection* connection, bool owns_connection, Visitor* owner, 49 const QuicConfig& config, std::string alpn, 50 webtransport::SessionVisitor* visitor, bool owns_visitor, 51 std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer); 52 ~QuicGenericSessionBase(); 53 54 // QuicSession implementation. GetAlpnsToOffer()55 std::vector<std::string> GetAlpnsToOffer() const override { 56 return std::vector<std::string>({alpn_}); 57 } SelectAlpn(const std::vector<absl::string_view> & alpns)58 std::vector<absl::string_view>::const_iterator SelectAlpn( 59 const std::vector<absl::string_view>& alpns) const override { 60 return absl::c_find(alpns, alpn_); 61 } OnAlpnSelected(absl::string_view alpn)62 void OnAlpnSelected(absl::string_view alpn) override { 63 QUICHE_DCHECK_EQ(alpn, alpn_); 64 } 65 void OnConnectionClosed(const QuicConnectionCloseFrame& frame, 66 ConnectionCloseSource source) override; 67 ShouldKeepConnectionAlive()68 bool ShouldKeepConnectionAlive() const override { return true; } 69 70 QuicStream* CreateIncomingStream(QuicStreamId id) override; CreateIncomingStream(PendingStream *)71 QuicStream* CreateIncomingStream(PendingStream* /*pending*/) override { 72 QUIC_BUG(QuicGenericSessionBase_PendingStream) 73 << "QuicGenericSessionBase::CreateIncomingStream(PendingStream) not " 74 "implemented"; 75 return nullptr; 76 } 77 78 void OnTlsHandshakeComplete() override; 79 void OnMessageReceived(absl::string_view message) override; 80 81 // webtransport::Session implementation. 82 webtransport::Stream* AcceptIncomingBidirectionalStream() override; 83 webtransport::Stream* AcceptIncomingUnidirectionalStream() override; 84 CanOpenNextOutgoingBidirectionalStream()85 bool CanOpenNextOutgoingBidirectionalStream() override { 86 return QuicSession::CanOpenNextOutgoingBidirectionalStream(); 87 } CanOpenNextOutgoingUnidirectionalStream()88 bool CanOpenNextOutgoingUnidirectionalStream() override { 89 return QuicSession::CanOpenNextOutgoingUnidirectionalStream(); 90 } 91 webtransport::Stream* OpenOutgoingBidirectionalStream() override; 92 webtransport::Stream* OpenOutgoingUnidirectionalStream() override; 93 94 webtransport::Stream* GetStreamById(webtransport::StreamId id) override; 95 96 webtransport::DatagramStatus SendOrQueueDatagram( 97 absl::string_view datagram) override; SetDatagramMaxTimeInQueue(absl::Duration max_time_in_queue)98 void SetDatagramMaxTimeInQueue(absl::Duration max_time_in_queue) override { 99 datagram_queue()->SetMaxTimeInQueue(QuicTimeDelta(max_time_in_queue)); 100 } GetDatagramStats()101 webtransport::DatagramStats GetDatagramStats() override { 102 return WebTransportDatagramStatsForQuicSession(*this); 103 } GetSessionStats()104 webtransport::SessionStats GetSessionStats() override { 105 return WebTransportStatsForQuicSession(*this); 106 } NotifySessionDraining()107 void NotifySessionDraining() override {} SetOnDraining(quiche::SingleUseCallback<void ()>)108 void SetOnDraining(quiche::SingleUseCallback<void()>) override {} 109 CloseSession(webtransport::SessionErrorCode error_code,absl::string_view error_message)110 void CloseSession(webtransport::SessionErrorCode error_code, 111 absl::string_view error_message) override { 112 connection()->CloseConnection( 113 QUIC_NO_ERROR, static_cast<QuicIetfTransportErrorCodes>(error_code), 114 std::string(error_message), 115 ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); 116 } 117 GetMaxDatagramSize()118 QuicByteCount GetMaxDatagramSize() const override { 119 return GetGuaranteedLargestMessagePayload(); 120 } 121 122 private: 123 // Creates and activates a QuicGenericStream for the given ID. 124 QuicGenericStream* CreateStream(QuicStreamId id); 125 126 void OnCanCreateNewOutgoingStream(bool unidirectional) override; 127 128 std::string alpn_; 129 webtransport::SessionVisitor* visitor_; 130 bool owns_connection_; 131 bool owns_visitor_; 132 133 // Contains all of the streams that has been received by the session but have 134 // not been processed by the application. 135 quiche::QuicheCircularDeque<QuicStreamId> incoming_bidirectional_streams_; 136 quiche::QuicheCircularDeque<QuicStreamId> incoming_unidirectional_streams_; 137 }; 138 139 class QUICHE_EXPORT QuicGenericClientSession final 140 : public QuicGenericSessionBase { 141 public: 142 QuicGenericClientSession( 143 QuicConnection* connection, bool owns_connection, Visitor* owner, 144 const QuicConfig& config, std::string host, uint16_t port, 145 std::string alpn, webtransport::SessionVisitor* visitor, 146 bool owns_visitor, 147 std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer, 148 QuicCryptoClientConfig* crypto_config); 149 QuicGenericClientSession( 150 QuicConnection* connection, bool owns_connection, Visitor* owner, 151 const QuicConfig& config, std::string host, uint16_t port, 152 std::string alpn, 153 CreateWebTransportSessionVisitorCallback create_visitor_callback, 154 std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer, 155 QuicCryptoClientConfig* crypto_config); 156 CryptoConnect()157 void CryptoConnect() { crypto_stream_->CryptoConnect(); } 158 159 // QuicSession implementation. GetMutableCryptoStream()160 QuicCryptoStream* GetMutableCryptoStream() override { 161 return crypto_stream_.get(); 162 } GetCryptoStream()163 const QuicCryptoStream* GetCryptoStream() const override { 164 return crypto_stream_.get(); 165 } 166 167 private: 168 std::unique_ptr<QuicCryptoClientStream> crypto_stream_; 169 }; 170 171 class QUICHE_EXPORT QuicGenericServerSession final 172 : public QuicGenericSessionBase { 173 public: 174 QuicGenericServerSession( 175 QuicConnection* connection, bool owns_connection, Visitor* owner, 176 const QuicConfig& config, std::string alpn, 177 webtransport::SessionVisitor* visitor, bool owns_visitor, 178 std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer, 179 const QuicCryptoServerConfig* crypto_config, 180 QuicCompressedCertsCache* compressed_certs_cache); 181 QuicGenericServerSession( 182 QuicConnection* connection, bool owns_connection, Visitor* owner, 183 const QuicConfig& config, std::string alpn, 184 CreateWebTransportSessionVisitorCallback create_visitor_callback, 185 std::unique_ptr<QuicDatagramQueue::Observer> datagram_observer, 186 const QuicCryptoServerConfig* crypto_config, 187 QuicCompressedCertsCache* compressed_certs_cache); 188 189 // QuicSession implementation. GetMutableCryptoStream()190 QuicCryptoStream* GetMutableCryptoStream() override { 191 return crypto_stream_.get(); 192 } GetCryptoStream()193 const QuicCryptoStream* GetCryptoStream() const override { 194 return crypto_stream_.get(); 195 } 196 197 private: 198 std::unique_ptr<QuicCryptoServerStreamBase> crypto_stream_; 199 }; 200 201 } // namespace quic 202 203 #endif // QUICHE_QUIC_CORE_QUIC_GENERIC_CLIENT_SESSION_H_ 204