| // 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. |
| |
| // Handles packets for connection_ids in time wait state by discarding the |
| // packet and sending the peers termination packets with exponential backoff. |
| |
| #ifndef QUICHE_QUIC_CORE_QUIC_TIME_WAIT_LIST_MANAGER_H_ |
| #define QUICHE_QUIC_CORE_QUIC_TIME_WAIT_LIST_MANAGER_H_ |
| |
| #include <cstddef> |
| #include <memory> |
| |
| #include "absl/container/flat_hash_map.h" |
| #include "quic/core/quic_blocked_writer_interface.h" |
| #include "quic/core/quic_connection_id.h" |
| #include "quic/core/quic_framer.h" |
| #include "quic/core/quic_packet_writer.h" |
| #include "quic/core/quic_packets.h" |
| #include "quic/core/quic_session.h" |
| #include "quic/core/quic_types.h" |
| #include "quic/platform/api/quic_flags.h" |
| #include "common/quiche_linked_hash_map.h" |
| |
| namespace quic { |
| |
| namespace test { |
| class QuicDispatcherPeer; |
| class QuicTimeWaitListManagerPeer; |
| } // namespace test |
| |
| // TimeWaitConnectionInfo comprises information of a connection which is in the |
| // time wait list. |
| struct QUIC_NO_EXPORT TimeWaitConnectionInfo { |
| TimeWaitConnectionInfo( |
| bool ietf_quic, |
| std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets, |
| std::vector<QuicConnectionId> active_connection_ids); |
| TimeWaitConnectionInfo( |
| bool ietf_quic, |
| std::vector<std::unique_ptr<QuicEncryptedPacket>>* termination_packets, |
| std::vector<QuicConnectionId> active_connection_ids, |
| QuicTime::Delta srtt); |
| |
| TimeWaitConnectionInfo(const TimeWaitConnectionInfo& other) = delete; |
| TimeWaitConnectionInfo(TimeWaitConnectionInfo&& other) = default; |
| |
| ~TimeWaitConnectionInfo() = default; |
| |
| bool ietf_quic; |
| std::vector<std::unique_ptr<QuicEncryptedPacket>> termination_packets; |
| std::vector<QuicConnectionId> active_connection_ids; |
| QuicTime::Delta srtt; |
| }; |
| |
| // Maintains a list of all connection_ids that have been recently closed. A |
| // connection_id lives in this state for time_wait_period_. All packets received |
| // for connection_ids in this state are handed over to the |
| // QuicTimeWaitListManager by the QuicDispatcher. Decides whether to send a |
| // public reset packet, a copy of the previously sent connection close packet, |
| // or nothing to the peer which sent a packet with the connection_id in time |
| // wait state. After the connection_id expires its time wait period, a new |
| // connection/session will be created if a packet is received for this |
| // connection_id. |
| class QUIC_NO_EXPORT QuicTimeWaitListManager |
| : public QuicBlockedWriterInterface { |
| public: |
| // Specifies what the time wait list manager should do when processing packets |
| // of a time wait connection. |
| enum TimeWaitAction : uint8_t { |
| // Send specified termination packets, error if termination packet is |
| // unavailable. |
| SEND_TERMINATION_PACKETS, |
| // The same as SEND_TERMINATION_PACKETS except that the corresponding |
| // termination packets are provided by the connection. |
| SEND_CONNECTION_CLOSE_PACKETS, |
| // Send stateless reset (public reset for GQUIC). |
| SEND_STATELESS_RESET, |
| |
| DO_NOTHING, |
| }; |
| |
| class QUIC_NO_EXPORT Visitor : public QuicSession::Visitor { |
| public: |
| // Called after the given connection is added to the time-wait list. |
| virtual void OnConnectionAddedToTimeWaitList( |
| QuicConnectionId connection_id) = 0; |
| }; |
| |
| // writer - the entity that writes to the socket. (Owned by the caller) |
| // visitor - the entity that manages blocked writers. (Owned by the caller) |
| // clock - provide a clock (Owned by the caller) |
| // alarm_factory - used to run clean up alarms. (Owned by the caller) |
| QuicTimeWaitListManager(QuicPacketWriter* writer, |
| Visitor* visitor, |
| const QuicClock* clock, |
| QuicAlarmFactory* alarm_factory); |
| QuicTimeWaitListManager(const QuicTimeWaitListManager&) = delete; |
| QuicTimeWaitListManager& operator=(const QuicTimeWaitListManager&) = delete; |
| ~QuicTimeWaitListManager() override; |
| |
| // Adds the connection IDs in info to time wait state for time_wait_period_. |
| // If |info|.termination_packets are provided, copies of these packets will be |
| // sent when a packet with one of these connection IDs is processed. Any |
| // termination packets will be move from |info|.termination_packets and will |
| // become owned by the manager. |action| specifies what the time wait list |
| // manager should do when processing packets of the connection. |
| virtual void AddConnectionIdToTimeWait(TimeWaitAction action, |
| TimeWaitConnectionInfo info); |
| |
| // Returns true if the connection_id is in time wait state, false otherwise. |
| // Packets received for this connection_id should not lead to creation of new |
| // QuicSessions. |
| bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) const; |
| |
| // Called when a packet is received for a connection_id that is in time wait |
| // state. Sends a public reset packet to the peer which sent this |
| // connection_id. Sending of the public reset packet is throttled by using |
| // exponential back off. QUICHE_DCHECKs for the connection_id to be in time |
| // wait state. virtual to override in tests. |
| // TODO(fayang): change ProcessPacket and SendPublicReset to take |
| // ReceivedPacketInfo. |
| virtual void ProcessPacket( |
| const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| QuicConnectionId connection_id, |
| PacketHeaderFormat header_format, |
| size_t received_packet_length, |
| std::unique_ptr<QuicPerPacketContext> packet_context); |
| |
| // Called by the dispatcher when the underlying socket becomes writable again, |
| // since we might need to send pending public reset packets which we didn't |
| // send because the underlying socket was write blocked. |
| void OnBlockedWriterCanWrite() override; |
| |
| bool IsWriterBlocked() const override { |
| return writer_ != nullptr && writer_->IsWriteBlocked(); |
| } |
| |
| // Used to delete connection_id entries that have outlived their time wait |
| // period. |
| void CleanUpOldConnectionIds(); |
| |
| // If necessary, trims the oldest connections from the time-wait list until |
| // the size is under the configured maximum. |
| void TrimTimeWaitListIfNeeded(); |
| |
| // The number of connections on the time-wait list. |
| size_t num_connections() const { return connection_id_map_.size(); } |
| |
| // Sends a version negotiation packet for |server_connection_id| and |
| // |client_connection_id| announcing support for |supported_versions| to |
| // |peer_address| from |self_address|. |
| virtual void SendVersionNegotiationPacket( |
| QuicConnectionId server_connection_id, |
| QuicConnectionId client_connection_id, |
| bool ietf_quic, |
| bool use_length_prefix, |
| const ParsedQuicVersionVector& supported_versions, |
| const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| std::unique_ptr<QuicPerPacketContext> packet_context); |
| |
| // Creates a public reset packet and sends it or queues it to be sent later. |
| virtual void SendPublicReset( |
| const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| QuicConnectionId connection_id, |
| bool ietf_quic, |
| size_t received_packet_length, |
| std::unique_ptr<QuicPerPacketContext> packet_context); |
| |
| // Called to send |packet|. |
| virtual void SendPacket(const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| const QuicEncryptedPacket& packet); |
| |
| // Return a non-owning pointer to the packet writer. |
| QuicPacketWriter* writer() { return writer_; } |
| |
| protected: |
| virtual std::unique_ptr<QuicEncryptedPacket> BuildPublicReset( |
| const QuicPublicResetPacket& packet); |
| |
| virtual void GetEndpointId(std::string* /*endpoint_id*/) {} |
| |
| // Returns a stateless reset token which will be included in the public reset |
| // packet. |
| virtual StatelessResetToken GetStatelessResetToken( |
| QuicConnectionId connection_id) const; |
| |
| // Internal structure to store pending termination packets. |
| class QUIC_NO_EXPORT QueuedPacket { |
| public: |
| QueuedPacket(const QuicSocketAddress& self_address, |
| const QuicSocketAddress& peer_address, |
| std::unique_ptr<QuicEncryptedPacket> packet) |
| : self_address_(self_address), |
| peer_address_(peer_address), |
| packet_(std::move(packet)) {} |
| QueuedPacket(const QueuedPacket&) = delete; |
| QueuedPacket& operator=(const QueuedPacket&) = delete; |
| |
| const QuicSocketAddress& self_address() const { return self_address_; } |
| const QuicSocketAddress& peer_address() const { return peer_address_; } |
| QuicEncryptedPacket* packet() { return packet_.get(); } |
| |
| private: |
| // Server address on which a packet was received for a connection_id in |
| // time wait state. |
| const QuicSocketAddress self_address_; |
| // Address of the peer to send this packet to. |
| const QuicSocketAddress peer_address_; |
| // The pending termination packet that is to be sent to the peer. |
| std::unique_ptr<QuicEncryptedPacket> packet_; |
| }; |
| |
| // Called right after |packet| is serialized. Either sends the packet and |
| // deletes it or makes pending_packets_queue_ the owner of the packet. |
| // Subclasses overriding this method should call this class's base |
| // implementation at the end of the override. |
| // Return true if |packet| is sent, false if it is queued. |
| virtual bool SendOrQueuePacket(std::unique_ptr<QueuedPacket> packet, |
| const QuicPerPacketContext* packet_context); |
| |
| const quiche::QuicheCircularDeque<std::unique_ptr<QueuedPacket>>& |
| pending_packets_queue() const { |
| return pending_packets_queue_; |
| } |
| |
| private: |
| friend class test::QuicDispatcherPeer; |
| friend class test::QuicTimeWaitListManagerPeer; |
| |
| // Decides if a packet should be sent for this connection_id based on the |
| // number of received packets. |
| bool ShouldSendResponse(int received_packet_count); |
| |
| // Sends the packet out. Returns true if the packet was successfully consumed. |
| // If the writer got blocked and did not buffer the packet, we'll need to keep |
| // the packet and retry sending. In case of all other errors we drop the |
| // packet. |
| bool WriteToWire(QueuedPacket* packet); |
| |
| // Register the alarm server to wake up at appropriate time. |
| void SetConnectionIdCleanUpAlarm(); |
| |
| // Removes the oldest connection from the time-wait list if it was added prior |
| // to "expiration_time". To unconditionally remove the oldest connection, use |
| // a QuicTime::Delta:Infinity(). This function modifies the |
| // connection_id_map_. If you plan to call this function in a loop, any |
| // iterators that you hold before the call to this function may be invalid |
| // afterward. Returns true if the oldest connection was expired. Returns |
| // false if the map is empty or the oldest connection has not expired. |
| bool MaybeExpireOldestConnection(QuicTime expiration_time); |
| |
| // Called when a packet is received for a connection in this time wait list. |
| virtual void OnPacketReceivedForKnownConnection( |
| int /*num_packets*/, |
| QuicTime::Delta /*delta*/, |
| QuicTime::Delta /*srtt*/) const {} |
| |
| std::unique_ptr<QuicEncryptedPacket> BuildIetfStatelessResetPacket( |
| QuicConnectionId connection_id, |
| size_t received_packet_length); |
| |
| // A map from a recently closed connection_id to the number of packets |
| // received after the termination of the connection bound to the |
| // connection_id. |
| struct QUIC_NO_EXPORT ConnectionIdData { |
| ConnectionIdData(int num_packets, |
| QuicTime time_added, |
| TimeWaitAction action, |
| TimeWaitConnectionInfo info); |
| |
| ConnectionIdData(const ConnectionIdData& other) = delete; |
| ConnectionIdData(ConnectionIdData&& other); |
| |
| ~ConnectionIdData(); |
| |
| int num_packets; |
| QuicTime time_added; |
| TimeWaitAction action; |
| TimeWaitConnectionInfo info; |
| }; |
| |
| // QuicheLinkedHashMap allows lookup by ConnectionId |
| // and traversal in add order. |
| using ConnectionIdMap = quiche::QuicheLinkedHashMap<QuicConnectionId, |
| ConnectionIdData, |
| QuicConnectionIdHash>; |
| // Do not use find/emplace/erase on this map directly. Use |
| // FindConnectionIdDataInMap, AddConnectionIdDateToMap, |
| // RemoveConnectionDataFromMap instead. |
| ConnectionIdMap connection_id_map_; |
| |
| // TODO(haoyuewang) Consider making connection_id_map_ a map of shared pointer |
| // and remove the indirect map. |
| // A connection can have multiple unretired ConnectionIds when it is closed. |
| // These Ids have the same ConnectionIdData entry in connection_id_map_. To |
| // find the entry, look up the cannoical ConnectionId in |
| // indirect_connection_id_map_ first, and look up connection_id_map_ with the |
| // cannoical ConnectionId. |
| absl::flat_hash_map<QuicConnectionId, QuicConnectionId, QuicConnectionIdHash> |
| indirect_connection_id_map_; |
| |
| // Find an iterator for the given connection_id. Returns |
| // connection_id_map_.end() if none found. |
| ConnectionIdMap::iterator FindConnectionIdDataInMap( |
| const QuicConnectionId& connection_id); |
| // Inserts a ConnectionIdData entry to connection_id_map_. |
| void AddConnectionIdDataToMap(const QuicConnectionId& canonical_connection_id, |
| int num_packets, |
| TimeWaitAction action, |
| TimeWaitConnectionInfo info); |
| // Removes a ConnectionIdData entry in connection_id_map_. |
| void RemoveConnectionDataFromMap(ConnectionIdMap::iterator it); |
| |
| // Pending termination packets that need to be sent out to the peer when we |
| // are given a chance to write by the dispatcher. |
| quiche::QuicheCircularDeque<std::unique_ptr<QueuedPacket>> |
| pending_packets_queue_; |
| |
| // Time period for which connection_ids should remain in time wait state. |
| const QuicTime::Delta time_wait_period_; |
| |
| // Alarm to clean up connection_ids that have out lived their duration in |
| // time wait state. |
| std::unique_ptr<QuicAlarm> connection_id_clean_up_alarm_; |
| |
| // Clock to efficiently measure approximate time. |
| const QuicClock* clock_; |
| |
| // Interface that writes given buffer to the socket. |
| QuicPacketWriter* writer_; |
| |
| // Interface that manages blocked writers. |
| Visitor* visitor_; |
| }; |
| |
| } // namespace quic |
| |
| #endif // QUICHE_QUIC_CORE_QUIC_TIME_WAIT_LIST_MANAGER_H_ |