blob: 840f69d084bc7fc059f37b47acf8406cf9f1a92b [file] [log] [blame]
// Copyright (c) 2017 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 <memory>
#include <string>
#include "net/third_party/quiche/src/quic/core/quic_crypto_client_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
#include "net/third_party/quiche/src/quic/core/quic_session.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_packet_writer.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_stream.h"
namespace quic {
// QuartcSession owns and manages a QUIC connection.
class QuartcSession : public QuicSession,
public QuartcPacketTransport::Delegate {
QuartcSession(std::unique_ptr<QuicConnection> connection,
Visitor* visitor,
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
const QuicClock* clock);
QuartcSession(const QuartcSession&) = delete;
QuartcSession& operator=(const QuartcSession&) = delete;
~QuartcSession() override;
// QuicSession overrides.
QuartcStream* CreateOutgoingBidirectionalStream();
// Sends short unreliable message using quic message frame (message must fit
// in one quic packet). If connection is blocked by congestion control,
// message will be queued and resent later after receiving an OnCanWrite
// notification.
// Message size must be <= GetLargestMessagePayload().
// Supported in quic version 45 or later.
// Returns false and logs error if message is too long or session does not
// support SendMessage API. Other unexpected errors during send will not be
// returned, because messages can be sent later if connection is congestion
// controlled.
// |datagram_id| is used to notify when message was sent in
// Delegate::OnMessageSent.
// TODO(sukhanov): We can not use QUIC message ID for notifications, because
// QUIC does not take ownership of messages and if connection is congestion
// controlled, message is not sent and does not get message id until it is
// sent successfully. It also creates problem of flow control between
// messages and streams if they are used together. We discussed it with QUIC
// team and there are multiple solutions, but for now we have to use our
// own datagram identification.
bool SendOrQueueMessage(QuicMemSliceSpan message, int64_t datagram_id);
// Returns largest message payload acceptable in SendQuartcMessage.
QuicPacketLength GetCurrentLargestMessagePayload() const {
return connection()->GetCurrentLargestMessagePayload();
// Return true if transport support message frame.
bool CanSendMessage() const {
return connection()->transport_version() > QUIC_VERSION_44;
void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
// QuicConnectionVisitorInterface overrides.
void OnCongestionWindowChange(QuicTime now) override;
bool ShouldKeepConnectionAlive() const override;
void OnCanWrite() override;
bool SendProbingData() override;
void OnConnectionClosed(QuicErrorCode error,
const std::string& error_details,
ConnectionCloseSource source) override;
// QuartcSession methods.
virtual void StartCryptoHandshake() = 0;
// Closes the connection with the given human-readable error details.
// The connection closes with the QUIC_CONNECTION_CANCELLED error code to
// indicate the application closed it.
// Informs the peer that the connection has been closed. This prevents the
// peer from waiting until the connection times out.
// Cleans up the underlying QuicConnection's state. Closing the connection
// makes it safe to delete the QuartcSession.
void CloseConnection(const std::string& details);
// If the given stream is still open, sends a reset frame to cancel it.
// Note: This method cancels a stream by QuicStreamId rather than by pointer
// (or by a method on QuartcStream) because QuartcSession (and not
// the caller) owns the streams. Streams may finish and be deleted before the
// caller tries to cancel them, rendering the caller's pointers invalid.
void CancelStream(QuicStreamId stream_id);
// Callbacks called by the QuartcSession to notify the user of the
// QuartcSession of certain events.
class Delegate {
virtual ~Delegate() {}
// Called when the crypto handshake is complete. Crypto handshake on the
// client is only completed _after_ SHLO is received, but we can actually
// start sending media data right after CHLO is sent.
virtual void OnCryptoHandshakeComplete() = 0;
// Connection can be writable even before crypto handshake is complete.
// In particular, on the client, we can start sending data after sending
// full CHLO, without waiting for SHLO. This reduces a send delay by 1-rtt.
// This may be called multiple times.
virtual void OnConnectionWritable() = 0;
// Called when a new stream is received from the remote endpoint.
virtual void OnIncomingStream(QuartcStream* stream) = 0;
// Called when network parameters change in response to an ack frame.
virtual void OnCongestionControlChange(QuicBandwidth bandwidth_estimate,
QuicBandwidth pacing_rate,
QuicTime::Delta latest_rtt) = 0;
// Called when the connection is closed. This means all of the streams will
// be closed and no new streams can be created.
virtual void OnConnectionClosed(QuicErrorCode error_code,
const std::string& error_details,
ConnectionCloseSource source) = 0;
// Called when message (sent as SendMessage) is received.
virtual void OnMessageReceived(QuicStringPiece message) = 0;
// Called when message is sent to QUIC.
// Takes into account delay due to congestion control, but does not take
// into account any additional socket delays.
// Passed |datagram_id| is the same used in SendOrQueueMessage.
// TODO(sukhanov): We can take into account socket delay, but it's not clear
// if it's worth doing if we eventually plan to move congestion control to
// QUIC in QRTP model. If we need to do it, mellem@ thinks it's fairly
// strtaightforward: QUIC does not know about socket delay, but ICE does. We
// can tell ICE the QUIC packet number for each packet sent, and it will
// echo it back to us when the packet actually goes out. We just need to
// plumb that signal up to RTP's congestion control.
virtual void OnMessageSent(int64_t datagram_id) = 0;
// TODO(zhihuang): Add proof verification.
// The |delegate| is not owned by QuartcSession.
void SetDelegate(Delegate* session_delegate);
// Called when CanWrite() changes from false to true.
void OnTransportCanWrite() override;
// Called when a packet has been received and should be handled by the
// QuicConnection.
void OnTransportReceived(const char* data, size_t data_len) override;
void OnMessageReceived(QuicStringPiece message) override;
// Returns number of queued (not sent) messages submitted by
// SendOrQueueMessage. Messages are queued if connection is congestion
// controlled.
size_t send_message_queue_size() const { return send_message_queue_.size(); }
// QuicSession override.
QuicStream* CreateIncomingStream(QuicStreamId id) override;
QuicStream* CreateIncomingStream(PendingStream pending) override;
std::unique_ptr<QuartcStream> CreateDataStream(QuicStreamId id,
spdy::SpdyPriority priority);
std::unique_ptr<QuartcStream> CreateDataStream(PendingStream pending,
spdy::SpdyPriority priority);
// Activates a QuartcStream. The session takes ownership of the stream, but
// returns an unowned pointer to the stream for convenience.
QuartcStream* ActivateDataStream(std::unique_ptr<QuartcStream> stream);
void ResetStream(QuicStreamId stream_id, QuicRstStreamErrorCode error);
const QuicClock* clock() { return clock_; }
std::unique_ptr<QuartcStream> InitializeDataStream(
std::unique_ptr<QuartcStream> stream,
spdy::SpdyPriority priority);
// Holds message until it's sent.
struct QueuedMessage {
QueuedMessage(QuicMemSlice the_message, int64_t the_datagram_id)
: message(std::move(the_message)), datagram_id(the_datagram_id) {}
QuicMemSlice message;
int64_t datagram_id;
void ProcessSendMessageQueue();
// Take ownership of the QuicConnection. Note: if |connection_| changes,
// the new value of |connection_| must be given to |packet_writer_| before any
// packets are written. Otherwise, |packet_writer_| will crash.
std::unique_ptr<QuicConnection> connection_;
// For recording packet receipt time
const QuicClock* clock_;
// Not owned by QuartcSession.
Delegate* session_delegate_ = nullptr;
// Options passed to the packet writer for each packet.
std::unique_ptr<QuartcPerPacketOptions> per_packet_options_;
// Queue of pending messages sent by SendQuartcMessage that were not sent
// yet or blocked by congestion control. Messages are queued in the order
// of sent by SendOrQueueMessage().
QuicDeque<QueuedMessage> send_message_queue_;
class QuartcClientSession : public QuartcSession,
public QuicCryptoClientStream::ProofHandler {
std::unique_ptr<QuicConnection> connection,
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
const QuicClock* clock,
std::unique_ptr<QuartcPacketWriter> packet_writer,
std::unique_ptr<QuicCryptoClientConfig> client_crypto_config,
QuicStringPiece server_crypto_config);
QuartcClientSession(const QuartcClientSession&) = delete;
QuartcClientSession& operator=(const QuartcClientSession&) = delete;
~QuartcClientSession() override;
// Initialize should not be called on a QuartcSession. Instead, call
// StartCryptoHandshake().
// TODO(mellem): Move creation of the crypto stream into Initialize() and
// remove StartCryptoHandshake() to bring QuartcSession in line with other
// implementations of QuicSession, which can be started by calling
// Initialize().
void Initialize() override;
// Accessors for the client crypto stream.
QuicCryptoStream* GetMutableCryptoStream() override;
const QuicCryptoStream* GetCryptoStream() const override;
// Initializes the session and sends a handshake.
void StartCryptoHandshake() override;
// ProofHandler overrides.
void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override;
// Called by the client crypto handshake when proof verification details
// become available, either because proof verification is complete, or when
// cached details are used.
void OnProofVerifyDetailsAvailable(
const ProofVerifyDetails& verify_details) override;
// Packet writer used by |connection_|.
std::unique_ptr<QuartcPacketWriter> packet_writer_;
// Config for QUIC crypto stream.
std::unique_ptr<QuicCryptoClientConfig> client_crypto_config_;
// Client perspective crypto stream.
std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
const std::string server_config_;
class QuartcServerSession : public QuartcSession {
QuartcServerSession(std::unique_ptr<QuicConnection> connection,
Visitor* visitor,
const QuicConfig& config,
const ParsedQuicVersionVector& supported_versions,
const QuicClock* clock,
const QuicCryptoServerConfig* server_crypto_config,
QuicCompressedCertsCache* const compressed_certs_cache,
QuicCryptoServerStream::Helper* const stream_helper);
QuartcServerSession(const QuartcServerSession&) = delete;
QuartcServerSession& operator=(const QuartcServerSession&) = delete;
// Accessors for the server crypto stream.
QuicCryptoStream* GetMutableCryptoStream() override;
const QuicCryptoStream* GetCryptoStream() const override;
// Initializes the session and prepares to receive a handshake.
void StartCryptoHandshake() override;
// Config for QUIC crypto stream.
const QuicCryptoServerConfig* server_crypto_config_;
// Used by QUIC crypto server stream to track most recently compressed certs.
QuicCompressedCertsCache* const compressed_certs_cache_;
// This helper is needed to create QuicCryptoServerStream.
QuicCryptoServerStream::Helper* const stream_helper_;
// Server perspective crypto stream.
std::unique_ptr<QuicCryptoServerStream> crypto_stream_;
} // namespace quic