Updating trunk VERSION from 2139.0 to 2140.0
[chromium-blink-merge.git] / net / tools / quic / quic_time_wait_list_manager.h
blob426f09f0872cb828631be1e30411e34fb3111188
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 //
5 // Handles packets for connection_ids in time wait state by discarding the
6 // packet and sending the clients a public reset packet with exponential
7 // backoff.
9 #ifndef NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
10 #define NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
12 #include <deque>
14 #include "base/basictypes.h"
15 #include "base/containers/hash_tables.h"
16 #include "base/strings/string_piece.h"
17 #include "net/base/linked_hash_map.h"
18 #include "net/quic/quic_blocked_writer_interface.h"
19 #include "net/quic/quic_framer.h"
20 #include "net/quic/quic_packet_writer.h"
21 #include "net/quic/quic_protocol.h"
22 #include "net/tools/quic/quic_epoll_clock.h"
24 namespace net {
26 class EpollServer;
28 namespace tools {
30 class ConnectionIdCleanUpAlarm;
31 class QuicServerSessionVisitor;
33 namespace test {
34 class QuicTimeWaitListManagerPeer;
35 } // namespace test
37 // Maintains a list of all connection_ids that have been recently closed. A
38 // connection_id lives in this state for kTimeWaitPeriod. All packets received
39 // for connection_ids in this state are handed over to the
40 // QuicTimeWaitListManager by the QuicDispatcher. Decides whether to send a
41 // public reset packet, a copy of the previously sent connection close packet,
42 // or nothing to the client which sent a packet with the connection_id in time
43 // wait state. After the connection_id expires its time wait period, a new
44 // connection/session will be created if a packet is received for this
45 // connection_id.
46 class QuicTimeWaitListManager : public QuicBlockedWriterInterface {
47 public:
48 // writer - the entity that writes to the socket. (Owned by the dispatcher)
49 // visitor - the entity that manages blocked writers. (The dispatcher)
50 // epoll_server - used to run clean up alarms. (Owned by the dispatcher)
51 QuicTimeWaitListManager(QuicPacketWriter* writer,
52 QuicServerSessionVisitor* visitor,
53 EpollServer* epoll_server,
54 const QuicVersionVector& supported_versions);
55 virtual ~QuicTimeWaitListManager();
57 // Adds the given connection_id to time wait state for kTimeWaitPeriod.
58 // Henceforth, any packet bearing this connection_id should not be processed
59 // while the connection_id remains in this list. If a non-NULL |close_packet|
60 // is provided, it is sent again when packets are received for added
61 // connection_ids. If NULL, a public reset packet is sent with the specified
62 // |version|. DCHECKs that connection_id is not already on the list.
63 void AddConnectionIdToTimeWait(QuicConnectionId connection_id,
64 QuicVersion version,
65 QuicEncryptedPacket* close_packet); // Owned.
67 // Returns true if the connection_id is in time wait state, false otherwise.
68 // Packets received for this connection_id should not lead to creation of new
69 // QuicSessions.
70 bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) const;
72 // Called when a packet is received for a connection_id that is in time wait
73 // state. Sends a public reset packet to the client which sent this
74 // connection_id. Sending of the public reset packet is throttled by using
75 // exponential back off. DCHECKs for the connection_id to be in time wait
76 // state. virtual to override in tests.
77 virtual void ProcessPacket(const IPEndPoint& server_address,
78 const IPEndPoint& client_address,
79 QuicConnectionId connection_id,
80 QuicPacketSequenceNumber sequence_number,
81 const QuicEncryptedPacket& packet);
83 // Called by the dispatcher when the underlying socket becomes writable again,
84 // since we might need to send pending public reset packets which we didn't
85 // send because the underlying socket was write blocked.
86 virtual void OnCanWrite() OVERRIDE;
88 // Used to delete connection_id entries that have outlived their time wait
89 // period.
90 void CleanUpOldConnectionIds();
92 // Given a ConnectionId that exists in the time wait list, returns the
93 // QuicVersion associated with it.
94 QuicVersion GetQuicVersionFromConnectionId(QuicConnectionId connection_id);
96 protected:
97 virtual QuicEncryptedPacket* BuildPublicReset(
98 const QuicPublicResetPacket& packet);
100 private:
101 friend class test::QuicTimeWaitListManagerPeer;
103 // Internal structure to store pending public reset packets.
104 class QueuedPacket;
106 // Decides if a packet should be sent for this connection_id based on the
107 // number of received packets.
108 bool ShouldSendResponse(int received_packet_count);
110 // Creates a public reset packet and sends it or queues it to be sent later.
111 void SendPublicReset(const IPEndPoint& server_address,
112 const IPEndPoint& client_address,
113 QuicConnectionId connection_id,
114 QuicPacketSequenceNumber rejected_sequence_number);
116 // Either sends the packet and deletes it or makes pending_packets_queue_ the
117 // owner of the packet.
118 void SendOrQueuePacket(QueuedPacket* packet);
120 // Sends the packet out. Returns true if the packet was successfully consumed.
121 // If the writer got blocked and did not buffer the packet, we'll need to keep
122 // the packet and retry sending. In case of all other errors we drop the
123 // packet.
124 bool WriteToWire(QueuedPacket* packet);
126 // Register the alarm with the epoll server to wake up at appropriate time.
127 void SetConnectionIdCleanUpAlarm();
129 // A map from a recently closed connection_id to the number of packets
130 // received after the termination of the connection bound to the
131 // connection_id.
132 struct ConnectionIdData {
133 ConnectionIdData(int num_packets_,
134 QuicVersion version_,
135 QuicTime time_added_,
136 QuicEncryptedPacket* close_packet)
137 : num_packets(num_packets_),
138 version(version_),
139 time_added(time_added_),
140 close_packet(close_packet) {}
141 int num_packets;
142 QuicVersion version;
143 QuicTime time_added;
144 QuicEncryptedPacket* close_packet;
147 // linked_hash_map allows lookup by ConnectionId and traversal in add order.
148 typedef linked_hash_map<QuicConnectionId, ConnectionIdData> ConnectionIdMap;
149 ConnectionIdMap connection_id_map_;
151 // Pending public reset packets that need to be sent out to the client
152 // when we are given a chance to write by the dispatcher.
153 std::deque<QueuedPacket*> pending_packets_queue_;
155 // Used to schedule alarms to delete old connection_ids which have been in the
156 // list for too long.
157 EpollServer* epoll_server_;
159 // Time period for which connection_ids should remain in time wait state.
160 const QuicTime::Delta kTimeWaitPeriod_;
162 // Alarm registered with the epoll server to clean up connection_ids that have
163 // out lived their duration in time wait state.
164 scoped_ptr<ConnectionIdCleanUpAlarm> connection_id_clean_up_alarm_;
166 // Clock to efficiently measure approximate time from the epoll server.
167 QuicEpollClock clock_;
169 // Interface that writes given buffer to the socket.
170 QuicPacketWriter* writer_;
172 // Interface that manages blocked writers.
173 QuicServerSessionVisitor* visitor_;
175 DISALLOW_COPY_AND_ASSIGN(QuicTimeWaitListManager);
178 } // namespace tools
179 } // namespace net
181 #endif // NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_