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