Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(947)

Unified Diff: net/quic/quic_connection.h

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: io_thread_unittest.cc Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/quic_config_test.cc ('k') | net/quic/quic_connection.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_connection.h
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
deleted file mode 100644
index 0269a9a9f09cf2768f227fa38c18da4d41e5b98f..0000000000000000000000000000000000000000
--- a/net/quic/quic_connection.h
+++ /dev/null
@@ -1,1080 +0,0 @@
-// 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_connection_stats.h"
-#include "net/quic/quic_framer.h"
-#include "net/quic/quic_multipath_sent_packet_manager.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 QuicSentPacketManagerInterface::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;
-
- // QuicConnectionCloseDelegateInterface
- void OnUnrecoverableError(QuicErrorCode error,
- const std::string& error_details,
- ConnectionCloseSource source) 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;
-
- // QuicSentPacketManager::NetworkChangeVisitor
- void OnCongestionChange() override;
- void OnPathDegrading() override;
- void OnPathMtuIncreased(QuicPacketLength packet_size) 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_
« no previous file with comments | « net/quic/quic_config_test.cc ('k') | net/quic/quic_connection.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698