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 #include "net/third_party/quiche/src/quic/core/quic_packet_creator.h"
6
7 #include <algorithm>
8 #include <cstddef>
9 #include <cstdint>
10 #include <limits>
11 #include <string>
12 #include <utility>
13
14 #include "absl/base/macros.h"
15 #include "absl/base/optimization.h"
16 #include "absl/strings/string_view.h"
17 #include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
18 #include "net/third_party/quiche/src/quic/core/frames/quic_frame.h"
19 #include "net/third_party/quiche/src/quic/core/frames/quic_path_challenge_frame.h"
20 #include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
21 #include "net/third_party/quiche/src/quic/core/quic_connection_id.h"
22 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
23 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
24 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
25 #include "net/third_party/quiche/src/quic/core/quic_types.h"
26 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
27 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
28 #include "net/third_party/quiche/src/quic/platform/api/quic_bug_tracker.h"
29 #include "net/third_party/quiche/src/quic/platform/api/quic_exported_stats.h"
30 #include "net/third_party/quiche/src/quic/platform/api/quic_flag_utils.h"
31 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
32 #include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
33 #include "net/third_party/quiche/src/quic/platform/api/quic_server_stats.h"
34 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
35 #include "net/third_party/quiche/src/common/platform/api/quiche_text_utils.h"
36
37 namespace quic {
38 namespace {
39
EncryptionlevelToLongHeaderType(EncryptionLevel level)40 QuicLongHeaderType EncryptionlevelToLongHeaderType(EncryptionLevel level) {
41 switch (level) {
42 case ENCRYPTION_INITIAL:
43 return INITIAL;
44 case ENCRYPTION_HANDSHAKE:
45 return HANDSHAKE;
46 case ENCRYPTION_ZERO_RTT:
47 return ZERO_RTT_PROTECTED;
48 case ENCRYPTION_FORWARD_SECURE:
49 QUIC_BUG
50 << "Try to derive long header type for packet with encryption level: "
51 << level;
52 return INVALID_PACKET_TYPE;
53 default:
54 QUIC_BUG << level;
55 return INVALID_PACKET_TYPE;
56 }
57 }
58
LogCoalesceStreamFrameStatus(bool success)59 void LogCoalesceStreamFrameStatus(bool success) {
60 QUIC_HISTOGRAM_BOOL("QuicSession.CoalesceStreamFrameStatus", success,
61 "Success rate of coalesing stream frames attempt.");
62 }
63
64 // ScopedPacketContextSwitcher saves |packet|'s states and change states
65 // during its construction. When the switcher goes out of scope, it restores
66 // saved states.
67 class ScopedPacketContextSwitcher {
68 public:
ScopedPacketContextSwitcher(QuicPacketNumber packet_number,QuicPacketNumberLength packet_number_length,EncryptionLevel encryption_level,SerializedPacket * packet)69 ScopedPacketContextSwitcher(QuicPacketNumber packet_number,
70 QuicPacketNumberLength packet_number_length,
71 EncryptionLevel encryption_level,
72 SerializedPacket* packet)
73
74 : saved_packet_number_(packet->packet_number),
75 saved_packet_number_length_(packet->packet_number_length),
76 saved_encryption_level_(packet->encryption_level),
77 packet_(packet) {
78 packet_->packet_number = packet_number,
79 packet_->packet_number_length = packet_number_length;
80 packet_->encryption_level = encryption_level;
81 }
82
~ScopedPacketContextSwitcher()83 ~ScopedPacketContextSwitcher() {
84 packet_->packet_number = saved_packet_number_;
85 packet_->packet_number_length = saved_packet_number_length_;
86 packet_->encryption_level = saved_encryption_level_;
87 }
88
89 private:
90 const QuicPacketNumber saved_packet_number_;
91 const QuicPacketNumberLength saved_packet_number_length_;
92 const EncryptionLevel saved_encryption_level_;
93 SerializedPacket* packet_;
94 };
95
96 } // namespace
97
98 #define ENDPOINT \
99 (framer_->perspective() == Perspective::IS_SERVER ? "Server: " : "Client: ")
100
QuicPacketCreator(QuicConnectionId server_connection_id,QuicFramer * framer,DelegateInterface * delegate)101 QuicPacketCreator::QuicPacketCreator(QuicConnectionId server_connection_id,
102 QuicFramer* framer,
103 DelegateInterface* delegate)
104 : QuicPacketCreator(server_connection_id,
105 framer,
106 QuicRandom::GetInstance(),
107 delegate) {}
108
QuicPacketCreator(QuicConnectionId server_connection_id,QuicFramer * framer,QuicRandom * random,DelegateInterface * delegate)109 QuicPacketCreator::QuicPacketCreator(QuicConnectionId server_connection_id,
110 QuicFramer* framer,
111 QuicRandom* random,
112 DelegateInterface* delegate)
113 : delegate_(delegate),
114 debug_delegate_(nullptr),
115 framer_(framer),
116 random_(random),
117 send_version_in_packet_(framer->perspective() == Perspective::IS_CLIENT),
118 have_diversification_nonce_(false),
119 max_packet_length_(0),
120 server_connection_id_included_(CONNECTION_ID_PRESENT),
121 packet_size_(0),
122 server_connection_id_(server_connection_id),
123 client_connection_id_(EmptyQuicConnectionId()),
124 packet_(QuicPacketNumber(),
125 PACKET_1BYTE_PACKET_NUMBER,
126 nullptr,
127 0,
128 false,
129 false),
130 pending_padding_bytes_(0),
131 needs_full_padding_(false),
132 next_transmission_type_(NOT_RETRANSMISSION),
133 flusher_attached_(false),
134 fully_pad_crypto_handshake_packets_(true),
135 latched_hard_max_packet_length_(0),
136 max_datagram_frame_size_(0) {
137 if (let_connection_handle_pings_) {
138 QUIC_RELOADABLE_FLAG_COUNT(quic_let_connection_handle_pings);
139 }
140 SetMaxPacketLength(kDefaultMaxPacketSize);
141 if (!framer_->version().UsesTls()) {
142 // QUIC+TLS negotiates the maximum datagram frame size via the
143 // IETF QUIC max_datagram_frame_size transport parameter.
144 // QUIC_CRYPTO however does not negotiate this so we set its value here.
145 SetMaxDatagramFrameSize(kMaxAcceptedDatagramFrameSize);
146 }
147 }
148
~QuicPacketCreator()149 QuicPacketCreator::~QuicPacketCreator() {
150 DeleteFrames(&packet_.retransmittable_frames);
151 }
152
SetEncrypter(EncryptionLevel level,std::unique_ptr<QuicEncrypter> encrypter)153 void QuicPacketCreator::SetEncrypter(EncryptionLevel level,
154 std::unique_ptr<QuicEncrypter> encrypter) {
155 framer_->SetEncrypter(level, std::move(encrypter));
156 max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
157 }
158
CanSetMaxPacketLength() const159 bool QuicPacketCreator::CanSetMaxPacketLength() const {
160 // |max_packet_length_| should not be changed mid-packet.
161 return queued_frames_.empty();
162 }
163
SetMaxPacketLength(QuicByteCount length)164 void QuicPacketCreator::SetMaxPacketLength(QuicByteCount length) {
165 DCHECK(CanSetMaxPacketLength());
166
167 // Avoid recomputing |max_plaintext_size_| if the length does not actually
168 // change.
169 if (length == max_packet_length_) {
170 return;
171 }
172 QUIC_DVLOG(1) << "Updating packet creator max packet length from "
173 << max_packet_length_ << " to " << length;
174
175 max_packet_length_ = length;
176 max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
177 QUIC_BUG_IF(max_plaintext_size_ - PacketHeaderSize() <
178 MinPlaintextPacketSize(framer_->version()))
179 << "Attempted to set max packet length too small";
180 }
181
SetMaxDatagramFrameSize(QuicByteCount max_datagram_frame_size)182 void QuicPacketCreator::SetMaxDatagramFrameSize(
183 QuicByteCount max_datagram_frame_size) {
184 constexpr QuicByteCount upper_bound =
185 std::min<QuicByteCount>(std::numeric_limits<QuicPacketLength>::max(),
186 std::numeric_limits<size_t>::max());
187 if (max_datagram_frame_size > upper_bound) {
188 // A value of |max_datagram_frame_size| that is equal or greater than
189 // 2^16-1 is effectively infinite because QUIC packets cannot be that large.
190 // We therefore clamp the value here to allow us to safely cast
191 // |max_datagram_frame_size_| to QuicPacketLength or size_t.
192 max_datagram_frame_size = upper_bound;
193 }
194 max_datagram_frame_size_ = max_datagram_frame_size;
195 }
196
SetSoftMaxPacketLength(QuicByteCount length)197 void QuicPacketCreator::SetSoftMaxPacketLength(QuicByteCount length) {
198 DCHECK(CanSetMaxPacketLength());
199 if (length > max_packet_length_) {
200 QUIC_BUG << ENDPOINT
201 << "Try to increase max_packet_length_ in "
202 "SetSoftMaxPacketLength, use SetMaxPacketLength instead.";
203 return;
204 }
205 if (framer_->GetMaxPlaintextSize(length) <
206 PacketHeaderSize() + MinPlaintextPacketSize(framer_->version())) {
207 // Please note: this would not guarantee to fit next packet if the size of
208 // packet header increases (e.g., encryption level changes).
209 QUIC_DLOG(INFO) << length << " is too small to fit packet header";
210 RemoveSoftMaxPacketLength();
211 return;
212 }
213 QUIC_DVLOG(1) << "Setting soft max packet length to: " << length;
214 latched_hard_max_packet_length_ = max_packet_length_;
215 max_packet_length_ = length;
216 max_plaintext_size_ = framer_->GetMaxPlaintextSize(length);
217 }
218
219 // Stops serializing version of the protocol in packets sent after this call.
220 // A packet that is already open might send kQuicVersionSize bytes less than the
221 // maximum packet size if we stop sending version before it is serialized.
StopSendingVersion()222 void QuicPacketCreator::StopSendingVersion() {
223 DCHECK(send_version_in_packet_);
224 DCHECK(!VersionHasIetfInvariantHeader(framer_->transport_version()));
225 send_version_in_packet_ = false;
226 if (packet_size_ > 0) {
227 DCHECK_LT(kQuicVersionSize, packet_size_);
228 packet_size_ -= kQuicVersionSize;
229 }
230 }
231
SetDiversificationNonce(const DiversificationNonce & nonce)232 void QuicPacketCreator::SetDiversificationNonce(
233 const DiversificationNonce& nonce) {
234 DCHECK(!have_diversification_nonce_);
235 have_diversification_nonce_ = true;
236 diversification_nonce_ = nonce;
237 }
238
UpdatePacketNumberLength(QuicPacketNumber least_packet_awaited_by_peer,QuicPacketCount max_packets_in_flight)239 void QuicPacketCreator::UpdatePacketNumberLength(
240 QuicPacketNumber least_packet_awaited_by_peer,
241 QuicPacketCount max_packets_in_flight) {
242 if (!queued_frames_.empty()) {
243 // Don't change creator state if there are frames queued.
244 QUIC_BUG << "Called UpdatePacketNumberLength with " << queued_frames_.size()
245 << " queued_frames. First frame type:"
246 << queued_frames_.front().type
247 << " last frame type:" << queued_frames_.back().type;
248 return;
249 }
250
251 const QuicPacketNumber next_packet_number = NextSendingPacketNumber();
252 DCHECK_LE(least_packet_awaited_by_peer, next_packet_number);
253 const uint64_t current_delta =
254 next_packet_number - least_packet_awaited_by_peer;
255 const uint64_t delta = std::max(current_delta, max_packets_in_flight);
256 const QuicPacketNumberLength packet_number_length =
257 QuicFramer::GetMinPacketNumberLength(QuicPacketNumber(delta * 4));
258 if (packet_.packet_number_length == packet_number_length) {
259 return;
260 }
261 QUIC_DLOG(INFO) << ENDPOINT << "Updating packet number length from "
262 << static_cast<int>(packet_.packet_number_length) << " to "
263 << static_cast<int>(packet_number_length)
264 << ", least_packet_awaited_by_peer: "
265 << least_packet_awaited_by_peer
266 << " max_packets_in_flight: " << max_packets_in_flight
267 << " next_packet_number: " << next_packet_number;
268 packet_.packet_number_length = packet_number_length;
269 }
270
SkipNPacketNumbers(QuicPacketCount count,QuicPacketNumber least_packet_awaited_by_peer,QuicPacketCount max_packets_in_flight)271 void QuicPacketCreator::SkipNPacketNumbers(
272 QuicPacketCount count,
273 QuicPacketNumber least_packet_awaited_by_peer,
274 QuicPacketCount max_packets_in_flight) {
275 if (!queued_frames_.empty()) {
276 // Don't change creator state if there are frames queued.
277 QUIC_BUG << "Called SkipNPacketNumbers with " << queued_frames_.size()
278 << " queued_frames. First frame type:"
279 << queued_frames_.front().type
280 << " last frame type:" << queued_frames_.back().type;
281 return;
282 }
283 if (packet_.packet_number > packet_.packet_number + count) {
284 // Skipping count packet numbers causes packet number wrapping around,
285 // reject it.
286 QUIC_LOG(WARNING) << "Skipping " << count
287 << " packet numbers causes packet number wrapping "
288 "around, least_packet_awaited_by_peer: "
289 << least_packet_awaited_by_peer
290 << " packet_number:" << packet_.packet_number;
291 return;
292 }
293 packet_.packet_number += count;
294 // Packet number changes, update packet number length if necessary.
295 UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
296 }
297
ConsumeCryptoDataToFillCurrentPacket(EncryptionLevel level,size_t write_length,QuicStreamOffset offset,bool needs_full_padding,TransmissionType transmission_type,QuicFrame * frame)298 bool QuicPacketCreator::ConsumeCryptoDataToFillCurrentPacket(
299 EncryptionLevel level,
300 size_t write_length,
301 QuicStreamOffset offset,
302 bool needs_full_padding,
303 TransmissionType transmission_type,
304 QuicFrame* frame) {
305 QUIC_DVLOG(2) << "ConsumeCryptoDataToFillCurrentPacket " << level
306 << " write_length " << write_length << " offset " << offset
307 << (needs_full_padding ? " needs_full_padding" : "") << " "
308 << transmission_type;
309 if (!CreateCryptoFrame(level, write_length, offset, frame)) {
310 return false;
311 }
312 // When crypto data was sent in stream frames, ConsumeData is called with
313 // |needs_full_padding = true|. Keep the same behavior here when sending
314 // crypto frames.
315 //
316 // TODO(nharper): Check what the IETF drafts say about padding out initial
317 // messages and change this as appropriate.
318 if (needs_full_padding) {
319 needs_full_padding_ = true;
320 }
321 return AddFrame(*frame, transmission_type);
322 }
323
ConsumeDataToFillCurrentPacket(QuicStreamId id,size_t data_size,QuicStreamOffset offset,bool fin,bool needs_full_padding,TransmissionType transmission_type,QuicFrame * frame)324 bool QuicPacketCreator::ConsumeDataToFillCurrentPacket(
325 QuicStreamId id,
326 size_t data_size,
327 QuicStreamOffset offset,
328 bool fin,
329 bool needs_full_padding,
330 TransmissionType transmission_type,
331 QuicFrame* frame) {
332 if (!HasRoomForStreamFrame(id, offset, data_size)) {
333 return false;
334 }
335 CreateStreamFrame(id, data_size, offset, fin, frame);
336 // Explicitly disallow multi-packet CHLOs.
337 if (GetQuicFlag(FLAGS_quic_enforce_single_packet_chlo) &&
338 StreamFrameIsClientHello(frame->stream_frame) &&
339 frame->stream_frame.data_length < data_size) {
340 const std::string error_details =
341 "Client hello won't fit in a single packet.";
342 QUIC_BUG << error_details << " Constructed stream frame length: "
343 << frame->stream_frame.data_length
344 << " CHLO length: " << data_size;
345 delegate_->OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, error_details);
346 return false;
347 }
348 if (!AddFrame(*frame, transmission_type)) {
349 // Fails if we try to write unencrypted stream data.
350 return false;
351 }
352 if (needs_full_padding) {
353 needs_full_padding_ = true;
354 }
355
356 return true;
357 }
358
HasRoomForStreamFrame(QuicStreamId id,QuicStreamOffset offset,size_t data_size)359 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
360 QuicStreamOffset offset,
361 size_t data_size) {
362 const size_t min_stream_frame_size = QuicFramer::GetMinStreamFrameSize(
363 framer_->transport_version(), id, offset, /*last_frame_in_packet=*/true,
364 data_size);
365 if (BytesFree() > min_stream_frame_size) {
366 return true;
367 }
368 if (!RemoveSoftMaxPacketLength()) {
369 return false;
370 }
371 return BytesFree() > min_stream_frame_size;
372 }
373
HasRoomForMessageFrame(QuicByteCount length)374 bool QuicPacketCreator::HasRoomForMessageFrame(QuicByteCount length) {
375 const size_t message_frame_size = QuicFramer::GetMessageFrameSize(
376 framer_->transport_version(), /*last_frame_in_packet=*/true, length);
377 if (static_cast<QuicByteCount>(message_frame_size) >
378 max_datagram_frame_size_) {
379 return false;
380 }
381 if (BytesFree() >= message_frame_size) {
382 return true;
383 }
384 if (!RemoveSoftMaxPacketLength()) {
385 return false;
386 }
387 return BytesFree() >= message_frame_size;
388 }
389
390 // static
StreamFramePacketOverhead(QuicTransportVersion version,QuicConnectionIdLength destination_connection_id_length,QuicConnectionIdLength source_connection_id_length,bool include_version,bool include_diversification_nonce,QuicPacketNumberLength packet_number_length,QuicVariableLengthIntegerLength retry_token_length_length,QuicVariableLengthIntegerLength length_length,QuicStreamOffset offset)391 size_t QuicPacketCreator::StreamFramePacketOverhead(
392 QuicTransportVersion version,
393 QuicConnectionIdLength destination_connection_id_length,
394 QuicConnectionIdLength source_connection_id_length,
395 bool include_version,
396 bool include_diversification_nonce,
397 QuicPacketNumberLength packet_number_length,
398 QuicVariableLengthIntegerLength retry_token_length_length,
399 QuicVariableLengthIntegerLength length_length,
400 QuicStreamOffset offset) {
401 return GetPacketHeaderSize(version, destination_connection_id_length,
402 source_connection_id_length, include_version,
403 include_diversification_nonce,
404 packet_number_length, retry_token_length_length, 0,
405 length_length) +
406
407 // Assumes a packet with a single stream frame, which omits the length,
408 // causing the data length argument to be ignored.
409 QuicFramer::GetMinStreamFrameSize(version, 1u, offset, true,
410 kMaxOutgoingPacketSize /* unused */);
411 }
412
CreateStreamFrame(QuicStreamId id,size_t data_size,QuicStreamOffset offset,bool fin,QuicFrame * frame)413 void QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
414 size_t data_size,
415 QuicStreamOffset offset,
416 bool fin,
417 QuicFrame* frame) {
418 // Make sure max_packet_length_ is greater than the largest possible overhead
419 // or max_packet_length_ is set to the soft limit.
420 DCHECK(max_packet_length_ >
421 StreamFramePacketOverhead(
422 framer_->transport_version(),
423 GetDestinationConnectionIdLength(),
424 GetSourceConnectionIdLength(), kIncludeVersion,
425 IncludeNonceInPublicHeader(), PACKET_6BYTE_PACKET_NUMBER,
426 GetRetryTokenLengthLength(), GetLengthLength(), offset) ||
427 latched_hard_max_packet_length_ > 0);
428
429 QUIC_BUG_IF(!HasRoomForStreamFrame(id, offset, data_size))
430 << "No room for Stream frame, BytesFree: " << BytesFree()
431 << " MinStreamFrameSize: "
432 << QuicFramer::GetMinStreamFrameSize(framer_->transport_version(), id,
433 offset, true, data_size);
434
435 QUIC_BUG_IF(data_size == 0 && !fin)
436 << "Creating a stream frame for stream ID:" << id
437 << " with no data or fin.";
438 size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
439 framer_->transport_version(), id, offset,
440 /* last_frame_in_packet= */ true, data_size);
441 size_t bytes_consumed =
442 std::min<size_t>(BytesFree() - min_frame_size, data_size);
443
444 bool set_fin = fin && bytes_consumed == data_size; // Last frame.
445 *frame = QuicFrame(QuicStreamFrame(id, set_fin, offset, bytes_consumed));
446 }
447
CreateCryptoFrame(EncryptionLevel level,size_t write_length,QuicStreamOffset offset,QuicFrame * frame)448 bool QuicPacketCreator::CreateCryptoFrame(EncryptionLevel level,
449 size_t write_length,
450 QuicStreamOffset offset,
451 QuicFrame* frame) {
452 const size_t min_frame_size =
453 QuicFramer::GetMinCryptoFrameSize(write_length, offset);
454 if (BytesFree() <= min_frame_size &&
455 (!RemoveSoftMaxPacketLength() || BytesFree() <= min_frame_size)) {
456 return false;
457 }
458 size_t max_write_length = BytesFree() - min_frame_size;
459 size_t bytes_consumed = std::min<size_t>(max_write_length, write_length);
460 *frame = QuicFrame(new QuicCryptoFrame(level, offset, bytes_consumed));
461 return true;
462 }
463
FlushCurrentPacket()464 void QuicPacketCreator::FlushCurrentPacket() {
465 if (!HasPendingFrames() && pending_padding_bytes_ == 0) {
466 return;
467 }
468
469 ABSL_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
470 QuicOwnedPacketBuffer external_buffer(delegate_->GetPacketBuffer());
471
472 if (external_buffer.buffer == nullptr) {
473 external_buffer.buffer = stack_buffer;
474 external_buffer.release_buffer = nullptr;
475 }
476
477 DCHECK_EQ(nullptr, packet_.encrypted_buffer);
478 if (!SerializePacket(std::move(external_buffer), kMaxOutgoingPacketSize)) {
479 return;
480 }
481 OnSerializedPacket();
482 }
483
OnSerializedPacket()484 void QuicPacketCreator::OnSerializedPacket() {
485 QUIC_BUG_IF(packet_.encrypted_buffer == nullptr);
486
487 SerializedPacket packet(std::move(packet_));
488 ClearPacket();
489 RemoveSoftMaxPacketLength();
490 delegate_->OnSerializedPacket(std::move(packet));
491 }
492
ClearPacket()493 void QuicPacketCreator::ClearPacket() {
494 packet_.has_ack = false;
495 packet_.has_stop_waiting = false;
496 packet_.has_crypto_handshake = NOT_HANDSHAKE;
497 packet_.transmission_type = NOT_RETRANSMISSION;
498 packet_.encrypted_buffer = nullptr;
499 packet_.encrypted_length = 0;
500 packet_.has_ack_frequency = false;
501 packet_.has_message = false;
502 packet_.fate = SEND_TO_WRITER;
503 QUIC_BUG_IF(packet_.release_encrypted_buffer != nullptr)
504 << "packet_.release_encrypted_buffer should be empty";
505 packet_.release_encrypted_buffer = nullptr;
506 DCHECK(packet_.retransmittable_frames.empty());
507 DCHECK(packet_.nonretransmittable_frames.empty());
508 packet_.largest_acked.Clear();
509 needs_full_padding_ = false;
510 }
511
ReserializeInitialPacketInCoalescedPacket(const SerializedPacket & packet,size_t padding_size,char * buffer,size_t buffer_len)512 size_t QuicPacketCreator::ReserializeInitialPacketInCoalescedPacket(
513 const SerializedPacket& packet,
514 size_t padding_size,
515 char* buffer,
516 size_t buffer_len) {
517 QUIC_BUG_IF(packet.encryption_level != ENCRYPTION_INITIAL);
518 QUIC_BUG_IF(packet.nonretransmittable_frames.empty() &&
519 packet.retransmittable_frames.empty())
520 << "Attempt to serialize empty ENCRYPTION_INITIAL packet in coalesced "
521 "packet";
522 ScopedPacketContextSwitcher switcher(
523 packet.packet_number -
524 1, // -1 because serialize packet increase packet number.
525 packet.packet_number_length, packet.encryption_level, &packet_);
526 for (const QuicFrame& frame : packet.nonretransmittable_frames) {
527 if (!AddFrame(frame, packet.transmission_type)) {
528 QUIC_BUG << "Failed to serialize frame: " << frame;
529 return 0;
530 }
531 }
532 for (const QuicFrame& frame : packet.retransmittable_frames) {
533 if (!AddFrame(frame, packet.transmission_type)) {
534 QUIC_BUG << "Failed to serialize frame: " << frame;
535 return 0;
536 }
537 }
538 // Add necessary padding.
539 if (padding_size > 0) {
540 QUIC_DVLOG(2) << ENDPOINT << "Add padding of size: " << padding_size;
541 if (!AddFrame(QuicFrame(QuicPaddingFrame(padding_size)),
542 packet.transmission_type)) {
543 QUIC_BUG << "Failed to add padding of size " << padding_size
544 << " when serializing ENCRYPTION_INITIAL "
545 "packet in coalesced packet";
546 return 0;
547 }
548 }
549 if (!SerializePacket(QuicOwnedPacketBuffer(buffer, nullptr), buffer_len)) {
550 return 0;
551 }
552 const size_t encrypted_length = packet_.encrypted_length;
553 // Clear frames in packet_. No need to DeleteFrames since frames are owned by
554 // initial_packet.
555 packet_.retransmittable_frames.clear();
556 packet_.nonretransmittable_frames.clear();
557 ClearPacket();
558 return encrypted_length;
559 }
560
CreateAndSerializeStreamFrame(QuicStreamId id,size_t write_length,QuicStreamOffset iov_offset,QuicStreamOffset stream_offset,bool fin,TransmissionType transmission_type,size_t * num_bytes_consumed)561 void QuicPacketCreator::CreateAndSerializeStreamFrame(
562 QuicStreamId id,
563 size_t write_length,
564 QuicStreamOffset iov_offset,
565 QuicStreamOffset stream_offset,
566 bool fin,
567 TransmissionType transmission_type,
568 size_t* num_bytes_consumed) {
569 // TODO(b/167222597): consider using ScopedSerializationFailureHandler.
570 DCHECK(queued_frames_.empty());
571 DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
572 // Write out the packet header
573 QuicPacketHeader header;
574 FillPacketHeader(&header);
575 packet_.fate = delegate_->GetSerializedPacketFate(
576 /*is_mtu_discovery=*/false, packet_.encryption_level);
577 QUIC_DVLOG(1) << ENDPOINT << "fate of packet " << packet_.packet_number
578 << ": " << SerializedPacketFateToString(packet_.fate) << " of "
579 << EncryptionLevelToString(packet_.encryption_level);
580
581 ABSL_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
582 QuicOwnedPacketBuffer packet_buffer(delegate_->GetPacketBuffer());
583
584 if (packet_buffer.buffer == nullptr) {
585 packet_buffer.buffer = stack_buffer;
586 packet_buffer.release_buffer = nullptr;
587 }
588
589 char* encrypted_buffer = packet_buffer.buffer;
590
591 QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
592 size_t length_field_offset = 0;
593 if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
594 QUIC_BUG << "AppendPacketHeader failed";
595 return;
596 }
597
598 // Create a Stream frame with the remaining space.
599 QUIC_BUG_IF(iov_offset == write_length && !fin)
600 << "Creating a stream frame with no data or fin.";
601 const size_t remaining_data_size = write_length - iov_offset;
602 size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
603 framer_->transport_version(), id, stream_offset,
604 /* last_frame_in_packet= */ true, remaining_data_size);
605 size_t available_size =
606 max_plaintext_size_ - writer.length() - min_frame_size;
607 size_t bytes_consumed = std::min<size_t>(available_size, remaining_data_size);
608 size_t plaintext_bytes_written = min_frame_size + bytes_consumed;
609 bool needs_padding = false;
610 if (plaintext_bytes_written < MinPlaintextPacketSize(framer_->version())) {
611 needs_padding = true;
612 // Recalculate sizes with the stream frame not being marked as the last
613 // frame in the packet.
614 min_frame_size = QuicFramer::GetMinStreamFrameSize(
615 framer_->transport_version(), id, stream_offset,
616 /* last_frame_in_packet= */ false, remaining_data_size);
617 available_size = max_plaintext_size_ - writer.length() - min_frame_size;
618 bytes_consumed = std::min<size_t>(available_size, remaining_data_size);
619 plaintext_bytes_written = min_frame_size + bytes_consumed;
620 }
621
622 const bool set_fin = fin && (bytes_consumed == remaining_data_size);
623 QuicStreamFrame frame(id, set_fin, stream_offset, bytes_consumed);
624 if (debug_delegate_ != nullptr) {
625 debug_delegate_->OnFrameAddedToPacket(QuicFrame(frame));
626 }
627 QUIC_DVLOG(1) << ENDPOINT << "Adding frame: " << frame;
628
629 QUIC_DVLOG(2) << ENDPOINT << "Serializing stream packet " << header << frame;
630
631 // TODO(ianswett): AppendTypeByte and AppendStreamFrame could be optimized
632 // into one method that takes a QuicStreamFrame, if warranted.
633 bool omit_frame_length = !needs_padding;
634 if (!framer_->AppendTypeByte(QuicFrame(frame), omit_frame_length, &writer)) {
635 QUIC_BUG << "AppendTypeByte failed";
636 return;
637 }
638 if (!framer_->AppendStreamFrame(frame, omit_frame_length, &writer)) {
639 QUIC_BUG << "AppendStreamFrame failed";
640 return;
641 }
642 if (needs_padding &&
643 plaintext_bytes_written < MinPlaintextPacketSize(framer_->version()) &&
644 !writer.WritePaddingBytes(MinPlaintextPacketSize(framer_->version()) -
645 plaintext_bytes_written)) {
646 QUIC_BUG << "Unable to add padding bytes";
647 return;
648 }
649
650 if (!framer_->WriteIetfLongHeaderLength(header, &writer, length_field_offset,
651 packet_.encryption_level)) {
652 return;
653 }
654
655 packet_.transmission_type = transmission_type;
656
657 DCHECK(packet_.encryption_level == ENCRYPTION_FORWARD_SECURE ||
658 packet_.encryption_level == ENCRYPTION_ZERO_RTT)
659 << packet_.encryption_level;
660 size_t encrypted_length = framer_->EncryptInPlace(
661 packet_.encryption_level, packet_.packet_number,
662 GetStartOfEncryptedData(framer_->transport_version(), header),
663 writer.length(), kMaxOutgoingPacketSize, encrypted_buffer);
664 if (encrypted_length == 0) {
665 QUIC_BUG << "Failed to encrypt packet number " << header.packet_number;
666 return;
667 }
668 // TODO(ianswett): Optimize the storage so RetransmitableFrames can be
669 // unioned with a QuicStreamFrame and a UniqueStreamBuffer.
670 *num_bytes_consumed = bytes_consumed;
671 packet_size_ = 0;
672 packet_.encrypted_buffer = encrypted_buffer;
673 packet_.encrypted_length = encrypted_length;
674
675 packet_buffer.buffer = nullptr;
676 packet_.release_encrypted_buffer = std::move(packet_buffer).release_buffer;
677
678 packet_.retransmittable_frames.push_back(QuicFrame(frame));
679 OnSerializedPacket();
680 }
681
HasPendingFrames() const682 bool QuicPacketCreator::HasPendingFrames() const {
683 return !queued_frames_.empty();
684 }
685
HasPendingRetransmittableFrames() const686 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
687 return !packet_.retransmittable_frames.empty();
688 }
689
HasPendingStreamFramesOfStream(QuicStreamId id) const690 bool QuicPacketCreator::HasPendingStreamFramesOfStream(QuicStreamId id) const {
691 for (const auto& frame : packet_.retransmittable_frames) {
692 if (frame.type == STREAM_FRAME && frame.stream_frame.stream_id == id) {
693 return true;
694 }
695 }
696 return false;
697 }
698
ExpansionOnNewFrame() const699 size_t QuicPacketCreator::ExpansionOnNewFrame() const {
700 // If the last frame in the packet is a message frame, then it will expand to
701 // include the varint message length when a new frame is added.
702 if (queued_frames_.empty()) {
703 return 0;
704 }
705 return ExpansionOnNewFrameWithLastFrame(queued_frames_.back(),
706 framer_->transport_version());
707 }
708
709 // static
ExpansionOnNewFrameWithLastFrame(const QuicFrame & last_frame,QuicTransportVersion version)710 size_t QuicPacketCreator::ExpansionOnNewFrameWithLastFrame(
711 const QuicFrame& last_frame,
712 QuicTransportVersion version) {
713 if (last_frame.type == MESSAGE_FRAME) {
714 return QuicDataWriter::GetVarInt62Len(
715 last_frame.message_frame->message_length);
716 }
717 if (last_frame.type != STREAM_FRAME) {
718 return 0;
719 }
720 if (VersionHasIetfQuicFrames(version)) {
721 return QuicDataWriter::GetVarInt62Len(last_frame.stream_frame.data_length);
722 }
723 return kQuicStreamPayloadLengthSize;
724 }
725
BytesFree() const726 size_t QuicPacketCreator::BytesFree() const {
727 DCHECK_GE(max_plaintext_size_, PacketSize());
728 return max_plaintext_size_ -
729 std::min(max_plaintext_size_, PacketSize() + ExpansionOnNewFrame());
730 }
731
PacketSize() const732 size_t QuicPacketCreator::PacketSize() const {
733 return queued_frames_.empty() ? PacketHeaderSize() : packet_size_;
734 }
735
AddPaddedSavedFrame(const QuicFrame & frame,TransmissionType transmission_type)736 bool QuicPacketCreator::AddPaddedSavedFrame(
737 const QuicFrame& frame,
738 TransmissionType transmission_type) {
739 if (AddFrame(frame, transmission_type)) {
740 needs_full_padding_ = true;
741 return true;
742 }
743 return false;
744 }
745
SerializePacket(QuicOwnedPacketBuffer encrypted_buffer,size_t encrypted_buffer_len)746 bool QuicPacketCreator::SerializePacket(QuicOwnedPacketBuffer encrypted_buffer,
747 size_t encrypted_buffer_len) {
748 if (packet_.encrypted_buffer != nullptr) {
749 const std::string error_details =
750 "Packet's encrypted buffer is not empty before serialization";
751 QUIC_BUG << error_details;
752 delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
753 error_details);
754 return false;
755 }
756 ScopedSerializationFailureHandler handler(this);
757
758 DCHECK_LT(0u, encrypted_buffer_len);
759 QUIC_BUG_IF(queued_frames_.empty() && pending_padding_bytes_ == 0)
760 << "Attempt to serialize empty packet";
761 QuicPacketHeader header;
762 // FillPacketHeader increments packet_number_.
763 FillPacketHeader(&header);
764 if (delegate_ != nullptr) {
765 packet_.fate = delegate_->GetSerializedPacketFate(
766 /*is_mtu_discovery=*/QuicUtils::ContainsFrameType(queued_frames_,
767 MTU_DISCOVERY_FRAME),
768 packet_.encryption_level);
769 QUIC_DVLOG(1) << ENDPOINT << "fate of packet " << packet_.packet_number
770 << ": " << SerializedPacketFateToString(packet_.fate)
771 << " of "
772 << EncryptionLevelToString(packet_.encryption_level);
773 }
774
775 MaybeAddPadding();
776
777 QUIC_DVLOG(2) << ENDPOINT << "Serializing packet " << header
778 << QuicFramesToString(queued_frames_) << " at encryption_level "
779 << packet_.encryption_level;
780
781 if (!framer_->HasEncrypterOfEncryptionLevel(packet_.encryption_level)) {
782 // TODO(fayang): Use QUIC_MISSING_WRITE_KEYS for serialization failures due
783 // to missing keys.
784 QUIC_BUG << ENDPOINT << "Attempting to serialize " << header
785 << QuicFramesToString(queued_frames_)
786 << " at missing encryption_level " << packet_.encryption_level
787 << " using " << framer_->version();
788 return false;
789 }
790
791 DCHECK_GE(max_plaintext_size_, packet_size_);
792 // Use the packet_size_ instead of the buffer size to ensure smaller
793 // packet sizes are properly used.
794 size_t length =
795 framer_->BuildDataPacket(header, queued_frames_, encrypted_buffer.buffer,
796 packet_size_, packet_.encryption_level);
797 if (length == 0) {
798 QUIC_BUG << "Failed to serialize " << QuicFramesToString(queued_frames_)
799 << " at encryption_level: " << packet_.encryption_level
800 << ", needs_full_padding_: " << needs_full_padding_
801 << ", pending_padding_bytes_: " << pending_padding_bytes_
802 << ", latched_hard_max_packet_length_: "
803 << latched_hard_max_packet_length_
804 << ", max_packet_length_: " << max_packet_length_
805 << ", header: " << header;
806 return false;
807 }
808
809 // ACK Frames will be truncated due to length only if they're the only frame
810 // in the packet, and if packet_size_ was set to max_plaintext_size_. If
811 // truncation due to length occurred, then GetSerializedFrameLength will have
812 // returned all bytes free.
813 bool possibly_truncated_by_length = packet_size_ == max_plaintext_size_ &&
814 queued_frames_.size() == 1 &&
815 queued_frames_.back().type == ACK_FRAME;
816 // Because of possible truncation, we can't be confident that our
817 // packet size calculation worked correctly.
818 if (!possibly_truncated_by_length) {
819 DCHECK_EQ(packet_size_, length);
820 }
821 const size_t encrypted_length = framer_->EncryptInPlace(
822 packet_.encryption_level, packet_.packet_number,
823 GetStartOfEncryptedData(framer_->transport_version(), header), length,
824 encrypted_buffer_len, encrypted_buffer.buffer);
825 if (encrypted_length == 0) {
826 QUIC_BUG << "Failed to encrypt packet number " << packet_.packet_number;
827 return false;
828 }
829
830 packet_size_ = 0;
831 packet_.encrypted_buffer = encrypted_buffer.buffer;
832 packet_.encrypted_length = encrypted_length;
833
834 encrypted_buffer.buffer = nullptr;
835 packet_.release_encrypted_buffer = std::move(encrypted_buffer).release_buffer;
836 return true;
837 }
838
839 std::unique_ptr<SerializedPacket>
SerializeConnectivityProbingPacket()840 QuicPacketCreator::SerializeConnectivityProbingPacket() {
841 QUIC_BUG_IF(VersionHasIetfQuicFrames(framer_->transport_version()))
842 << "Must not be version 99 to serialize padded ping connectivity probe";
843 RemoveSoftMaxPacketLength();
844 QuicPacketHeader header;
845 // FillPacketHeader increments packet_number_.
846 FillPacketHeader(&header);
847
848 QUIC_DVLOG(2) << ENDPOINT << "Serializing connectivity probing packet "
849 << header;
850
851 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
852 size_t length = BuildConnectivityProbingPacket(
853 header, buffer.get(), max_plaintext_size_, packet_.encryption_level);
854 DCHECK(length);
855
856 DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
857 const size_t encrypted_length = framer_->EncryptInPlace(
858 packet_.encryption_level, packet_.packet_number,
859 GetStartOfEncryptedData(framer_->transport_version(), header), length,
860 kMaxOutgoingPacketSize, buffer.get());
861 DCHECK(encrypted_length);
862
863 std::unique_ptr<SerializedPacket> serialize_packet(new SerializedPacket(
864 header.packet_number, header.packet_number_length, buffer.release(),
865 encrypted_length, /*has_ack=*/false, /*has_stop_waiting=*/false));
866
867 serialize_packet->release_encrypted_buffer = [](const char* p) {
868 delete[] p;
869 };
870 serialize_packet->encryption_level = packet_.encryption_level;
871 serialize_packet->transmission_type = NOT_RETRANSMISSION;
872
873 return serialize_packet;
874 }
875
876 std::unique_ptr<SerializedPacket>
SerializePathChallengeConnectivityProbingPacket(QuicPathFrameBuffer * payload)877 QuicPacketCreator::SerializePathChallengeConnectivityProbingPacket(
878 QuicPathFrameBuffer* payload) {
879 QUIC_BUG_IF(!VersionHasIetfQuicFrames(framer_->transport_version()))
880 << "Must be version 99 to serialize path challenge connectivity probe, "
881 "is version "
882 << framer_->transport_version();
883 RemoveSoftMaxPacketLength();
884 QuicPacketHeader header;
885 // FillPacketHeader increments packet_number_.
886 FillPacketHeader(&header);
887
888 QUIC_DVLOG(2) << ENDPOINT << "Serializing path challenge packet " << header;
889
890 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
891 size_t length = BuildPaddedPathChallengePacket(
892 header, buffer.get(), max_plaintext_size_, payload, random_,
893 packet_.encryption_level);
894 DCHECK(length);
895
896 DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
897 const size_t encrypted_length = framer_->EncryptInPlace(
898 packet_.encryption_level, packet_.packet_number,
899 GetStartOfEncryptedData(framer_->transport_version(), header), length,
900 kMaxOutgoingPacketSize, buffer.get());
901 DCHECK(encrypted_length);
902
903 std::unique_ptr<SerializedPacket> serialize_packet(
904 new SerializedPacket(header.packet_number, header.packet_number_length,
905 buffer.release(), encrypted_length,
906 /*has_ack=*/false, /*has_stop_waiting=*/false));
907
908 serialize_packet->release_encrypted_buffer = [](const char* p) {
909 delete[] p;
910 };
911 serialize_packet->encryption_level = packet_.encryption_level;
912 serialize_packet->transmission_type = NOT_RETRANSMISSION;
913
914 return serialize_packet;
915 }
916
917 std::unique_ptr<SerializedPacket>
SerializePathResponseConnectivityProbingPacket(const QuicCircularDeque<QuicPathFrameBuffer> & payloads,const bool is_padded)918 QuicPacketCreator::SerializePathResponseConnectivityProbingPacket(
919 const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
920 const bool is_padded) {
921 QUIC_BUG_IF(!VersionHasIetfQuicFrames(framer_->transport_version()))
922 << "Must be version 99 to serialize path response connectivity probe, is "
923 "version "
924 << framer_->transport_version();
925 RemoveSoftMaxPacketLength();
926 QuicPacketHeader header;
927 // FillPacketHeader increments packet_number_.
928 FillPacketHeader(&header);
929
930 QUIC_DVLOG(2) << ENDPOINT << "Serializing path response packet " << header;
931
932 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
933 size_t length =
934 BuildPathResponsePacket(header, buffer.get(), max_plaintext_size_,
935 payloads, is_padded, packet_.encryption_level);
936 DCHECK(length);
937
938 DCHECK_EQ(packet_.encryption_level, ENCRYPTION_FORWARD_SECURE);
939 const size_t encrypted_length = framer_->EncryptInPlace(
940 packet_.encryption_level, packet_.packet_number,
941 GetStartOfEncryptedData(framer_->transport_version(), header), length,
942 kMaxOutgoingPacketSize, buffer.get());
943 DCHECK(encrypted_length);
944
945 std::unique_ptr<SerializedPacket> serialize_packet(
946 new SerializedPacket(header.packet_number, header.packet_number_length,
947 buffer.release(), encrypted_length,
948 /*has_ack=*/false, /*has_stop_waiting=*/false));
949
950 serialize_packet->release_encrypted_buffer = [](const char* p) {
951 delete[] p;
952 };
953 serialize_packet->encryption_level = packet_.encryption_level;
954 serialize_packet->transmission_type = NOT_RETRANSMISSION;
955
956 return serialize_packet;
957 }
958
BuildPaddedPathChallengePacket(const QuicPacketHeader & header,char * buffer,size_t packet_length,QuicPathFrameBuffer * payload,QuicRandom * randomizer,EncryptionLevel level)959 size_t QuicPacketCreator::BuildPaddedPathChallengePacket(
960 const QuicPacketHeader& header,
961 char* buffer,
962 size_t packet_length,
963 QuicPathFrameBuffer* payload,
964 QuicRandom* randomizer,
965 EncryptionLevel level) {
966 DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
967 QuicFrames frames;
968
969 // Write a PATH_CHALLENGE frame, which has a random 8-byte payload
970 randomizer->RandBytes(payload->data(), payload->size());
971 QuicPathChallengeFrame path_challenge_frame(0, *payload);
972 frames.push_back(QuicFrame(&path_challenge_frame));
973
974 if (debug_delegate_ != nullptr) {
975 debug_delegate_->OnFrameAddedToPacket(QuicFrame(&path_challenge_frame));
976 }
977
978 // Add padding to the rest of the packet in order to assess Path MTU
979 // characteristics.
980 QuicPaddingFrame padding_frame;
981 frames.push_back(QuicFrame(padding_frame));
982
983 return framer_->BuildDataPacket(header, frames, buffer, packet_length, level);
984 }
985
BuildPathResponsePacket(const QuicPacketHeader & header,char * buffer,size_t packet_length,const QuicCircularDeque<QuicPathFrameBuffer> & payloads,const bool is_padded,EncryptionLevel level)986 size_t QuicPacketCreator::BuildPathResponsePacket(
987 const QuicPacketHeader& header,
988 char* buffer,
989 size_t packet_length,
990 const QuicCircularDeque<QuicPathFrameBuffer>& payloads,
991 const bool is_padded,
992 EncryptionLevel level) {
993 if (payloads.empty()) {
994 QUIC_BUG
995 << "Attempt to generate connectivity response with no request payloads";
996 return 0;
997 }
998 DCHECK(VersionHasIetfQuicFrames(framer_->transport_version()));
999
1000 std::vector<std::unique_ptr<QuicPathResponseFrame>> path_response_frames;
1001 for (const QuicPathFrameBuffer& payload : payloads) {
1002 // Note that the control frame ID can be 0 since this is not retransmitted.
1003 path_response_frames.push_back(
1004 std::make_unique<QuicPathResponseFrame>(0, payload));
1005 }
1006
1007 QuicFrames frames;
1008 for (const std::unique_ptr<QuicPathResponseFrame>& path_response_frame :
1009 path_response_frames) {
1010 frames.push_back(QuicFrame(path_response_frame.get()));
1011 if (debug_delegate_ != nullptr) {
1012 debug_delegate_->OnFrameAddedToPacket(
1013 QuicFrame(path_response_frame.get()));
1014 }
1015 }
1016
1017 if (is_padded) {
1018 // Add padding to the rest of the packet in order to assess Path MTU
1019 // characteristics.
1020 QuicPaddingFrame padding_frame;
1021 frames.push_back(QuicFrame(padding_frame));
1022 }
1023
1024 return framer_->BuildDataPacket(header, frames, buffer, packet_length, level);
1025 }
1026
BuildConnectivityProbingPacket(const QuicPacketHeader & header,char * buffer,size_t packet_length,EncryptionLevel level)1027 size_t QuicPacketCreator::BuildConnectivityProbingPacket(
1028 const QuicPacketHeader& header,
1029 char* buffer,
1030 size_t packet_length,
1031 EncryptionLevel level) {
1032 QuicFrames frames;
1033
1034 // Write a PING frame, which has no data payload.
1035 QuicPingFrame ping_frame;
1036 frames.push_back(QuicFrame(ping_frame));
1037
1038 // Add padding to the rest of the packet.
1039 QuicPaddingFrame padding_frame;
1040 frames.push_back(QuicFrame(padding_frame));
1041
1042 return framer_->BuildDataPacket(header, frames, buffer, packet_length, level);
1043 }
1044
SerializeCoalescedPacket(const QuicCoalescedPacket & coalesced,char * buffer,size_t buffer_len)1045 size_t QuicPacketCreator::SerializeCoalescedPacket(
1046 const QuicCoalescedPacket& coalesced,
1047 char* buffer,
1048 size_t buffer_len) {
1049 if (HasPendingFrames()) {
1050 QUIC_BUG << "Try to serialize coalesced packet with pending frames";
1051 return 0;
1052 }
1053 RemoveSoftMaxPacketLength();
1054 QUIC_BUG_IF(coalesced.length() == 0)
1055 << "Attempt to serialize empty coalesced packet";
1056 size_t packet_length = 0;
1057 if (coalesced.initial_packet() != nullptr) {
1058 // Padding coalesced packet containing initial packet to full.
1059 size_t padding_size = coalesced.max_packet_length() - coalesced.length();
1060 if (framer_->perspective() == Perspective::IS_SERVER &&
1061 QuicUtils::ContainsFrameType(
1062 coalesced.initial_packet()->retransmittable_frames,
1063 CONNECTION_CLOSE_FRAME)) {
1064 // Do not pad server initial connection close packet.
1065 padding_size = 0;
1066 }
1067 size_t initial_length = ReserializeInitialPacketInCoalescedPacket(
1068 *coalesced.initial_packet(), padding_size, buffer, buffer_len);
1069 if (initial_length == 0) {
1070 QUIC_BUG << "Failed to reserialize ENCRYPTION_INITIAL packet in "
1071 "coalesced packet";
1072 return 0;
1073 }
1074 buffer += initial_length;
1075 buffer_len -= initial_length;
1076 packet_length += initial_length;
1077 }
1078 size_t length_copied = 0;
1079 if (!coalesced.CopyEncryptedBuffers(buffer, buffer_len, &length_copied)) {
1080 return 0;
1081 }
1082 packet_length += length_copied;
1083 QUIC_DVLOG(1) << ENDPOINT
1084 << "Successfully serialized coalesced packet of length: "
1085 << packet_length;
1086 return packet_length;
1087 }
1088
1089 // TODO(b/74062209): Make this a public method of framer?
NoPacket()1090 SerializedPacket QuicPacketCreator::NoPacket() {
1091 return SerializedPacket(QuicPacketNumber(), PACKET_1BYTE_PACKET_NUMBER,
1092 nullptr, 0, false, false);
1093 }
1094
GetDestinationConnectionId() const1095 QuicConnectionId QuicPacketCreator::GetDestinationConnectionId() const {
1096 if (framer_->perspective() == Perspective::IS_SERVER) {
1097 return client_connection_id_;
1098 }
1099 return server_connection_id_;
1100 }
1101
GetSourceConnectionId() const1102 QuicConnectionId QuicPacketCreator::GetSourceConnectionId() const {
1103 if (framer_->perspective() == Perspective::IS_CLIENT) {
1104 return client_connection_id_;
1105 }
1106 return server_connection_id_;
1107 }
1108
GetDestinationConnectionIdIncluded() const1109 QuicConnectionIdIncluded QuicPacketCreator::GetDestinationConnectionIdIncluded()
1110 const {
1111 // In versions that do not support client connection IDs, the destination
1112 // connection ID is only sent from client to server.
1113 return (framer_->perspective() == Perspective::IS_CLIENT ||
1114 framer_->version().SupportsClientConnectionIds())
1115 ? CONNECTION_ID_PRESENT
1116 : CONNECTION_ID_ABSENT;
1117 }
1118
GetSourceConnectionIdIncluded() const1119 QuicConnectionIdIncluded QuicPacketCreator::GetSourceConnectionIdIncluded()
1120 const {
1121 // Long header packets sent by server include source connection ID.
1122 // Ones sent by the client only include source connection ID if the version
1123 // supports client connection IDs.
1124 if (HasIetfLongHeader() &&
1125 (framer_->perspective() == Perspective::IS_SERVER ||
1126 framer_->version().SupportsClientConnectionIds())) {
1127 return CONNECTION_ID_PRESENT;
1128 }
1129 if (framer_->perspective() == Perspective::IS_SERVER) {
1130 return server_connection_id_included_;
1131 }
1132 return CONNECTION_ID_ABSENT;
1133 }
1134
GetDestinationConnectionIdLength() const1135 QuicConnectionIdLength QuicPacketCreator::GetDestinationConnectionIdLength()
1136 const {
1137 DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
1138 transport_version()));
1139 return GetDestinationConnectionIdIncluded() == CONNECTION_ID_PRESENT
1140 ? static_cast<QuicConnectionIdLength>(
1141 GetDestinationConnectionId().length())
1142 : PACKET_0BYTE_CONNECTION_ID;
1143 }
1144
GetSourceConnectionIdLength() const1145 QuicConnectionIdLength QuicPacketCreator::GetSourceConnectionIdLength() const {
1146 DCHECK(QuicUtils::IsConnectionIdValidForVersion(server_connection_id_,
1147 transport_version()));
1148 return GetSourceConnectionIdIncluded() == CONNECTION_ID_PRESENT
1149 ? static_cast<QuicConnectionIdLength>(
1150 GetSourceConnectionId().length())
1151 : PACKET_0BYTE_CONNECTION_ID;
1152 }
1153
GetPacketNumberLength() const1154 QuicPacketNumberLength QuicPacketCreator::GetPacketNumberLength() const {
1155 if (HasIetfLongHeader() &&
1156 !framer_->version().SendsVariableLengthPacketNumberInLongHeader()) {
1157 return PACKET_4BYTE_PACKET_NUMBER;
1158 }
1159 return packet_.packet_number_length;
1160 }
1161
PacketHeaderSize() const1162 size_t QuicPacketCreator::PacketHeaderSize() const {
1163 return GetPacketHeaderSize(
1164 framer_->transport_version(), GetDestinationConnectionIdLength(),
1165 GetSourceConnectionIdLength(), IncludeVersionInHeader(),
1166 IncludeNonceInPublicHeader(), GetPacketNumberLength(),
1167 GetRetryTokenLengthLength(), GetRetryToken().length(), GetLengthLength());
1168 }
1169
GetRetryTokenLengthLength() const1170 QuicVariableLengthIntegerLength QuicPacketCreator::GetRetryTokenLengthLength()
1171 const {
1172 if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
1173 HasIetfLongHeader() &&
1174 EncryptionlevelToLongHeaderType(packet_.encryption_level) == INITIAL) {
1175 return QuicDataWriter::GetVarInt62Len(GetRetryToken().length());
1176 }
1177 return VARIABLE_LENGTH_INTEGER_LENGTH_0;
1178 }
1179
GetRetryToken() const1180 absl::string_view QuicPacketCreator::GetRetryToken() const {
1181 if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
1182 HasIetfLongHeader() &&
1183 EncryptionlevelToLongHeaderType(packet_.encryption_level) == INITIAL) {
1184 return retry_token_;
1185 }
1186 return absl::string_view();
1187 }
1188
SetRetryToken(absl::string_view retry_token)1189 void QuicPacketCreator::SetRetryToken(absl::string_view retry_token) {
1190 retry_token_ = std::string(retry_token);
1191 }
1192
ConsumeRetransmittableControlFrame(const QuicFrame & frame)1193 bool QuicPacketCreator::ConsumeRetransmittableControlFrame(
1194 const QuicFrame& frame) {
1195 QUIC_BUG_IF(IsControlFrame(frame.type) && !GetControlFrameId(frame) &&
1196 (!let_connection_handle_pings_ || frame.type != PING_FRAME))
1197 << "Adding a control frame with no control frame id: " << frame;
1198 DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
1199 MaybeBundleAckOpportunistically();
1200 if (HasPendingFrames()) {
1201 if (AddFrame(frame, next_transmission_type_)) {
1202 // There is pending frames and current frame fits.
1203 return true;
1204 }
1205 }
1206 DCHECK(!HasPendingFrames());
1207 if (frame.type != PING_FRAME && frame.type != CONNECTION_CLOSE_FRAME &&
1208 !delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
1209 NOT_HANDSHAKE)) {
1210 // Do not check congestion window for ping or connection close frames.
1211 return false;
1212 }
1213 const bool success = AddFrame(frame, next_transmission_type_);
1214 QUIC_BUG_IF(!success) << "Failed to add frame:" << frame
1215 << " transmission_type:" << next_transmission_type_;
1216 return success;
1217 }
1218
ConsumeData(QuicStreamId id,size_t write_length,QuicStreamOffset offset,StreamSendingState state)1219 QuicConsumedData QuicPacketCreator::ConsumeData(QuicStreamId id,
1220 size_t write_length,
1221 QuicStreamOffset offset,
1222 StreamSendingState state) {
1223 QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
1224 "generator tries to write stream data.";
1225 bool has_handshake = QuicUtils::IsCryptoStreamId(transport_version(), id);
1226 MaybeBundleAckOpportunistically();
1227 bool fin = state != NO_FIN;
1228 QUIC_BUG_IF(has_handshake && fin)
1229 << "Handshake packets should never send a fin";
1230 // To make reasoning about crypto frames easier, we don't combine them with
1231 // other retransmittable frames in a single packet.
1232 if (has_handshake && HasPendingRetransmittableFrames()) {
1233 FlushCurrentPacket();
1234 }
1235
1236 size_t total_bytes_consumed = 0;
1237 bool fin_consumed = false;
1238
1239 if (!HasRoomForStreamFrame(id, offset, write_length)) {
1240 FlushCurrentPacket();
1241 }
1242
1243 if (!fin && (write_length == 0)) {
1244 QUIC_BUG << "Attempt to consume empty data without FIN.";
1245 return QuicConsumedData(0, false);
1246 }
1247 // We determine if we can enter the fast path before executing
1248 // the slow path loop.
1249 bool run_fast_path =
1250 !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() &&
1251 write_length - total_bytes_consumed > kMaxOutgoingPacketSize &&
1252 latched_hard_max_packet_length_ == 0;
1253
1254 while (!run_fast_path &&
1255 (has_handshake || delegate_->ShouldGeneratePacket(
1256 HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE))) {
1257 QuicFrame frame;
1258 bool needs_full_padding =
1259 has_handshake && fully_pad_crypto_handshake_packets_;
1260
1261 if (!ConsumeDataToFillCurrentPacket(id, write_length - total_bytes_consumed,
1262 offset + total_bytes_consumed, fin,
1263 needs_full_padding,
1264 next_transmission_type_, &frame)) {
1265 // The creator is always flushed if there's not enough room for a new
1266 // stream frame before ConsumeData, so ConsumeData should always succeed.
1267 QUIC_BUG << "Failed to ConsumeData, stream:" << id;
1268 return QuicConsumedData(0, false);
1269 }
1270
1271 // A stream frame is created and added.
1272 size_t bytes_consumed = frame.stream_frame.data_length;
1273 total_bytes_consumed += bytes_consumed;
1274 fin_consumed = fin && total_bytes_consumed == write_length;
1275 if (fin_consumed && state == FIN_AND_PADDING) {
1276 AddRandomPadding();
1277 }
1278 DCHECK(total_bytes_consumed == write_length ||
1279 (bytes_consumed > 0 && HasPendingFrames()));
1280
1281 if (total_bytes_consumed == write_length) {
1282 // We're done writing the data. Exit the loop.
1283 // We don't make this a precondition because we could have 0 bytes of data
1284 // if we're simply writing a fin.
1285 break;
1286 }
1287 FlushCurrentPacket();
1288
1289 run_fast_path =
1290 !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() &&
1291 write_length - total_bytes_consumed > kMaxOutgoingPacketSize &&
1292 latched_hard_max_packet_length_ == 0;
1293 }
1294
1295 if (run_fast_path) {
1296 return ConsumeDataFastPath(id, write_length, offset, state != NO_FIN,
1297 total_bytes_consumed);
1298 }
1299
1300 // Don't allow the handshake to be bundled with other retransmittable frames.
1301 if (has_handshake) {
1302 FlushCurrentPacket();
1303 }
1304
1305 return QuicConsumedData(total_bytes_consumed, fin_consumed);
1306 }
1307
ConsumeDataFastPath(QuicStreamId id,size_t write_length,QuicStreamOffset offset,bool fin,size_t total_bytes_consumed)1308 QuicConsumedData QuicPacketCreator::ConsumeDataFastPath(
1309 QuicStreamId id,
1310 size_t write_length,
1311 QuicStreamOffset offset,
1312 bool fin,
1313 size_t total_bytes_consumed) {
1314 DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
1315 if (AttemptingToSendUnencryptedStreamData()) {
1316 return QuicConsumedData(total_bytes_consumed,
1317 fin && (total_bytes_consumed == write_length));
1318 }
1319
1320 while (total_bytes_consumed < write_length &&
1321 delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
1322 NOT_HANDSHAKE)) {
1323 // Serialize and encrypt the packet.
1324 size_t bytes_consumed = 0;
1325 CreateAndSerializeStreamFrame(id, write_length, total_bytes_consumed,
1326 offset + total_bytes_consumed, fin,
1327 next_transmission_type_, &bytes_consumed);
1328 if (bytes_consumed == 0) {
1329 const std::string error_details =
1330 "Failed in CreateAndSerializeStreamFrame.";
1331 QUIC_BUG << error_details;
1332 delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
1333 error_details);
1334 break;
1335 }
1336 total_bytes_consumed += bytes_consumed;
1337 }
1338
1339 return QuicConsumedData(total_bytes_consumed,
1340 fin && (total_bytes_consumed == write_length));
1341 }
1342
ConsumeCryptoData(EncryptionLevel level,size_t write_length,QuicStreamOffset offset)1343 size_t QuicPacketCreator::ConsumeCryptoData(EncryptionLevel level,
1344 size_t write_length,
1345 QuicStreamOffset offset) {
1346 QUIC_DVLOG(2) << "ConsumeCryptoData " << level << " write_length "
1347 << write_length << " offset " << offset;
1348 QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
1349 "generator tries to write crypto data.";
1350 MaybeBundleAckOpportunistically();
1351 // To make reasoning about crypto frames easier, we don't combine them with
1352 // other retransmittable frames in a single packet.
1353 // TODO(nharper): Once we have separate packet number spaces, everything
1354 // should be driven by encryption level, and we should stop flushing in this
1355 // spot.
1356 if (HasPendingRetransmittableFrames()) {
1357 FlushCurrentPacket();
1358 }
1359
1360 size_t total_bytes_consumed = 0;
1361
1362 while (
1363 total_bytes_consumed < write_length &&
1364 delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA, IS_HANDSHAKE)) {
1365 QuicFrame frame;
1366 if (!ConsumeCryptoDataToFillCurrentPacket(
1367 level, write_length - total_bytes_consumed,
1368 offset + total_bytes_consumed, fully_pad_crypto_handshake_packets_,
1369 next_transmission_type_, &frame)) {
1370 // The only pending data in the packet is non-retransmittable frames. I'm
1371 // assuming here that they won't occupy so much of the packet that a
1372 // CRYPTO frame won't fit.
1373 QUIC_BUG << "Failed to ConsumeCryptoData at level " << level;
1374 return 0;
1375 }
1376 total_bytes_consumed += frame.crypto_frame->data_length;
1377 FlushCurrentPacket();
1378 }
1379
1380 // Don't allow the handshake to be bundled with other retransmittable frames.
1381 FlushCurrentPacket();
1382
1383 return total_bytes_consumed;
1384 }
1385
GenerateMtuDiscoveryPacket(QuicByteCount target_mtu)1386 void QuicPacketCreator::GenerateMtuDiscoveryPacket(QuicByteCount target_mtu) {
1387 // MTU discovery frames must be sent by themselves.
1388 if (!CanSetMaxPacketLength()) {
1389 QUIC_BUG << "MTU discovery packets should only be sent when no other "
1390 << "frames needs to be sent.";
1391 return;
1392 }
1393 const QuicByteCount current_mtu = max_packet_length();
1394
1395 // The MTU discovery frame is allocated on the stack, since it is going to be
1396 // serialized within this function.
1397 QuicMtuDiscoveryFrame mtu_discovery_frame;
1398 QuicFrame frame(mtu_discovery_frame);
1399
1400 // Send the probe packet with the new length.
1401 SetMaxPacketLength(target_mtu);
1402 const bool success = AddPaddedSavedFrame(frame, next_transmission_type_);
1403 FlushCurrentPacket();
1404 // The only reason AddFrame can fail is that the packet is too full to fit in
1405 // a ping. This is not possible for any sane MTU.
1406 QUIC_BUG_IF(!success) << "Failed to send path MTU target_mtu:" << target_mtu
1407 << " transmission_type:" << next_transmission_type_;
1408
1409 // Reset the packet length back.
1410 SetMaxPacketLength(current_mtu);
1411 }
1412
MaybeBundleAckOpportunistically()1413 void QuicPacketCreator::MaybeBundleAckOpportunistically() {
1414 if (has_ack()) {
1415 // Ack already queued, nothing to do.
1416 return;
1417 }
1418 if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
1419 NOT_HANDSHAKE)) {
1420 return;
1421 }
1422 const bool flushed =
1423 FlushAckFrame(delegate_->MaybeBundleAckOpportunistically());
1424 QUIC_BUG_IF(!flushed) << "Failed to flush ACK frame. encryption_level:"
1425 << packet_.encryption_level;
1426 }
1427
FlushAckFrame(const QuicFrames & frames)1428 bool QuicPacketCreator::FlushAckFrame(const QuicFrames& frames) {
1429 QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
1430 "generator tries to send ACK frame.";
1431 for (const auto& frame : frames) {
1432 DCHECK(frame.type == ACK_FRAME || frame.type == STOP_WAITING_FRAME);
1433 if (HasPendingFrames()) {
1434 if (AddFrame(frame, next_transmission_type_)) {
1435 // There is pending frames and current frame fits.
1436 continue;
1437 }
1438 }
1439 DCHECK(!HasPendingFrames());
1440 // There is no pending frames, consult the delegate whether a packet can be
1441 // generated.
1442 if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
1443 NOT_HANDSHAKE)) {
1444 return false;
1445 }
1446 const bool success = AddFrame(frame, next_transmission_type_);
1447 QUIC_BUG_IF(!success) << "Failed to flush " << frame;
1448 }
1449 return true;
1450 }
1451
AddRandomPadding()1452 void QuicPacketCreator::AddRandomPadding() {
1453 AddPendingPadding(random_->RandUint64() % kMaxNumRandomPaddingBytes + 1);
1454 }
1455
AttachPacketFlusher()1456 void QuicPacketCreator::AttachPacketFlusher() {
1457 flusher_attached_ = true;
1458 if (!write_start_packet_number_.IsInitialized()) {
1459 write_start_packet_number_ = NextSendingPacketNumber();
1460 }
1461 }
1462
Flush()1463 void QuicPacketCreator::Flush() {
1464 FlushCurrentPacket();
1465 SendRemainingPendingPadding();
1466 flusher_attached_ = false;
1467 if (GetQuicFlag(FLAGS_quic_export_write_path_stats_at_server)) {
1468 if (!write_start_packet_number_.IsInitialized()) {
1469 QUIC_BUG << "write_start_packet_number is not initialized";
1470 return;
1471 }
1472 QUIC_SERVER_HISTOGRAM_COUNTS(
1473 "quic_server_num_written_packets_per_write",
1474 NextSendingPacketNumber() - write_start_packet_number_, 1, 200, 50,
1475 "Number of QUIC packets written per write operation");
1476 }
1477 write_start_packet_number_.Clear();
1478 }
1479
SendRemainingPendingPadding()1480 void QuicPacketCreator::SendRemainingPendingPadding() {
1481 while (
1482 pending_padding_bytes() > 0 && !HasPendingFrames() &&
1483 delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, NOT_HANDSHAKE)) {
1484 FlushCurrentPacket();
1485 }
1486 }
1487
SetServerConnectionIdLength(uint32_t length)1488 void QuicPacketCreator::SetServerConnectionIdLength(uint32_t length) {
1489 if (length == 0) {
1490 SetServerConnectionIdIncluded(CONNECTION_ID_ABSENT);
1491 } else {
1492 SetServerConnectionIdIncluded(CONNECTION_ID_PRESENT);
1493 }
1494 }
1495
SetTransmissionType(TransmissionType type)1496 void QuicPacketCreator::SetTransmissionType(TransmissionType type) {
1497 next_transmission_type_ = type;
1498 }
1499
AddMessageFrame(QuicMessageId message_id,QuicMemSliceSpan message)1500 MessageStatus QuicPacketCreator::AddMessageFrame(QuicMessageId message_id,
1501 QuicMemSliceSpan message) {
1502 QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
1503 "generator tries to add message frame.";
1504 MaybeBundleAckOpportunistically();
1505 const QuicByteCount message_length = message.total_length();
1506 if (message_length > GetCurrentLargestMessagePayload()) {
1507 return MESSAGE_STATUS_TOO_LARGE;
1508 }
1509 if (!HasRoomForMessageFrame(message_length)) {
1510 FlushCurrentPacket();
1511 }
1512 QuicMessageFrame* frame = new QuicMessageFrame(message_id, message);
1513 const bool success = AddFrame(QuicFrame(frame), next_transmission_type_);
1514 if (!success) {
1515 QUIC_BUG << "Failed to send message " << message_id;
1516 delete frame;
1517 return MESSAGE_STATUS_INTERNAL_ERROR;
1518 }
1519 return MESSAGE_STATUS_SUCCESS;
1520 }
1521
GetLengthLength() const1522 QuicVariableLengthIntegerLength QuicPacketCreator::GetLengthLength() const {
1523 if (QuicVersionHasLongHeaderLengths(framer_->transport_version()) &&
1524 HasIetfLongHeader()) {
1525 QuicLongHeaderType long_header_type =
1526 EncryptionlevelToLongHeaderType(packet_.encryption_level);
1527 if (long_header_type == INITIAL || long_header_type == ZERO_RTT_PROTECTED ||
1528 long_header_type == HANDSHAKE) {
1529 return VARIABLE_LENGTH_INTEGER_LENGTH_2;
1530 }
1531 }
1532 return VARIABLE_LENGTH_INTEGER_LENGTH_0;
1533 }
1534
FillPacketHeader(QuicPacketHeader * header)1535 void QuicPacketCreator::FillPacketHeader(QuicPacketHeader* header) {
1536 header->destination_connection_id = GetDestinationConnectionId();
1537 header->destination_connection_id_included =
1538 GetDestinationConnectionIdIncluded();
1539 header->source_connection_id = GetSourceConnectionId();
1540 header->source_connection_id_included = GetSourceConnectionIdIncluded();
1541 header->reset_flag = false;
1542 header->version_flag = IncludeVersionInHeader();
1543 if (IncludeNonceInPublicHeader()) {
1544 DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
1545 header->nonce = &diversification_nonce_;
1546 } else {
1547 header->nonce = nullptr;
1548 }
1549 packet_.packet_number = NextSendingPacketNumber();
1550 header->packet_number = packet_.packet_number;
1551 header->packet_number_length = GetPacketNumberLength();
1552 header->retry_token_length_length = GetRetryTokenLengthLength();
1553 header->retry_token = GetRetryToken();
1554 header->length_length = GetLengthLength();
1555 header->remaining_packet_length = 0;
1556 if (!HasIetfLongHeader()) {
1557 return;
1558 }
1559 header->long_packet_type =
1560 EncryptionlevelToLongHeaderType(packet_.encryption_level);
1561 }
1562
GetSerializedFrameLength(const QuicFrame & frame)1563 size_t QuicPacketCreator::GetSerializedFrameLength(const QuicFrame& frame) {
1564 size_t serialized_frame_length = framer_->GetSerializedFrameLength(
1565 frame, BytesFree(), queued_frames_.empty(),
1566 /* last_frame_in_packet= */ true, GetPacketNumberLength());
1567 if (!framer_->version().HasHeaderProtection() ||
1568 serialized_frame_length == 0) {
1569 return serialized_frame_length;
1570 }
1571 // Calculate frame bytes and bytes free with this frame added.
1572 const size_t frame_bytes = PacketSize() - PacketHeaderSize() +
1573 ExpansionOnNewFrame() + serialized_frame_length;
1574 if (frame_bytes >= MinPlaintextPacketSize(framer_->version())) {
1575 // No extra bytes is needed.
1576 return serialized_frame_length;
1577 }
1578 if (BytesFree() < serialized_frame_length) {
1579 QUIC_BUG << ENDPOINT << "Frame does not fit: " << frame;
1580 return 0;
1581 }
1582 // Please note bytes_free does not take |frame|'s expansion into account.
1583 size_t bytes_free = BytesFree() - serialized_frame_length;
1584 // Extra bytes needed (this is NOT padding needed) should be at least 1
1585 // padding + expansion.
1586 const size_t extra_bytes_needed = std::max(
1587 1 + ExpansionOnNewFrameWithLastFrame(frame, framer_->transport_version()),
1588 MinPlaintextPacketSize(framer_->version()) - frame_bytes);
1589 if (bytes_free < extra_bytes_needed) {
1590 // This frame does not fit.
1591 return 0;
1592 }
1593 return serialized_frame_length;
1594 }
1595
AddFrame(const QuicFrame & frame,TransmissionType transmission_type)1596 bool QuicPacketCreator::AddFrame(const QuicFrame& frame,
1597 TransmissionType transmission_type) {
1598 QUIC_DVLOG(1) << ENDPOINT << "Adding frame with transmission type "
1599 << transmission_type << ": " << frame;
1600 if (frame.type == STREAM_FRAME &&
1601 !QuicUtils::IsCryptoStreamId(framer_->transport_version(),
1602 frame.stream_frame.stream_id) &&
1603 AttemptingToSendUnencryptedStreamData()) {
1604 return false;
1605 }
1606
1607 if (frame.type == STREAM_FRAME) {
1608 if (MaybeCoalesceStreamFrame(frame.stream_frame)) {
1609 LogCoalesceStreamFrameStatus(true);
1610 return true;
1611 } else {
1612 LogCoalesceStreamFrameStatus(false);
1613 }
1614 }
1615
1616 // If this is an ACK frame, validate that it is non-empty and that
1617 // largest_acked matches the max packet number.
1618 DCHECK(frame.type != ACK_FRAME ||
1619 (!frame.ack_frame->packets.Empty() &&
1620 frame.ack_frame->packets.Max() == frame.ack_frame->largest_acked))
1621 << "Invalid ACK frame: " << frame;
1622
1623 size_t frame_len = GetSerializedFrameLength(frame);
1624 if (frame_len == 0 && RemoveSoftMaxPacketLength()) {
1625 // Remove soft max_packet_length and retry.
1626 frame_len = GetSerializedFrameLength(frame);
1627 }
1628 if (frame_len == 0) {
1629 QUIC_DVLOG(1) << "Flushing because current open packet is full when adding "
1630 << frame;
1631 FlushCurrentPacket();
1632 return false;
1633 }
1634 if (queued_frames_.empty()) {
1635 packet_size_ = PacketHeaderSize();
1636 }
1637 DCHECK_LT(0u, packet_size_);
1638
1639 packet_size_ += ExpansionOnNewFrame() + frame_len;
1640
1641 if (QuicUtils::IsRetransmittableFrame(frame.type)) {
1642 packet_.retransmittable_frames.push_back(frame);
1643 queued_frames_.push_back(frame);
1644 if (QuicUtils::IsHandshakeFrame(frame, framer_->transport_version())) {
1645 packet_.has_crypto_handshake = IS_HANDSHAKE;
1646 }
1647 } else {
1648 if (frame.type == PADDING_FRAME &&
1649 frame.padding_frame.num_padding_bytes == -1) {
1650 // Populate the actual length of full padding frame, such that one can
1651 // know how much padding is actually added.
1652 packet_.nonretransmittable_frames.push_back(
1653 QuicFrame(QuicPaddingFrame(frame_len)));
1654 } else {
1655 packet_.nonretransmittable_frames.push_back(frame);
1656 }
1657 queued_frames_.push_back(frame);
1658 }
1659
1660 if (frame.type == ACK_FRAME) {
1661 packet_.has_ack = true;
1662 packet_.largest_acked = LargestAcked(*frame.ack_frame);
1663 } else if (frame.type == STOP_WAITING_FRAME) {
1664 packet_.has_stop_waiting = true;
1665 } else if (frame.type == ACK_FREQUENCY_FRAME) {
1666 packet_.has_ack_frequency = true;
1667 } else if (frame.type == MESSAGE_FRAME) {
1668 packet_.has_message = true;
1669 }
1670 if (debug_delegate_ != nullptr) {
1671 debug_delegate_->OnFrameAddedToPacket(frame);
1672 }
1673
1674 // Packet transmission type is determined by the last added retransmittable
1675 // frame.
1676 if (QuicUtils::IsRetransmittableFrame(frame.type)) {
1677 packet_.transmission_type = transmission_type;
1678 }
1679 return true;
1680 }
1681
MaybeAddExtraPaddingForHeaderProtection()1682 void QuicPacketCreator::MaybeAddExtraPaddingForHeaderProtection() {
1683 if (!framer_->version().HasHeaderProtection() || needs_full_padding_) {
1684 return;
1685 }
1686 const size_t frame_bytes = PacketSize() - PacketHeaderSize();
1687 if (frame_bytes >= MinPlaintextPacketSize(framer_->version())) {
1688 return;
1689 }
1690 const QuicByteCount min_header_protection_padding =
1691 std::max(1 + ExpansionOnNewFrame(),
1692 MinPlaintextPacketSize(framer_->version()) - frame_bytes) -
1693 ExpansionOnNewFrame();
1694 // Update pending_padding_bytes_.
1695 pending_padding_bytes_ =
1696 std::max(pending_padding_bytes_, min_header_protection_padding);
1697 }
1698
MaybeCoalesceStreamFrame(const QuicStreamFrame & frame)1699 bool QuicPacketCreator::MaybeCoalesceStreamFrame(const QuicStreamFrame& frame) {
1700 if (queued_frames_.empty() || queued_frames_.back().type != STREAM_FRAME) {
1701 return false;
1702 }
1703 QuicStreamFrame* candidate = &queued_frames_.back().stream_frame;
1704 if (candidate->stream_id != frame.stream_id ||
1705 candidate->offset + candidate->data_length != frame.offset ||
1706 frame.data_length > BytesFree()) {
1707 return false;
1708 }
1709 candidate->data_length += frame.data_length;
1710 candidate->fin = frame.fin;
1711
1712 // The back of retransmittable frames must be the same as the original
1713 // queued frames' back.
1714 DCHECK_EQ(packet_.retransmittable_frames.back().type, STREAM_FRAME);
1715 QuicStreamFrame* retransmittable =
1716 &packet_.retransmittable_frames.back().stream_frame;
1717 DCHECK_EQ(retransmittable->stream_id, frame.stream_id);
1718 DCHECK_EQ(retransmittable->offset + retransmittable->data_length,
1719 frame.offset);
1720 retransmittable->data_length = candidate->data_length;
1721 retransmittable->fin = candidate->fin;
1722 packet_size_ += frame.data_length;
1723 if (debug_delegate_ != nullptr) {
1724 debug_delegate_->OnStreamFrameCoalesced(*candidate);
1725 }
1726 return true;
1727 }
1728
RemoveSoftMaxPacketLength()1729 bool QuicPacketCreator::RemoveSoftMaxPacketLength() {
1730 if (latched_hard_max_packet_length_ == 0) {
1731 return false;
1732 }
1733 if (!CanSetMaxPacketLength()) {
1734 return false;
1735 }
1736 QUIC_DVLOG(1) << "Restoring max packet length to: "
1737 << latched_hard_max_packet_length_;
1738 SetMaxPacketLength(latched_hard_max_packet_length_);
1739 // Reset latched_max_packet_length_.
1740 latched_hard_max_packet_length_ = 0;
1741 return true;
1742 }
1743
MaybeAddPadding()1744 void QuicPacketCreator::MaybeAddPadding() {
1745 // The current packet should have no padding bytes because padding is only
1746 // added when this method is called just before the packet is serialized.
1747 if (BytesFree() == 0) {
1748 // Don't pad full packets.
1749 return;
1750 }
1751
1752 if (packet_.transmission_type == PROBING_RETRANSMISSION) {
1753 needs_full_padding_ = true;
1754 }
1755
1756 if (packet_.fate == COALESCE || packet_.fate == LEGACY_VERSION_ENCAPSULATE) {
1757 // Do not add full padding if the packet is going to be coalesced or
1758 // encapsulated.
1759 needs_full_padding_ = false;
1760 }
1761
1762 // Header protection requires a minimum plaintext packet size.
1763 MaybeAddExtraPaddingForHeaderProtection();
1764
1765 if (!needs_full_padding_ && pending_padding_bytes_ == 0) {
1766 // Do not need padding.
1767 return;
1768 }
1769
1770 int padding_bytes = -1;
1771 if (!needs_full_padding_) {
1772 padding_bytes = std::min<int16_t>(pending_padding_bytes_, BytesFree());
1773 pending_padding_bytes_ -= padding_bytes;
1774 }
1775
1776 bool success = AddFrame(QuicFrame(QuicPaddingFrame(padding_bytes)),
1777 packet_.transmission_type);
1778 QUIC_BUG_IF(!success) << "Failed to add padding_bytes: " << padding_bytes
1779 << " transmission_type: " << packet_.transmission_type;
1780 }
1781
IncludeNonceInPublicHeader() const1782 bool QuicPacketCreator::IncludeNonceInPublicHeader() const {
1783 return have_diversification_nonce_ &&
1784 packet_.encryption_level == ENCRYPTION_ZERO_RTT;
1785 }
1786
IncludeVersionInHeader() const1787 bool QuicPacketCreator::IncludeVersionInHeader() const {
1788 if (VersionHasIetfInvariantHeader(framer_->transport_version())) {
1789 return packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
1790 }
1791 return send_version_in_packet_;
1792 }
1793
AddPendingPadding(QuicByteCount size)1794 void QuicPacketCreator::AddPendingPadding(QuicByteCount size) {
1795 pending_padding_bytes_ += size;
1796 }
1797
StreamFrameIsClientHello(const QuicStreamFrame & frame) const1798 bool QuicPacketCreator::StreamFrameIsClientHello(
1799 const QuicStreamFrame& frame) const {
1800 if (framer_->perspective() == Perspective::IS_SERVER ||
1801 !QuicUtils::IsCryptoStreamId(framer_->transport_version(),
1802 frame.stream_id)) {
1803 return false;
1804 }
1805 // The ClientHello is always sent with INITIAL encryption.
1806 return packet_.encryption_level == ENCRYPTION_INITIAL;
1807 }
1808
SetServerConnectionIdIncluded(QuicConnectionIdIncluded server_connection_id_included)1809 void QuicPacketCreator::SetServerConnectionIdIncluded(
1810 QuicConnectionIdIncluded server_connection_id_included) {
1811 DCHECK(server_connection_id_included == CONNECTION_ID_PRESENT ||
1812 server_connection_id_included == CONNECTION_ID_ABSENT);
1813 DCHECK(framer_->perspective() == Perspective::IS_SERVER ||
1814 server_connection_id_included != CONNECTION_ID_ABSENT);
1815 server_connection_id_included_ = server_connection_id_included;
1816 }
1817
SetServerConnectionId(QuicConnectionId server_connection_id)1818 void QuicPacketCreator::SetServerConnectionId(
1819 QuicConnectionId server_connection_id) {
1820 server_connection_id_ = server_connection_id;
1821 }
1822
SetClientConnectionId(QuicConnectionId client_connection_id)1823 void QuicPacketCreator::SetClientConnectionId(
1824 QuicConnectionId client_connection_id) {
1825 DCHECK(client_connection_id.IsEmpty() ||
1826 framer_->version().SupportsClientConnectionIds());
1827 client_connection_id_ = client_connection_id;
1828 }
1829
GetCurrentLargestMessagePayload() const1830 QuicPacketLength QuicPacketCreator::GetCurrentLargestMessagePayload() const {
1831 if (!VersionSupportsMessageFrames(framer_->transport_version())) {
1832 return 0;
1833 }
1834 const size_t packet_header_size = GetPacketHeaderSize(
1835 framer_->transport_version(), GetDestinationConnectionIdLength(),
1836 GetSourceConnectionIdLength(), IncludeVersionInHeader(),
1837 IncludeNonceInPublicHeader(), GetPacketNumberLength(),
1838 // No Retry token on packets containing application data.
1839 VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, GetLengthLength());
1840 // This is the largest possible message payload when the length field is
1841 // omitted.
1842 size_t max_plaintext_size =
1843 latched_hard_max_packet_length_ == 0
1844 ? max_plaintext_size_
1845 : framer_->GetMaxPlaintextSize(latched_hard_max_packet_length_);
1846 size_t largest_frame =
1847 max_plaintext_size - std::min(max_plaintext_size, packet_header_size);
1848 if (static_cast<QuicByteCount>(largest_frame) > max_datagram_frame_size_) {
1849 largest_frame = static_cast<size_t>(max_datagram_frame_size_);
1850 }
1851 return largest_frame - std::min(largest_frame, kQuicFrameTypeSize);
1852 }
1853
GetGuaranteedLargestMessagePayload() const1854 QuicPacketLength QuicPacketCreator::GetGuaranteedLargestMessagePayload() const {
1855 if (!VersionSupportsMessageFrames(framer_->transport_version())) {
1856 return 0;
1857 }
1858 // QUIC Crypto server packets may include a diversification nonce.
1859 const bool may_include_nonce =
1860 framer_->version().handshake_protocol == PROTOCOL_QUIC_CRYPTO &&
1861 framer_->perspective() == Perspective::IS_SERVER;
1862 // IETF QUIC long headers include a length on client 0RTT packets.
1863 QuicVariableLengthIntegerLength length_length =
1864 VARIABLE_LENGTH_INTEGER_LENGTH_0;
1865 if (framer_->perspective() == Perspective::IS_CLIENT) {
1866 length_length = VARIABLE_LENGTH_INTEGER_LENGTH_2;
1867 }
1868 if (!QuicVersionHasLongHeaderLengths(framer_->transport_version())) {
1869 length_length = VARIABLE_LENGTH_INTEGER_LENGTH_0;
1870 }
1871 const size_t packet_header_size = GetPacketHeaderSize(
1872 framer_->transport_version(), GetDestinationConnectionIdLength(),
1873 // Assume CID lengths don't change, but version may be present.
1874 GetSourceConnectionIdLength(), kIncludeVersion, may_include_nonce,
1875 PACKET_4BYTE_PACKET_NUMBER,
1876 // No Retry token on packets containing application data.
1877 VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, length_length);
1878 // This is the largest possible message payload when the length field is
1879 // omitted.
1880 size_t max_plaintext_size =
1881 latched_hard_max_packet_length_ == 0
1882 ? max_plaintext_size_
1883 : framer_->GetMaxPlaintextSize(latched_hard_max_packet_length_);
1884 size_t largest_frame =
1885 max_plaintext_size - std::min(max_plaintext_size, packet_header_size);
1886 if (static_cast<QuicByteCount>(largest_frame) > max_datagram_frame_size_) {
1887 largest_frame = static_cast<size_t>(max_datagram_frame_size_);
1888 }
1889 const QuicPacketLength largest_payload =
1890 largest_frame - std::min(largest_frame, kQuicFrameTypeSize);
1891 // This must always be less than or equal to GetCurrentLargestMessagePayload.
1892 DCHECK_LE(largest_payload, GetCurrentLargestMessagePayload());
1893 return largest_payload;
1894 }
1895
AttemptingToSendUnencryptedStreamData()1896 bool QuicPacketCreator::AttemptingToSendUnencryptedStreamData() {
1897 if (packet_.encryption_level == ENCRYPTION_ZERO_RTT ||
1898 packet_.encryption_level == ENCRYPTION_FORWARD_SECURE) {
1899 return false;
1900 }
1901 const std::string error_details =
1902 quiche::QuicheStrCat("Cannot send stream data with level: ",
1903 EncryptionLevelToString(packet_.encryption_level));
1904 QUIC_BUG << error_details;
1905 delegate_->OnUnrecoverableError(QUIC_ATTEMPT_TO_SEND_UNENCRYPTED_STREAM_DATA,
1906 error_details);
1907 return true;
1908 }
1909
HasIetfLongHeader() const1910 bool QuicPacketCreator::HasIetfLongHeader() const {
1911 return VersionHasIetfInvariantHeader(framer_->transport_version()) &&
1912 packet_.encryption_level < ENCRYPTION_FORWARD_SECURE;
1913 }
1914
1915 // static
MinPlaintextPacketSize(const ParsedQuicVersion & version)1916 size_t QuicPacketCreator::MinPlaintextPacketSize(
1917 const ParsedQuicVersion& version) {
1918 if (!version.HasHeaderProtection()) {
1919 return 0;
1920 }
1921 // Header protection samples 16 bytes of ciphertext starting 4 bytes after the
1922 // packet number. In IETF QUIC, all AEAD algorithms have a 16-byte auth tag
1923 // (i.e. the ciphertext is 16 bytes larger than the plaintext). Since packet
1924 // numbers could be as small as 1 byte, but the sample starts 4 bytes after
1925 // the packet number, at least 3 bytes of plaintext are needed to make sure
1926 // that there is enough ciphertext to sample.
1927 //
1928 // Google QUIC crypto uses different AEAD algorithms - in particular the auth
1929 // tags are only 12 bytes instead of 16 bytes. Since the auth tag is 4 bytes
1930 // shorter, 4 more bytes of plaintext are needed to guarantee there is enough
1931 // ciphertext to sample.
1932 //
1933 // This method could check for PROTOCOL_TLS1_3 vs PROTOCOL_QUIC_CRYPTO and
1934 // return 3 when TLS 1.3 is in use (the use of IETF vs Google QUIC crypters is
1935 // determined based on the handshake protocol used). However, even when TLS
1936 // 1.3 is used, unittests still use NullEncrypter/NullDecrypter (and other
1937 // test crypters) which also only use 12 byte tags.
1938 //
1939 // TODO(nharper): Set this based on the handshake protocol in use.
1940 return 7;
1941 }
1942
NextSendingPacketNumber() const1943 QuicPacketNumber QuicPacketCreator::NextSendingPacketNumber() const {
1944 if (!packet_number().IsInitialized()) {
1945 return framer_->first_sending_packet_number();
1946 }
1947 return packet_number() + 1;
1948 }
1949
PacketFlusherAttached() const1950 bool QuicPacketCreator::PacketFlusherAttached() const {
1951 return flusher_attached_;
1952 }
1953
HasSoftMaxPacketLength() const1954 bool QuicPacketCreator::HasSoftMaxPacketLength() const {
1955 return latched_hard_max_packet_length_ != 0;
1956 }
1957
SetDefaultPeerAddress(QuicSocketAddress address)1958 void QuicPacketCreator::SetDefaultPeerAddress(QuicSocketAddress address) {
1959 if (!packet_.peer_address.IsInitialized()) {
1960 packet_.peer_address = address;
1961 return;
1962 }
1963 if (packet_.peer_address != address) {
1964 FlushCurrentPacket();
1965 packet_.peer_address = address;
1966 }
1967 }
1968
ScopedPeerAddressContext(QuicPacketCreator * creator,QuicSocketAddress address)1969 QuicPacketCreator::ScopedPeerAddressContext::ScopedPeerAddressContext(
1970 QuicPacketCreator* creator,
1971 QuicSocketAddress address)
1972 : creator_(creator), old_peer_address_(creator_->packet_.peer_address) {
1973 QUIC_BUG_IF(!creator_->packet_.peer_address.IsInitialized())
1974 << "Context is used before seralized packet's peer address is "
1975 "initialized.";
1976 creator_->SetDefaultPeerAddress(address);
1977 }
1978
~ScopedPeerAddressContext()1979 QuicPacketCreator::ScopedPeerAddressContext::~ScopedPeerAddressContext() {
1980 creator_->SetDefaultPeerAddress(old_peer_address_);
1981 }
1982
1983 QuicPacketCreator::ScopedSerializationFailureHandler::
ScopedSerializationFailureHandler(QuicPacketCreator * creator)1984 ScopedSerializationFailureHandler(QuicPacketCreator* creator)
1985 : creator_(creator) {}
1986
1987 QuicPacketCreator::ScopedSerializationFailureHandler::
~ScopedSerializationFailureHandler()1988 ~ScopedSerializationFailureHandler() {
1989 if (creator_ == nullptr) {
1990 return;
1991 }
1992 // Always clear queued_frames_.
1993 creator_->queued_frames_.clear();
1994
1995 if (creator_->packet_.encrypted_buffer == nullptr) {
1996 const std::string error_details = "Failed to SerializePacket.";
1997 QUIC_BUG << error_details;
1998 creator_->delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
1999 error_details);
2000 }
2001 }
2002
set_encryption_level(EncryptionLevel level)2003 void QuicPacketCreator::set_encryption_level(EncryptionLevel level) {
2004 DCHECK(level == packet_.encryption_level || !HasPendingFrames())
2005 << "Cannot update encryption level from " << packet_.encryption_level
2006 << " to " << level << " when we already have pending frames: "
2007 << QuicFramesToString(queued_frames_);
2008 packet_.encryption_level = level;
2009 }
2010
AddPathChallengeFrame(QuicPathFrameBuffer * payload)2011 void QuicPacketCreator::AddPathChallengeFrame(QuicPathFrameBuffer* payload) {
2012 // Write a PATH_CHALLENGE frame, which has a random 8-byte payload.
2013 random_->RandBytes(payload->data(), payload->size());
2014 auto path_challenge_frame = new QuicPathChallengeFrame(0, *payload);
2015 QuicFrame frame(path_challenge_frame);
2016 if (AddPaddedFrameWithRetry(frame)) {
2017 return;
2018 }
2019 // Fail silently if the probing packet cannot be written, path validation
2020 // initiator will retry sending automatically.
2021 // TODO(danzh) This will consume retry budget, if it causes performance
2022 // regression, consider to notify the caller about the sending failure and let
2023 // the caller to decide if it worth retrying.
2024 QUIC_DVLOG(1) << ENDPOINT << "Can't send PATH_CHALLENGE now";
2025 delete path_challenge_frame;
2026 }
2027
AddPathResponseFrame(const QuicPathFrameBuffer & data_buffer)2028 bool QuicPacketCreator::AddPathResponseFrame(
2029 const QuicPathFrameBuffer& data_buffer) {
2030 auto path_response =
2031 new QuicPathResponseFrame(kInvalidControlFrameId, data_buffer);
2032 QuicFrame frame(path_response);
2033 if (AddPaddedFrameWithRetry(frame)) {
2034 return true;
2035 }
2036
2037 QUIC_DVLOG(1) << ENDPOINT << "Can't send PATH_RESPONSE now";
2038 QUIC_RELOADABLE_FLAG_COUNT_N(quic_send_path_response, 5, 5);
2039 delete path_response;
2040 return false;
2041 }
2042
AddPaddedFrameWithRetry(const QuicFrame & frame)2043 bool QuicPacketCreator::AddPaddedFrameWithRetry(const QuicFrame& frame) {
2044 if (HasPendingFrames()) {
2045 if (AddPaddedSavedFrame(frame, NOT_RETRANSMISSION)) {
2046 // Frame is queued.
2047 return true;
2048 }
2049 }
2050 // Frame was not queued but queued frames were flushed.
2051 DCHECK(!HasPendingFrames());
2052 if (!delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2053 NOT_HANDSHAKE)) {
2054 return false;
2055 }
2056 bool success = AddPaddedSavedFrame(frame, NOT_RETRANSMISSION);
2057 QUIC_BUG_IF(!success);
2058 return true;
2059 }
2060
2061 #undef ENDPOINT // undef for jumbo builds
2062 } // namespace quic
2063