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