blob: 46a3cbb88f82e7a475b80425a57603e031e6ea37 [file] [log] [blame]
// Copyright (c) 2012 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.
//
// The entity that handles framing writes for a Quic client or server.
// Each QuicSession will have a connection associated with it.
//
// On the server side, the Dispatcher handles the raw reads, and hands off
// packets via ProcessUdpPacket for framing and processing.
//
// On the client side, the Connection handles the raw reads, as well as the
// processing.
//
// Note: this class is not thread-safe.
#ifndef NET_QUIC_QUIC_CONNECTION_H_
#define NET_QUIC_QUIC_CONNECTION_H_
#include <stddef.h>
#include <stdint.h>
#include <deque>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/quic/crypto/quic_decrypter.h"
#include "net/quic/quic_alarm.h"
#include "net/quic/quic_alarm_factory.h"
#include "net/quic/quic_blocked_writer_interface.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_one_block_arena.h"
#include "net/quic/quic_packet_creator.h"
#include "net/quic/quic_packet_generator.h"
#include "net/quic/quic_packet_writer.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/quic_received_packet_manager.h"
#include "net/quic/quic_sent_entropy_manager.h"
#include "net/quic/quic_sent_packet_manager_interface.h"
#include "net/quic/quic_time.h"
#include "net/quic/quic_types.h"
namespace net {
class QuicClock;
class QuicConfig;
class QuicConnection;
class QuicEncrypter;
class QuicRandom;
namespace test {
class PacketSavingConnection;
class QuicConnectionPeer;
} // namespace test
// The initial number of packets between MTU probes. After each attempt the
// number is doubled.
const QuicPacketCount kPacketsBetweenMtuProbesBase = 100;
// The number of MTU probes that get sent before giving up.
const size_t kMtuDiscoveryAttempts = 3;
// Ensure that exponential back-off does not result in an integer overflow.
// The number of packets can be potentially capped, but that is not useful at
// current kMtuDiscoveryAttempts value, and hence is not implemented at present.
static_assert(kMtuDiscoveryAttempts + 8 < 8 * sizeof(QuicPacketNumber),
"The number of MTU discovery attempts is too high");
static_assert(kPacketsBetweenMtuProbesBase < (1 << 8),
"The initial number of packets between MTU probes is too high");
// The incresed packet size targeted when doing path MTU discovery.
const QuicByteCount kMtuDiscoveryTargetPacketSizeHigh = 1450;
const QuicByteCount kMtuDiscoveryTargetPacketSizeLow = 1430;
static_assert(kMtuDiscoveryTargetPacketSizeLow <= kMaxPacketSize,
"MTU discovery target is too large");
static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxPacketSize,
"MTU discovery target is too large");
static_assert(kMtuDiscoveryTargetPacketSizeLow > kDefaultMaxPacketSize,
"MTU discovery target does not exceed the default packet size");
static_assert(kMtuDiscoveryTargetPacketSizeHigh > kDefaultMaxPacketSize,
"MTU discovery target does not exceed the default packet size");
// Class that receives callbacks from the connection when frames are received
// and when other interesting events happen.
class NET_EXPORT_PRIVATE QuicConnectionVisitorInterface {
public:
virtual ~QuicConnectionVisitorInterface() {}
// A simple visitor interface for dealing with a data frame.
virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
// The session should process the WINDOW_UPDATE frame, adjusting both stream
// and connection level flow control windows.
virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) = 0;
// A BLOCKED frame indicates the peer is flow control blocked
// on a specified stream.
virtual void OnBlockedFrame(const QuicBlockedFrame& frame) = 0;
// Called when the stream is reset by the peer.
virtual void OnRstStream(const QuicRstStreamFrame& frame) = 0;
// Called when the connection is going away according to the peer.
virtual void OnGoAway(const QuicGoAwayFrame& frame) = 0;
// Called when the connection is closed either locally by the framer, or
// remotely by the peer.
virtual void OnConnectionClosed(QuicErrorCode error,
const std::string& error_details,
ConnectionCloseSource source) = 0;
// Called when the connection failed to write because the socket was blocked.
virtual void OnWriteBlocked() = 0;
// Called once a specific QUIC version is agreed by both endpoints.
virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
// Called when a blocked socket becomes writable.
virtual void OnCanWrite() = 0;
// Called when the connection experiences a change in congestion window.
virtual void OnCongestionWindowChange(QuicTime now) = 0;
// Called when the connection receives a packet from a migrated client.
virtual void OnConnectionMigration(PeerAddressChangeType type) = 0;
// Called when the peer seems unreachable over the current path.
virtual void OnPathDegrading() = 0;
// Called after OnStreamFrame, OnRstStream, OnGoAway, OnWindowUpdateFrame,
// OnBlockedFrame, and OnCanWrite to allow post-processing once the work has
// been done.
virtual void PostProcessAfterData() = 0;
// Called to ask if the visitor wants to schedule write resumption as it both
// has pending data to write, and is able to write (e.g. based on flow control
// limits).
// Writes may be pending because they were write-blocked, congestion-throttled
// or yielded to other connections.
virtual bool WillingAndAbleToWrite() const = 0;
// Called to ask if any handshake messages are pending in this visitor.
virtual bool HasPendingHandshake() const = 0;
// Called to ask if any streams are open in this visitor, excluding the
// reserved crypto and headers stream.
virtual bool HasOpenDynamicStreams() const = 0;
};
// Interface which gets callbacks from the QuicConnection at interesting
// points. Implementations must not mutate the state of the connection
// as a result of these callbacks.
class NET_EXPORT_PRIVATE QuicConnectionDebugVisitor
: public QuicSentPacketManagerInterface::DebugDelegate {
public:
~QuicConnectionDebugVisitor() override {}
// Called when a packet has been sent.
virtual void OnPacketSent(const SerializedPacket& serialized_packet,
QuicPathId original_path_id,
QuicPacketNumber original_packet_number,
TransmissionType transmission_type,
QuicTime sent_time) {}
// Called when a packet has been received, but before it is
// validated or parsed.
virtual void OnPacketReceived(const IPEndPoint& self_address,
const IPEndPoint& peer_address,
const QuicEncryptedPacket& packet) {}
// Called when the unauthenticated portion of the header has been parsed.
virtual void OnUnauthenticatedHeader(const QuicPacketHeader& header) {}
// Called when a packet is received with a connection id that does not
// match the ID of this connection.
virtual void OnIncorrectConnectionId(QuicConnectionId connection_id) {}
// Called when an undecryptable packet has been received.
virtual void OnUndecryptablePacket() {}
// Called when a duplicate packet has been received.
virtual void OnDuplicatePacket(QuicPacketNumber packet_number) {}
// Called when the protocol version on the received packet doensn't match
// current protocol version of the connection.
virtual void OnProtocolVersionMismatch(QuicVersion version) {}
// Called when the complete header of a packet has been parsed.
virtual void OnPacketHeader(const QuicPacketHeader& header) {}
// Called when a StreamFrame has been parsed.
virtual void OnStreamFrame(const QuicStreamFrame& frame) {}
// Called when a AckFrame has been parsed.
virtual void OnAckFrame(const QuicAckFrame& frame) {}
// Called when a StopWaitingFrame has been parsed.
virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {}
// Called when a QuicPaddingFrame has been parsed.
virtual void OnPaddingFrame(const QuicPaddingFrame& frame) {}
// Called when a Ping has been parsed.
virtual void OnPingFrame(const QuicPingFrame& frame) {}
// Called when a GoAway has been parsed.
virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) {}
// Called when a RstStreamFrame has been parsed.
virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) {}
// Called when a ConnectionCloseFrame has been parsed.
virtual void OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) {}
// Called when a WindowUpdate has been parsed.
virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) {}
// Called when a BlockedFrame has been parsed.
virtual void OnBlockedFrame(const QuicBlockedFrame& frame) {}
// Called when a PathCloseFrame has been parsed.
virtual void OnPathCloseFrame(const QuicPathCloseFrame& frame) {}
// Called when a public reset packet has been received.
virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {}
// Called when a version negotiation packet has been received.
virtual void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) {}
// Called when the connection is closed.
virtual void OnConnectionClosed(QuicErrorCode error,
const std::string& error_details,
ConnectionCloseSource source) {}
// Called when the version negotiation is successful.
virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) {}
// Called when a CachedNetworkParameters is sent to the client.
virtual void OnSendConnectionState(
const CachedNetworkParameters& cached_network_params) {}
// Called when a CachedNetworkParameters are recieved from the client.
virtual void OnReceiveConnectionState(
const CachedNetworkParameters& cached_network_params) {}
// Called when the connection parameters are set from the supplied
// |config|.
virtual void OnSetFromConfig(const QuicConfig& config) {}
// Called when RTT may have changed, including when an RTT is read from
// the config.
virtual void OnRttChanged(QuicTime::Delta rtt) const {}
};
// QuicConnections currently use around 1KB of polymorphic types which would
// ordinarily be on the heap. Instead, store them inline in an arena.
using QuicConnectionArena = QuicOneBlockArena<1024>;
class NET_EXPORT_PRIVATE QuicConnectionHelperInterface {
public:
virtual ~QuicConnectionHelperInterface() {}
// Returns a QuicClock to be used for all time related functions.
virtual const QuicClock* GetClock() const = 0;
// Returns a QuicRandom to be used for all random number related functions.
virtual QuicRandom* GetRandomGenerator() = 0;
// Returns a QuicBufferAllocator to be used for all stream frame buffers.
virtual QuicBufferAllocator* GetBufferAllocator() = 0;
};
class NET_EXPORT_PRIVATE QuicConnection
: public QuicFramerVisitorInterface,
public QuicBlockedWriterInterface,
public QuicPacketGenerator::DelegateInterface,
public QuicSentPacketManager::NetworkChangeVisitor {
public:
enum AckBundling {
// Send an ack if it's already queued in the connection.
SEND_ACK_IF_QUEUED,
// Always send an ack.
SEND_ACK,
// Bundle an ack with outgoing data.
SEND_ACK_IF_PENDING,
};
enum AckMode { TCP_ACKING, ACK_DECIMATION, ACK_DECIMATION_WITH_REORDERING };
// Constructs a new QuicConnection for |connection_id| and |address| using
// |writer| to write packets. |owns_writer| specifies whether the connection
// takes ownership of |writer|. |helper| must outlive this connection.
QuicConnection(QuicConnectionId connection_id,
IPEndPoint address,
QuicConnectionHelperInterface* helper,
QuicAlarmFactory* alarm_factory,
QuicPacketWriter* writer,
bool owns_writer,
Perspective perspective,
const QuicVersionVector& supported_versions);
~QuicConnection() override;
// Sets connection parameters from the supplied |config|.
void SetFromConfig(const QuicConfig& config);
// Called by the session when sending connection state to the client.
virtual void OnSendConnectionState(
const CachedNetworkParameters& cached_network_params);
// Called by the session when receiving connection state from the client.
virtual void OnReceiveConnectionState(
const CachedNetworkParameters& cached_network_params);
// Called by the Session when the client has provided CachedNetworkParameters.
virtual void ResumeConnectionState(
const CachedNetworkParameters& cached_network_params,
bool max_bandwidth_resumption);
// Called by the Session when a max pacing rate for the connection is needed.
virtual void SetMaxPacingRate(QuicBandwidth max_pacing_rate);
// Sets the number of active streams on the connection for congestion control.
void SetNumOpenStreams(size_t num_streams);
// Send the data in |data| to the peer in as few packets as possible.
// Returns a pair with the number of bytes consumed from data, and a boolean
// indicating if the fin bit was consumed. This does not indicate the data
// has been sent on the wire: it may have been turned into a packet and queued
// if the socket was unexpectedly blocked.
// If |listener| is provided, then it will be informed once ACKs have been
// received for all the packets written in this call.
// The |listener| is not owned by the QuicConnection and must outlive it.
virtual QuicConsumedData SendStreamData(QuicStreamId id,
QuicIOVector iov,
QuicStreamOffset offset,
bool fin,
QuicAckListenerInterface* listener);
// Send a RST_STREAM frame to the peer.
virtual void SendRstStream(QuicStreamId id,
QuicRstStreamErrorCode error,
QuicStreamOffset bytes_written);
// Send a BLOCKED frame to the peer.
virtual void SendBlocked(QuicStreamId id);
// Send a WINDOW_UPDATE frame to the peer.
virtual void SendWindowUpdate(QuicStreamId id, QuicStreamOffset byte_offset);
// Send a PATH_CLOSE frame to the peer.
virtual void SendPathClose(QuicPathId path_id);
// Closes the connection.
// |connection_close_behavior| determines whether or not a connection close
// packet is sent to the peer.
virtual void CloseConnection(
QuicErrorCode error,
const std::string& details,
ConnectionCloseBehavior connection_close_behavior);
// Sends a GOAWAY frame. Does nothing if a GOAWAY frame has already been sent.
virtual void SendGoAway(QuicErrorCode error,
QuicStreamId last_good_stream_id,
const std::string& reason);
// Returns statistics tracked for this connection.
const QuicConnectionStats& GetStats();
// Processes an incoming UDP packet (consisting of a QuicEncryptedPacket) from
// the peer.
// In a client, the packet may be "stray" and have a different connection ID
// than that of this connection.
virtual void ProcessUdpPacket(const IPEndPoint& self_address,
const IPEndPoint& peer_address,
const QuicReceivedPacket& packet);
// QuicBlockedWriterInterface
// Called when the underlying connection becomes writable to allow queued
// writes to happen.
void OnCanWrite() override;
// Called when an error occurs while attempting to write a packet to the
// network.
void OnWriteError(int error_code);
// If the socket is not blocked, writes queued packets.
void WriteIfNotBlocked();
// If the socket is not blocked, writes queued packets and bundles any pending
// ACKs.
void WriteAndBundleAcksIfNotBlocked();
// Set the packet writer.
void SetQuicPacketWriter(QuicPacketWriter* writer, bool owns_writer) {
DCHECK(writer != nullptr);
if (writer_ != nullptr && owns_writer_) {
delete writer_;
}
writer_ = writer;
owns_writer_ = owns_writer;
}
// Set self address.
void SetSelfAddress(IPEndPoint address) { self_address_ = address; }
// The version of the protocol this connection is using.
QuicVersion version() const { return framer_.version(); }
// The versions of the protocol that this connection supports.
const QuicVersionVector& supported_versions() const {
return framer_.supported_versions();
}
// From QuicFramerVisitorInterface
void OnError(QuicFramer* framer) override;
bool OnProtocolVersionMismatch(QuicVersion received_version) override;
void OnPacket() override;
void OnPublicResetPacket(const QuicPublicResetPacket& packet) override;
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) override;
bool OnUnauthenticatedPublicHeader(
const QuicPacketPublicHeader& header) override;
bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
void OnDecryptedPacket(EncryptionLevel level) override;
bool OnPacketHeader(const QuicPacketHeader& header) override;
bool OnStreamFrame(const QuicStreamFrame& frame) override;
bool OnAckFrame(const QuicAckFrame& frame) override;
bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
bool OnPaddingFrame(const QuicPaddingFrame& frame) override;
bool OnPingFrame(const QuicPingFrame& frame) override;
bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override;
bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
bool OnPathCloseFrame(const QuicPathCloseFrame& frame) override;
void OnPacketComplete() override;
// QuicPacketGenerator::DelegateInterface
bool ShouldGeneratePacket(HasRetransmittableData retransmittable,
IsHandshake handshake) override;
const QuicFrame GetUpdatedAckFrame() override;
void PopulateStopWaitingFrame(QuicStopWaitingFrame* stop_waiting) override;
// QuicPacketCreator::DelegateInterface
void OnSerializedPacket(SerializedPacket* packet) override;
void OnUnrecoverableError(QuicErrorCode error,
const std::string& error_details,
ConnectionCloseSource source) override;
// QuicSentPacketManager::NetworkChangeVisitor
void OnCongestionChange() override;
void OnPathDegrading() override;
// Called by the crypto stream when the handshake completes. In the server's
// case this is when the SHLO has been ACKed. Clients call this on receipt of
// the SHLO.
void OnHandshakeComplete();
// Accessors
void set_visitor(QuicConnectionVisitorInterface* visitor) {
visitor_ = visitor;
}
void set_debug_visitor(QuicConnectionDebugVisitor* debug_visitor) {
debug_visitor_ = debug_visitor;
sent_packet_manager_->SetDebugDelegate(debug_visitor);
}
// Used in Chromium, but not internally.
void set_creator_debug_delegate(QuicPacketCreator::DebugDelegate* visitor) {
packet_generator_.set_debug_delegate(visitor);
}
const IPEndPoint& self_address() const { return self_address_; }
const IPEndPoint& peer_address() const { return peer_address_; }
QuicConnectionId connection_id() const { return connection_id_; }
const QuicClock* clock() const { return clock_; }
QuicRandom* random_generator() const { return random_generator_; }
QuicByteCount max_packet_length() const;
void SetMaxPacketLength(QuicByteCount length);
size_t mtu_probe_count() const { return mtu_probe_count_; }
bool connected() const { return connected_; }
bool goaway_sent() const { return goaway_sent_; }
bool goaway_received() const { return goaway_received_; }
// Must only be called on client connections.
const QuicVersionVector& server_supported_versions() const {
DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
return server_supported_versions_;
}
// Testing only.
size_t NumQueuedPackets() const { return queued_packets_.size(); }
// Once called, any sent crypto packets to be saved as the
// termination packet, for use with stateless rejections.
void EnableSavingCryptoPackets();
// Returns true if the underlying UDP socket is writable, there is
// no queued data and the connection is not congestion-control
// blocked.
bool CanWriteStreamData();
// Returns true if the connection has queued packets or frames.
bool HasQueuedData() const;
// Sets the handshake and idle state connection timeouts.
void SetNetworkTimeouts(QuicTime::Delta handshake_timeout,
QuicTime::Delta idle_timeout);
// If the connection has timed out, this will close the connection.
// Otherwise, it will reschedule the timeout alarm.
void CheckForTimeout();
// Called when the ping alarm fires. Causes a ping frame to be sent only
// if the retransmission alarm is not running.
void OnPingTimeout();
// Sends a ping frame.
void SendPing();
// Sets up a packet with an QuicAckFrame and sends it out.
void SendAck();
// Called when an RTO fires. Resets the retransmission alarm if there are
// remaining unacked packets.
void OnRetransmissionTimeout();
// Retransmits all unacked packets with retransmittable frames if
// |retransmission_type| is ALL_UNACKED_PACKETS, otherwise retransmits only
// initially encrypted packets. Used when the negotiated protocol version is
// different from what was initially assumed and when the initial encryption
// changes.
void RetransmitUnackedPackets(TransmissionType retransmission_type);
// Calls |sent_packet_manager_|'s NeuterUnencryptedPackets. Used when the
// connection becomes forward secure and hasn't received acks for all packets.
void NeuterUnencryptedPackets();
// Changes the encrypter used for level |level| to |encrypter|. The function
// takes ownership of |encrypter|.
void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
// SetNonceForPublicHeader sets the nonce that will be transmitted in the
// public header of each packet encrypted at the initial encryption level
// decrypted. This should only be called on the server side.
void SetDiversificationNonce(const DiversificationNonce nonce);
// SetDefaultEncryptionLevel sets the encryption level that will be applied
// to new packets.
void SetDefaultEncryptionLevel(EncryptionLevel level);
// SetDecrypter sets the primary decrypter, replacing any that already exists,
// and takes ownership. If an alternative decrypter is in place then the
// function DCHECKs. This is intended for cases where one knows that future
// packets will be using the new decrypter and the previous decrypter is now
// obsolete. |level| indicates the encryption level of the new decrypter.
void SetDecrypter(EncryptionLevel level, QuicDecrypter* decrypter);
// SetAlternativeDecrypter sets a decrypter that may be used to decrypt
// future packets and takes ownership of it. |level| indicates the encryption
// level of the decrypter. If |latch_once_used| is true, then the first time
// that the decrypter is successful it will replace the primary decrypter.
// Otherwise both decrypters will remain active and the primary decrypter
// will be the one last used.
void SetAlternativeDecrypter(EncryptionLevel level,
QuicDecrypter* decrypter,
bool latch_once_used);
const QuicDecrypter* decrypter() const;
const QuicDecrypter* alternative_decrypter() const;
Perspective perspective() const { return perspective_; }
// Allow easy overriding of truncated connection IDs.
void set_can_truncate_connection_ids(bool can) {
can_truncate_connection_ids_ = can;
}
// Returns the underlying sent packet manager.
const QuicSentPacketManagerInterface& sent_packet_manager() const {
return *sent_packet_manager_;
}
bool CanWrite(HasRetransmittableData retransmittable);
// Stores current batch state for connection, puts the connection
// into batch mode, and destruction restores the stored batch state.
// While the bundler is in scope, any generated frames are bundled
// as densely as possible into packets. In addition, this bundler
// can be configured to ensure that an ACK frame is included in the
// first packet created, if there's new ack information to be sent.
class NET_EXPORT_PRIVATE ScopedPacketBundler {
public:
// In addition to all outgoing frames being bundled when the
// bundler is in scope, setting |include_ack| to true ensures that
// an ACK frame is opportunistically bundled with the first
// outgoing packet.
ScopedPacketBundler(QuicConnection* connection, AckBundling send_ack);
~ScopedPacketBundler();
private:
bool ShouldSendAck(AckBundling ack_mode) const;
QuicConnection* connection_;
bool already_in_batch_mode_;
};
// Delays setting the retransmission alarm until the scope is exited.
// When nested, only the outermost scheduler will set the alarm, and inner
// ones have no effect.
class NET_EXPORT_PRIVATE ScopedRetransmissionScheduler {
public:
explicit ScopedRetransmissionScheduler(QuicConnection* connection);
~ScopedRetransmissionScheduler();
private:
QuicConnection* connection_;
// Set to the connection's delay_setting_retransmission_alarm_ value in the
// constructor and when true, causes this class to do nothing.
const bool already_delayed_;
};
QuicPacketNumber packet_number_of_last_sent_packet() const {
return packet_number_of_last_sent_packet_;
}
QuicPacketWriter* writer() { return writer_; }
const QuicPacketWriter* writer() const { return writer_; }
// Sends an MTU discovery packet of size |target_mtu|. If the packet is
// acknowledged by the peer, the maximum packet size will be increased to
// |target_mtu|.
void SendMtuDiscoveryPacket(QuicByteCount target_mtu);
// Sends an MTU discovery packet of size |mtu_discovery_target_| and updates
// the MTU discovery alarm.
void DiscoverMtu();
// Return the name of the cipher of the primary decrypter of the framer.
const char* cipher_name() const { return framer_.decrypter()->cipher_name(); }
// Return the id of the cipher of the primary decrypter of the framer.
uint32_t cipher_id() const { return framer_.decrypter()->cipher_id(); }
std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets() {
return termination_packets_.get();
}
bool ack_queued() const { return ack_queued_; }
bool ack_frame_updated() const;
QuicConnectionHelperInterface* helper() { return helper_; }
QuicAlarmFactory* alarm_factory() { return alarm_factory_; }
base::StringPiece GetCurrentPacket();
const QuicPacketGenerator& packet_generator() const {
return packet_generator_;
}
EncryptionLevel encryption_level() const { return encryption_level_; }
const IPEndPoint& last_packet_source_address() const {
return last_packet_source_address_;
}
protected:
// Calls cancel() on all the alarms owned by this connection.
void CancelAllAlarms();
// Send a packet to the peer, and takes ownership of the packet if the packet
// cannot be written immediately.
virtual void SendOrQueuePacket(SerializedPacket* packet);
// Called after a packet is received from a new peer address on existing
// |path_id| and is decrypted. Starts validation of peer's address change.
virtual void StartPeerMigration(QuicPathId path_id,
PeerAddressChangeType peer_migration_type);
// Called when a peer address migration is validated on |path_id|.
virtual void OnPeerMigrationValidated(QuicPathId path_id);
// Selects and updates the version of the protocol being used by selecting a
// version from |available_versions| which is also supported. Returns true if
// such a version exists, false otherwise.
bool SelectMutualVersion(const QuicVersionVector& available_versions);
// Returns the current per-packet options for the connection.
PerPacketOptions* per_packet_options() { return per_packet_options_; }
// Sets the current per-packet options for the connection. The QuicConnection
// does not take ownership of |options|; |options| must live for as long as
// the QuicConnection is in use.
void set_per_packet_options(PerPacketOptions* options) {
per_packet_options_ = options;
}
// If |defer| is true, configures the connection to defer sending packets in
// response to an ACK to the SendAlarm. If |defer| is false, packets may be
// sent immediately after receiving an ACK.
void set_defer_send_in_response_to_packets(bool defer) {
defer_send_in_response_to_packets_ = defer;
}
PeerAddressChangeType active_peer_migration_type() {
return active_peer_migration_type_;
}
// Sends the connection close packet to the peer.
virtual void SendConnectionClosePacket(QuicErrorCode error,
const std::string& details);
private:
friend class test::QuicConnectionPeer;
friend class test::PacketSavingConnection;
typedef std::list<SerializedPacket> QueuedPacketList;
// Notifies the visitor of the close and marks the connection as disconnected.
// Does not send a connection close frame to the peer.
void TearDownLocalConnectionState(QuicErrorCode error,
const std::string& details,
ConnectionCloseSource source);
// Writes the given packet to socket, encrypted with packet's
// encryption_level. Returns true on successful write, and false if the writer
// was blocked and the write needs to be tried again. Notifies the
// SentPacketManager when the write is successful and sets
// retransmittable frames to nullptr.
// Saves the connection close packet for later transmission, even if the
// writer is write blocked.
bool WritePacket(SerializedPacket* packet);
// Make sure an ack we got from our peer is sane.
// Returns nullptr for valid acks or an error std::string if it was invalid.
const char* ValidateAckFrame(const QuicAckFrame& incoming_ack);
// Make sure a stop waiting we got from our peer is sane.
// Returns nullptr if the frame is valid or an error std::string if it was
// invalid.
const char* ValidateStopWaitingFrame(
const QuicStopWaitingFrame& stop_waiting);
// Sends a version negotiation packet to the peer.
void SendVersionNegotiationPacket();
// Clears any accumulated frames from the last received packet.
void ClearLastFrames();
// Deletes and clears any queued packets.
void ClearQueuedPackets();
// Closes the connection if the sent or received packet manager are tracking
// too many outstanding packets.
void MaybeCloseIfTooManyOutstandingPackets();
// Writes as many queued packets as possible. The connection must not be
// blocked when this is called.
void WriteQueuedPackets();
// Writes as many pending retransmissions as possible.
void WritePendingRetransmissions();
// Returns true if the packet should be discarded and not sent.
bool ShouldDiscardPacket(const SerializedPacket& packet);
// Queues |packet| in the hopes that it can be decrypted in the
// future, when a new key is installed.
void QueueUndecryptablePacket(const QuicEncryptedPacket& packet);
// Attempts to process any queued undecryptable packets.
void MaybeProcessUndecryptablePackets();
void ProcessAckFrame(const QuicAckFrame& incoming_ack);
void ProcessStopWaitingFrame(const QuicStopWaitingFrame& stop_waiting);
// Sends any packets which are a response to the last packet, including both
// acks and pending writes if an ack opened the congestion window.
void MaybeSendInResponseToPacket();
// Queue an ack or set the ack alarm if needed. |was_missing| is true if
// the most recently received packet was formerly missing.
void MaybeQueueAck(bool was_missing);
// Gets the least unacked packet number of |path_id|, which is the next packet
// number to be sent if there are no outstanding packets.
QuicPacketNumber GetLeastUnacked(QuicPathId path_id) const;
// Sets the timeout alarm to the appropriate value, if any.
void SetTimeoutAlarm();
// Sets the ping alarm to the appropriate value, if any.
void SetPingAlarm();
// Sets the retransmission alarm based on SentPacketManager.
void SetRetransmissionAlarm();
// Sets the MTU discovery alarm if necessary.
void MaybeSetMtuAlarm();
// On arrival of a new packet, checks to see if the socket addresses have
// changed since the last packet we saw on this connection.
void CheckForAddressMigration(const IPEndPoint& self_address,
const IPEndPoint& peer_address);
HasRetransmittableData IsRetransmittable(const SerializedPacket& packet);
bool IsTerminationPacket(const SerializedPacket& packet);
// Set the size of the packet we are targeting while doing path MTU discovery.
void SetMtuDiscoveryTarget(QuicByteCount target);
// Validates the potential maximum packet size, and reduces it if it exceeds
// the largest supported by the protocol or the packet writer.
QuicByteCount LimitMaxPacketSize(QuicByteCount suggested_max_packet_size);
// Called when |path_id| is considered as closed because either a PATH_CLOSE
// frame is sent or received. Stops receiving packets on closed path. Drops
// receive side of a closed path, and packets with retransmittable frames on a
// closed path are marked as retransmissions which will be transmitted on
// other paths.
// TODO(fayang): complete OnPathClosed once QuicMultipathSentPacketManager and
// QuicMultipathReceivedPacketManager are landed in QuicConnection.
void OnPathClosed(QuicPathId path_id);
// Do any work which logically would be done in OnPacket but can not be
// safely done until the packet is validated. Returns true if packet can be
// handled, false otherwise.
bool ProcessValidatedPacket(const QuicPacketHeader& header);
// Consider receiving crypto frame on non crypto stream as memory corruption.
bool MaybeConsiderAsMemoryCorruption(const QuicStreamFrame& frame);
const QuicTime::Delta DelayedAckTime();
QuicFramer framer_;
QuicConnectionHelperInterface* helper_; // Not owned.
QuicAlarmFactory* alarm_factory_; // Not owned.
PerPacketOptions* per_packet_options_; // Not owned.
QuicPacketWriter* writer_; // Owned or not depending on |owns_writer_|.
bool owns_writer_;
// Encryption level for new packets. Should only be changed via
// SetDefaultEncryptionLevel().
EncryptionLevel encryption_level_;
bool has_forward_secure_encrypter_;
// The packet number of the first packet which will be encrypted with the
// foward-secure encrypter, even if the peer has not started sending
// forward-secure packets.
QuicPacketNumber first_required_forward_secure_packet_;
const QuicClock* clock_;
QuicRandom* random_generator_;
const QuicConnectionId connection_id_;
// Address on the last successfully processed packet received from the
// client.
IPEndPoint self_address_;
IPEndPoint peer_address_;
// Records change type when the peer initiates migration to a new peer
// address. Reset to NO_CHANGE after peer migration is validated.
PeerAddressChangeType active_peer_migration_type_;
// Records highest sent packet number when peer migration is started.
QuicPacketNumber highest_packet_sent_before_peer_migration_;
// True if the last packet has gotten far enough in the framer to be
// decrypted.
bool last_packet_decrypted_;
QuicByteCount last_size_; // Size of the last received packet.
// TODO(rch): remove this when b/27221014 is fixed.
const char* current_packet_data_; // UDP payload of packet currently being
// parsed or nullptr.
EncryptionLevel last_decrypted_packet_level_;
QuicPacketHeader last_header_;
QuicStopWaitingFrame last_stop_waiting_frame_;
bool should_last_packet_instigate_acks_;
// Track some peer state so we can do less bookkeeping
// Largest sequence sent by the peer which had an ack frame (latest ack info).
QuicPacketNumber largest_seen_packet_with_ack_;
// Largest packet number sent by the peer which had a stop waiting frame.
QuicPacketNumber largest_seen_packet_with_stop_waiting_;
// Collection of packets which were received before encryption was
// established, but which could not be decrypted. We buffer these on
// the assumption that they could not be processed because they were
// sent with the INITIAL encryption and the CHLO message was lost.
std::deque<QuicEncryptedPacket*> undecryptable_packets_;
// Maximum number of undecryptable packets the connection will store.
size_t max_undecryptable_packets_;
// When the version negotiation packet could not be sent because the socket
// was not writable, this is set to true.
bool pending_version_negotiation_packet_;
// When packets could not be sent because the socket was not writable,
// they are added to this std::list. All corresponding frames are in
// unacked_packets_ if they are to be retransmitted. Packets encrypted_buffer
// fields are owned by the QueuedPacketList, in order to ensure they outlast
// the original scope of the SerializedPacket.
QueuedPacketList queued_packets_;
// If true, then crypto packets will be saved as termination packets.
bool save_crypto_packets_as_termination_packets_;
// Contains the connection close packets if the connection has been closed.
std::unique_ptr<std::vector<std::unique_ptr<QuicEncryptedPacket>>>
termination_packets_;
// Determines whether or not a connection close packet is sent to the peer
// after idle timeout due to lack of network activity.
// This is particularly important on mobile, where waking up the radio is
// undesirable.
ConnectionCloseBehavior idle_timeout_connection_close_behavior_;
// When true, close the QUIC connection after 5 RTOs. Due to the min rto of
// 200ms, this is over 5 seconds.
bool close_connection_after_five_rtos_;
QuicReceivedPacketManager received_packet_manager_;
QuicSentEntropyManager sent_entropy_manager_;
// Indicates whether an ack should be sent the next time we try to write.
bool ack_queued_;
// How many retransmittable packets have arrived without sending an ack.
QuicPacketCount num_retransmittable_packets_received_since_last_ack_sent_;
// Whether there were missing packets in the last sent ack.
bool last_ack_had_missing_packets_;
// How many consecutive packets have arrived without sending an ack.
QuicPacketCount num_packets_received_since_last_ack_sent_;
// Indicates how many consecutive times an ack has arrived which indicates
// the peer needs to stop waiting for some packets.
int stop_waiting_count_;
// Indicates the current ack mode, defaults to acking every 2 packets.
AckMode ack_mode_;
// The max delay in fraction of min_rtt to use when sending decimated acks.
float ack_decimation_delay_;
// Indicates the retransmit alarm is going to be set by the
// ScopedRetransmitAlarmDelayer
bool delay_setting_retransmission_alarm_;
// Indicates the retransmission alarm needs to be set.
bool pending_retransmission_alarm_;
// If true, defer sending data in response to received packets to the
// SendAlarm.
bool defer_send_in_response_to_packets_;
// Arena to store class implementations within the QuicConnection.
QuicConnectionArena arena_;
// An alarm that fires when an ACK should be sent to the peer.
QuicArenaScopedPtr<QuicAlarm> ack_alarm_;
// An alarm that fires when a packet needs to be retransmitted.
QuicArenaScopedPtr<QuicAlarm> retransmission_alarm_;
// An alarm that is scheduled when the SentPacketManager requires a delay
// before sending packets and fires when the packet may be sent.
QuicArenaScopedPtr<QuicAlarm> send_alarm_;
// An alarm that is scheduled when the connection can still write and there
// may be more data to send.
// TODO(ianswett): Remove resume_writes_alarm when deprecating
// FLAGS_quic_only_one_sending_alarm
QuicArenaScopedPtr<QuicAlarm> resume_writes_alarm_;
// An alarm that fires when the connection may have timed out.
QuicArenaScopedPtr<QuicAlarm> timeout_alarm_;
// An alarm that fires when a ping should be sent.
QuicArenaScopedPtr<QuicAlarm> ping_alarm_;
// An alarm that fires when an MTU probe should be sent.
QuicArenaScopedPtr<QuicAlarm> mtu_discovery_alarm_;
// Neither visitor is owned by this class.
QuicConnectionVisitorInterface* visitor_;
QuicConnectionDebugVisitor* debug_visitor_;
QuicPacketGenerator packet_generator_;
// Network idle time before this connection is closed.
QuicTime::Delta idle_network_timeout_;
// The connection will wait this long for the handshake to complete.
QuicTime::Delta handshake_timeout_;
// Statistics for this session.
QuicConnectionStats stats_;
// The time that we got a packet for this connection.
// This is used for timeouts, and does not indicate the packet was processed.
QuicTime time_of_last_received_packet_;
// The last time this connection began sending a new (non-retransmitted)
// packet.
QuicTime time_of_last_sent_new_packet_;
// The the send time of the first retransmittable packet sent after
// |time_of_last_received_packet_|.
QuicTime last_send_for_timeout_;
// packet number of the last sent packet. Packets are guaranteed to be sent
// in packet number order.
QuicPacketNumber packet_number_of_last_sent_packet_;
// Sent packet manager which tracks the status of packets sent by this
// connection and contains the send and receive algorithms to determine when
// to send packets.
std::unique_ptr<QuicSentPacketManagerInterface> sent_packet_manager_;
// The state of connection in version negotiation finite state machine.
QuicVersionNegotiationState version_negotiation_state_;
// Tracks if the connection was created by the server or the client.
Perspective perspective_;
// True by default. False if we've received or sent an explicit connection
// close.
bool connected_;
// Destination address of the last received packet.
IPEndPoint last_packet_destination_address_;
// Source address of the last received packet.
IPEndPoint last_packet_source_address_;
// Set to false if the connection should not send truncated connection IDs to
// the peer, even if the peer supports it.
bool can_truncate_connection_ids_;
// If non-empty this contains the set of versions received in a
// version negotiation packet.
QuicVersionVector server_supported_versions_;
// The size of the packet we are targeting while doing path MTU discovery.
QuicByteCount mtu_discovery_target_;
// The number of MTU probes already sent.
size_t mtu_probe_count_;
// The number of packets between MTU probes.
QuicPacketCount packets_between_mtu_probes_;
// The packet number of the packet after which the next MTU probe will be
// sent.
QuicPacketNumber next_mtu_probe_at_;
// The size of the largest packet received from peer.
QuicByteCount largest_received_packet_size_;
// Whether a GoAway has been sent.
bool goaway_sent_;
// Whether a GoAway has been received.
bool goaway_received_;
// If true, multipath is enabled for this connection.
bool multipath_enabled_;
DISALLOW_COPY_AND_ASSIGN(QuicConnection);
};
} // namespace net
#endif // NET_QUIC_QUIC_CONNECTION_H_