1 // Copyright 2019 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 #include "net/third_party/quiche/src/quic/core/uber_received_packet_manager.h"
6
7 #include "net/third_party/quiche/src/quic/core/quic_types.h"
8 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
9 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
10
11 namespace quic {
12
UberReceivedPacketManager(QuicConnectionStats * stats)13 UberReceivedPacketManager::UberReceivedPacketManager(QuicConnectionStats* stats)
14 : supports_multiple_packet_number_spaces_(false) {
15 for (auto& received_packet_manager : received_packet_managers_) {
16 received_packet_manager.set_connection_stats(stats);
17 }
18 }
19
~UberReceivedPacketManager()20 UberReceivedPacketManager::~UberReceivedPacketManager() {}
21
SetFromConfig(const QuicConfig & config,Perspective perspective)22 void UberReceivedPacketManager::SetFromConfig(const QuicConfig& config,
23 Perspective perspective) {
24 for (auto& received_packet_manager : received_packet_managers_) {
25 received_packet_manager.SetFromConfig(config, perspective);
26 }
27 }
28
IsAwaitingPacket(EncryptionLevel decrypted_packet_level,QuicPacketNumber packet_number) const29 bool UberReceivedPacketManager::IsAwaitingPacket(
30 EncryptionLevel decrypted_packet_level,
31 QuicPacketNumber packet_number) const {
32 if (!supports_multiple_packet_number_spaces_) {
33 return received_packet_managers_[0].IsAwaitingPacket(packet_number);
34 }
35 return received_packet_managers_[QuicUtils::GetPacketNumberSpace(
36 decrypted_packet_level)]
37 .IsAwaitingPacket(packet_number);
38 }
39
GetUpdatedAckFrame(PacketNumberSpace packet_number_space,QuicTime approximate_now)40 const QuicFrame UberReceivedPacketManager::GetUpdatedAckFrame(
41 PacketNumberSpace packet_number_space,
42 QuicTime approximate_now) {
43 if (!supports_multiple_packet_number_spaces_) {
44 return received_packet_managers_[0].GetUpdatedAckFrame(approximate_now);
45 }
46 return received_packet_managers_[packet_number_space].GetUpdatedAckFrame(
47 approximate_now);
48 }
49
RecordPacketReceived(EncryptionLevel decrypted_packet_level,const QuicPacketHeader & header,QuicTime receipt_time)50 void UberReceivedPacketManager::RecordPacketReceived(
51 EncryptionLevel decrypted_packet_level,
52 const QuicPacketHeader& header,
53 QuicTime receipt_time) {
54 if (!supports_multiple_packet_number_spaces_) {
55 received_packet_managers_[0].RecordPacketReceived(header, receipt_time);
56 return;
57 }
58 received_packet_managers_[QuicUtils::GetPacketNumberSpace(
59 decrypted_packet_level)]
60 .RecordPacketReceived(header, receipt_time);
61 }
62
DontWaitForPacketsBefore(EncryptionLevel decrypted_packet_level,QuicPacketNumber least_unacked)63 void UberReceivedPacketManager::DontWaitForPacketsBefore(
64 EncryptionLevel decrypted_packet_level,
65 QuicPacketNumber least_unacked) {
66 if (!supports_multiple_packet_number_spaces_) {
67 received_packet_managers_[0].DontWaitForPacketsBefore(least_unacked);
68 return;
69 }
70 received_packet_managers_[QuicUtils::GetPacketNumberSpace(
71 decrypted_packet_level)]
72 .DontWaitForPacketsBefore(least_unacked);
73 }
74
MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,EncryptionLevel decrypted_packet_level,QuicPacketNumber last_received_packet_number,QuicTime now,const RttStats * rtt_stats)75 void UberReceivedPacketManager::MaybeUpdateAckTimeout(
76 bool should_last_packet_instigate_acks,
77 EncryptionLevel decrypted_packet_level,
78 QuicPacketNumber last_received_packet_number,
79 QuicTime now,
80 const RttStats* rtt_stats) {
81 if (!supports_multiple_packet_number_spaces_) {
82 received_packet_managers_[0].MaybeUpdateAckTimeout(
83 should_last_packet_instigate_acks, last_received_packet_number, now,
84 rtt_stats);
85 return;
86 }
87 received_packet_managers_[QuicUtils::GetPacketNumberSpace(
88 decrypted_packet_level)]
89 .MaybeUpdateAckTimeout(should_last_packet_instigate_acks,
90 last_received_packet_number, now, rtt_stats);
91 }
92
ResetAckStates(EncryptionLevel encryption_level)93 void UberReceivedPacketManager::ResetAckStates(
94 EncryptionLevel encryption_level) {
95 if (!supports_multiple_packet_number_spaces_) {
96 received_packet_managers_[0].ResetAckStates();
97 return;
98 }
99 received_packet_managers_[QuicUtils::GetPacketNumberSpace(encryption_level)]
100 .ResetAckStates();
101 if (encryption_level == ENCRYPTION_INITIAL) {
102 // After one Initial ACK is sent, the others should be sent 'immediately'.
103 received_packet_managers_[INITIAL_DATA].set_local_max_ack_delay(
104 kAlarmGranularity);
105 }
106 }
107
EnableMultiplePacketNumberSpacesSupport(Perspective perspective)108 void UberReceivedPacketManager::EnableMultiplePacketNumberSpacesSupport(
109 Perspective perspective) {
110 if (supports_multiple_packet_number_spaces_) {
111 QUIC_BUG << "Multiple packet number spaces has already been enabled";
112 return;
113 }
114 if (received_packet_managers_[0].GetLargestObserved().IsInitialized()) {
115 QUIC_BUG << "Try to enable multiple packet number spaces support after any "
116 "packet has been received.";
117 return;
118 }
119 // In IETF QUIC, the peer is expected to acknowledge packets in Initial and
120 // Handshake packets with minimal delay.
121 if (!GetQuicReloadableFlag(quic_delay_initial_ack) ||
122 perspective == Perspective::IS_CLIENT) {
123 // Delay the first server ACK, because server ACKs are padded to
124 // full size and count towards the amplification limit.
125 received_packet_managers_[INITIAL_DATA].set_local_max_ack_delay(
126 kAlarmGranularity);
127 } else {
128 QUIC_RELOADABLE_FLAG_COUNT(quic_delay_initial_ack);
129 }
130 received_packet_managers_[HANDSHAKE_DATA].set_local_max_ack_delay(
131 kAlarmGranularity);
132
133 supports_multiple_packet_number_spaces_ = true;
134 }
135
IsAckFrameUpdated() const136 bool UberReceivedPacketManager::IsAckFrameUpdated() const {
137 if (!supports_multiple_packet_number_spaces_) {
138 return received_packet_managers_[0].ack_frame_updated();
139 }
140 for (const auto& received_packet_manager : received_packet_managers_) {
141 if (received_packet_manager.ack_frame_updated()) {
142 return true;
143 }
144 }
145 return false;
146 }
147
GetLargestObserved(EncryptionLevel decrypted_packet_level) const148 QuicPacketNumber UberReceivedPacketManager::GetLargestObserved(
149 EncryptionLevel decrypted_packet_level) const {
150 if (!supports_multiple_packet_number_spaces_) {
151 return received_packet_managers_[0].GetLargestObserved();
152 }
153 return received_packet_managers_[QuicUtils::GetPacketNumberSpace(
154 decrypted_packet_level)]
155 .GetLargestObserved();
156 }
157
GetAckTimeout(PacketNumberSpace packet_number_space) const158 QuicTime UberReceivedPacketManager::GetAckTimeout(
159 PacketNumberSpace packet_number_space) const {
160 if (!supports_multiple_packet_number_spaces_) {
161 return received_packet_managers_[0].ack_timeout();
162 }
163 return received_packet_managers_[packet_number_space].ack_timeout();
164 }
165
GetEarliestAckTimeout() const166 QuicTime UberReceivedPacketManager::GetEarliestAckTimeout() const {
167 QuicTime ack_timeout = QuicTime::Zero();
168 // Returns the earliest non-zero ack timeout.
169 for (const auto& received_packet_manager : received_packet_managers_) {
170 const QuicTime timeout = received_packet_manager.ack_timeout();
171 if (!ack_timeout.IsInitialized()) {
172 ack_timeout = timeout;
173 continue;
174 }
175 if (timeout.IsInitialized()) {
176 ack_timeout = std::min(ack_timeout, timeout);
177 }
178 }
179 return ack_timeout;
180 }
181
IsAckFrameEmpty(PacketNumberSpace packet_number_space) const182 bool UberReceivedPacketManager::IsAckFrameEmpty(
183 PacketNumberSpace packet_number_space) const {
184 if (!supports_multiple_packet_number_spaces_) {
185 return received_packet_managers_[0].IsAckFrameEmpty();
186 }
187 return received_packet_managers_[packet_number_space].IsAckFrameEmpty();
188 }
189
peer_least_packet_awaiting_ack() const190 QuicPacketNumber UberReceivedPacketManager::peer_least_packet_awaiting_ack()
191 const {
192 DCHECK(!supports_multiple_packet_number_spaces_);
193 return received_packet_managers_[0].peer_least_packet_awaiting_ack();
194 }
195
min_received_before_ack_decimation() const196 size_t UberReceivedPacketManager::min_received_before_ack_decimation() const {
197 return received_packet_managers_[0].min_received_before_ack_decimation();
198 }
199
set_min_received_before_ack_decimation(size_t new_value)200 void UberReceivedPacketManager::set_min_received_before_ack_decimation(
201 size_t new_value) {
202 for (auto& received_packet_manager : received_packet_managers_) {
203 received_packet_manager.set_min_received_before_ack_decimation(new_value);
204 }
205 }
206
set_ack_frequency(size_t new_value)207 void UberReceivedPacketManager::set_ack_frequency(size_t new_value) {
208 for (auto& received_packet_manager : received_packet_managers_) {
209 received_packet_manager.set_ack_frequency(new_value);
210 }
211 }
212
ack_frame() const213 const QuicAckFrame& UberReceivedPacketManager::ack_frame() const {
214 DCHECK(!supports_multiple_packet_number_spaces_);
215 return received_packet_managers_[0].ack_frame();
216 }
217
GetAckFrame(PacketNumberSpace packet_number_space) const218 const QuicAckFrame& UberReceivedPacketManager::GetAckFrame(
219 PacketNumberSpace packet_number_space) const {
220 DCHECK(supports_multiple_packet_number_spaces_);
221 return received_packet_managers_[packet_number_space].ack_frame();
222 }
223
set_max_ack_ranges(size_t max_ack_ranges)224 void UberReceivedPacketManager::set_max_ack_ranges(size_t max_ack_ranges) {
225 for (auto& received_packet_manager : received_packet_managers_) {
226 received_packet_manager.set_max_ack_ranges(max_ack_ranges);
227 }
228 }
229
set_save_timestamps(bool save_timestamps)230 void UberReceivedPacketManager::set_save_timestamps(bool save_timestamps) {
231 for (auto& received_packet_manager : received_packet_managers_) {
232 received_packet_manager.set_save_timestamps(save_timestamps);
233 }
234 }
235
OnAckFrequencyFrame(const QuicAckFrequencyFrame & frame)236 void UberReceivedPacketManager::OnAckFrequencyFrame(
237 const QuicAckFrequencyFrame& frame) {
238 if (!supports_multiple_packet_number_spaces_) {
239 QUIC_BUG << "Received AckFrequencyFrame when multiple packet number spaces "
240 "is not supported";
241 return;
242 }
243 received_packet_managers_[APPLICATION_DATA].OnAckFrequencyFrame(frame);
244 }
245
246 } // namespace quic
247