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 <cstdint>
8 #include <limits>
9 #include <memory>
10 #include <ostream>
11 #include <string>
12 #include <utility>
13
14 #include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
15 #include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
16 #include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
17 #include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
18 #include "net/third_party/quiche/src/quic/core/frames/quic_stream_frame.h"
19 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
20 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
21 #include "net/third_party/quiche/src/quic/core/quic_types.h"
22 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
23 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
24 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
25 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
26 #include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
27 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
28 #include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
29 #include "net/third_party/quiche/src/quic/test_tools/quic_packet_creator_peer.h"
30 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
31 #include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"
32 #include "net/third_party/quiche/src/quic/test_tools/simple_quic_framer.h"
33 #include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
34 #include "net/third_party/quiche/src/common/platform/api/quiche_str_cat.h"
35 #include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.h"
36 #include "net/third_party/quiche/src/common/test_tools/quiche_test_utils.h"
37
38 using testing::_;
39 using testing::DoAll;
40 using testing::InSequence;
41 using testing::Invoke;
42 using testing::Return;
43 using testing::SaveArg;
44 using testing::StrictMock;
45
46 namespace quic {
47 namespace test {
48 namespace {
49
50 const QuicPacketNumber kPacketNumber = QuicPacketNumber(UINT64_C(0x12345678));
51 // Use fields in which each byte is distinct to ensure that every byte is
52 // framed correctly. The values are otherwise arbitrary.
CreateTestConnectionId()53 QuicConnectionId CreateTestConnectionId() {
54 return TestConnectionId(UINT64_C(0xFEDCBA9876543210));
55 }
56
57 // Run tests with combinations of {ParsedQuicVersion,
58 // ToggleVersionSerialization}.
59 struct TestParams {
TestParamsquic::test::__anonc6aac9380111::TestParams60 TestParams(ParsedQuicVersion version, bool version_serialization)
61 : version(version), version_serialization(version_serialization) {}
62
63 ParsedQuicVersion version;
64 bool version_serialization;
65 };
66
67 // Used by ::testing::PrintToStringParamName().
PrintToString(const TestParams & p)68 std::string PrintToString(const TestParams& p) {
69 return quiche::QuicheStrCat(ParsedQuicVersionToString(p.version), "_",
70 (p.version_serialization ? "Include" : "No"),
71 "Version");
72 }
73
74 // Constructs various test permutations.
GetTestParams()75 std::vector<TestParams> GetTestParams() {
76 std::vector<TestParams> params;
77 ParsedQuicVersionVector all_supported_versions = AllSupportedVersions();
78 for (size_t i = 0; i < all_supported_versions.size(); ++i) {
79 params.push_back(TestParams(all_supported_versions[i], true));
80 params.push_back(TestParams(all_supported_versions[i], false));
81 }
82 return params;
83 }
84
85 class MockDebugDelegate : public QuicPacketCreator::DebugDelegate {
86 public:
87 ~MockDebugDelegate() override = default;
88
89 MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame& frame));
90
91 MOCK_METHOD1(OnStreamFrameCoalesced, void(const QuicStreamFrame& frame));
92 };
93
94 class TestPacketCreator : public QuicPacketCreator {
95 public:
TestPacketCreator(QuicConnectionId connection_id,QuicFramer * framer,DelegateInterface * delegate,SimpleDataProducer * producer)96 TestPacketCreator(QuicConnectionId connection_id,
97 QuicFramer* framer,
98 DelegateInterface* delegate,
99 SimpleDataProducer* producer)
100 : QuicPacketCreator(connection_id, framer, delegate),
101 producer_(producer),
102 version_(framer->transport_version()) {}
103
ConsumeDataToFillCurrentPacket(QuicStreamId id,const struct iovec * iov,int iov_count,size_t total_length,size_t iov_offset,QuicStreamOffset offset,bool fin,bool needs_full_padding,TransmissionType transmission_type,QuicFrame * frame)104 bool ConsumeDataToFillCurrentPacket(QuicStreamId id,
105 const struct iovec* iov,
106 int iov_count,
107 size_t total_length,
108 size_t iov_offset,
109 QuicStreamOffset offset,
110 bool fin,
111 bool needs_full_padding,
112 TransmissionType transmission_type,
113 QuicFrame* frame) {
114 // Save data before data is consumed.
115 QuicByteCount data_length = total_length - iov_offset;
116 if (data_length > 0) {
117 producer_->SaveStreamData(id, iov, iov_count, iov_offset, data_length);
118 }
119 return QuicPacketCreator::ConsumeDataToFillCurrentPacket(
120 id, data_length - iov_offset, offset, fin, needs_full_padding,
121 transmission_type, frame);
122 }
123
StopSendingVersion()124 void StopSendingVersion() {
125 if (VersionHasIetfInvariantHeader(version_)) {
126 set_encryption_level(ENCRYPTION_FORWARD_SECURE);
127 return;
128 }
129 QuicPacketCreator::StopSendingVersion();
130 }
131
132 SimpleDataProducer* producer_;
133 QuicTransportVersion version_;
134 };
135
136 class QuicPacketCreatorTest : public QuicTestWithParam<TestParams> {
137 public:
ClearSerializedPacketForTests(SerializedPacket * serialized_packet)138 void ClearSerializedPacketForTests(SerializedPacket* serialized_packet) {
139 if (serialized_packet == nullptr) {
140 return;
141 }
142 ClearSerializedPacket(serialized_packet);
143 }
144
SaveSerializedPacket(SerializedPacket * serialized_packet)145 void SaveSerializedPacket(SerializedPacket* serialized_packet) {
146 if (serialized_packet == nullptr) {
147 return;
148 }
149 delete[] serialized_packet_.encrypted_buffer;
150 serialized_packet_ = *serialized_packet;
151 serialized_packet_.encrypted_buffer = CopyBuffer(*serialized_packet);
152 serialized_packet->retransmittable_frames.clear();
153 }
154
DeleteSerializedPacket()155 void DeleteSerializedPacket() {
156 delete[] serialized_packet_.encrypted_buffer;
157 serialized_packet_.encrypted_buffer = nullptr;
158 ClearSerializedPacket(&serialized_packet_);
159 }
160
161 protected:
QuicPacketCreatorTest()162 QuicPacketCreatorTest()
163 : connection_id_(TestConnectionId(2)),
164 server_framer_(SupportedVersions(GetParam().version),
165 QuicTime::Zero(),
166 Perspective::IS_SERVER,
167 connection_id_.length()),
168 client_framer_(SupportedVersions(GetParam().version),
169 QuicTime::Zero(),
170 Perspective::IS_CLIENT,
171 connection_id_.length()),
172 data_("foo"),
173 creator_(connection_id_, &client_framer_, &delegate_, &producer_),
174 serialized_packet_(creator_.NoPacket()) {
175 EXPECT_CALL(delegate_, GetPacketBuffer()).WillRepeatedly(Return(nullptr));
176 creator_.SetEncrypter(ENCRYPTION_INITIAL, std::make_unique<NullEncrypter>(
177 Perspective::IS_CLIENT));
178 creator_.SetEncrypter(ENCRYPTION_HANDSHAKE, std::make_unique<NullEncrypter>(
179 Perspective::IS_CLIENT));
180 creator_.SetEncrypter(ENCRYPTION_ZERO_RTT, std::make_unique<NullEncrypter>(
181 Perspective::IS_CLIENT));
182 creator_.SetEncrypter(
183 ENCRYPTION_FORWARD_SECURE,
184 std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
185 client_framer_.set_visitor(&framer_visitor_);
186 server_framer_.set_visitor(&framer_visitor_);
187 client_framer_.set_data_producer(&producer_);
188 if (server_framer_.version().KnowsWhichDecrypterToUse()) {
189 server_framer_.InstallDecrypter(
190 ENCRYPTION_INITIAL,
191 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
192 server_framer_.InstallDecrypter(
193 ENCRYPTION_ZERO_RTT,
194 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
195 server_framer_.InstallDecrypter(
196 ENCRYPTION_HANDSHAKE,
197 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
198 server_framer_.InstallDecrypter(
199 ENCRYPTION_FORWARD_SECURE,
200 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
201 } else {
202 server_framer_.SetDecrypter(
203 ENCRYPTION_INITIAL,
204 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
205 }
206 }
207
~QuicPacketCreatorTest()208 ~QuicPacketCreatorTest() override {
209 delete[] serialized_packet_.encrypted_buffer;
210 ClearSerializedPacket(&serialized_packet_);
211 }
212
SerializeAllFrames(const QuicFrames & frames)213 SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
214 SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
215 &creator_, frames, buffer_, kMaxOutgoingPacketSize);
216 EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
217 packet.encryption_level);
218 return packet;
219 }
220
ProcessPacket(const SerializedPacket & packet)221 void ProcessPacket(const SerializedPacket& packet) {
222 QuicEncryptedPacket encrypted_packet(packet.encrypted_buffer,
223 packet.encrypted_length);
224 server_framer_.ProcessPacket(encrypted_packet);
225 }
226
CheckStreamFrame(const QuicFrame & frame,QuicStreamId stream_id,const std::string & data,QuicStreamOffset offset,bool fin)227 void CheckStreamFrame(const QuicFrame& frame,
228 QuicStreamId stream_id,
229 const std::string& data,
230 QuicStreamOffset offset,
231 bool fin) {
232 EXPECT_EQ(STREAM_FRAME, frame.type);
233 EXPECT_EQ(stream_id, frame.stream_frame.stream_id);
234 char buf[kMaxOutgoingPacketSize];
235 QuicDataWriter writer(kMaxOutgoingPacketSize, buf, quiche::HOST_BYTE_ORDER);
236 if (frame.stream_frame.data_length > 0) {
237 producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
238 frame.stream_frame.data_length, &writer);
239 }
240 EXPECT_EQ(data,
241 quiche::QuicheStringPiece(buf, frame.stream_frame.data_length));
242 EXPECT_EQ(offset, frame.stream_frame.offset);
243 EXPECT_EQ(fin, frame.stream_frame.fin);
244 }
245
246 // Returns the number of bytes consumed by the header of packet, including
247 // the version.
GetPacketHeaderOverhead(QuicTransportVersion version)248 size_t GetPacketHeaderOverhead(QuicTransportVersion version) {
249 return GetPacketHeaderSize(
250 version, creator_.GetDestinationConnectionIdLength(),
251 creator_.GetSourceConnectionIdLength(),
252 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
253 !kIncludeDiversificationNonce,
254 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
255 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
256 QuicPacketCreatorPeer::GetLengthLength(&creator_));
257 }
258
259 // Returns the number of bytes of overhead that will be added to a packet
260 // of maximum length.
GetEncryptionOverhead()261 size_t GetEncryptionOverhead() {
262 return creator_.max_packet_length() -
263 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
264 }
265
266 // Returns the number of bytes consumed by the non-data fields of a stream
267 // frame, assuming it is the last frame in the packet
GetStreamFrameOverhead(QuicTransportVersion version)268 size_t GetStreamFrameOverhead(QuicTransportVersion version) {
269 return QuicFramer::GetMinStreamFrameSize(
270 version, GetNthClientInitiatedStreamId(1), kOffset, true,
271 /* data_length= */ 0);
272 }
273
IsDefaultTestConfiguration()274 bool IsDefaultTestConfiguration() {
275 TestParams p = GetParam();
276 return p.version == AllSupportedVersions()[0] && p.version_serialization;
277 }
278
GetNthClientInitiatedStreamId(int n) const279 QuicStreamId GetNthClientInitiatedStreamId(int n) const {
280 return QuicUtils::GetFirstBidirectionalStreamId(
281 creator_.transport_version(), Perspective::IS_CLIENT) +
282 n * 2;
283 }
284
285 static const QuicStreamOffset kOffset = 0u;
286
287 char buffer_[kMaxOutgoingPacketSize];
288 QuicConnectionId connection_id_;
289 QuicFrames frames_;
290 QuicFramer server_framer_;
291 QuicFramer client_framer_;
292 StrictMock<MockFramerVisitor> framer_visitor_;
293 StrictMock<MockPacketCreatorDelegate> delegate_;
294 std::string data_;
295 struct iovec iov_;
296 TestPacketCreator creator_;
297 SerializedPacket serialized_packet_;
298 SimpleDataProducer producer_;
299 SimpleBufferAllocator allocator_;
300 };
301
302 // Run all packet creator tests with all supported versions of QUIC, and with
303 // and without version in the packet header, as well as doing a run for each
304 // length of truncated connection id.
305 INSTANTIATE_TEST_SUITE_P(QuicPacketCreatorTests,
306 QuicPacketCreatorTest,
307 ::testing::ValuesIn(GetTestParams()),
308 ::testing::PrintToStringParamName());
309
TEST_P(QuicPacketCreatorTest,SerializeFrames)310 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
311 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
312 EncryptionLevel level = static_cast<EncryptionLevel>(i);
313 creator_.set_encryption_level(level);
314 frames_.push_back(QuicFrame(new QuicAckFrame(InitAckFrame(1))));
315 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
316 client_framer_.transport_version(), Perspective::IS_CLIENT);
317 if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
318 frames_.push_back(QuicFrame(
319 QuicStreamFrame(stream_id, false, 0u, quiche::QuicheStringPiece())));
320 }
321 SerializedPacket serialized = SerializeAllFrames(frames_);
322 EXPECT_EQ(level, serialized.encryption_level);
323 delete frames_[0].ack_frame;
324 frames_.clear();
325
326 {
327 InSequence s;
328 EXPECT_CALL(framer_visitor_, OnPacket());
329 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
330 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
331 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
332 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
333 EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _))
334 .WillOnce(Return(true));
335 EXPECT_CALL(framer_visitor_,
336 OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2)))
337 .WillOnce(Return(true));
338 EXPECT_CALL(framer_visitor_, OnAckFrameEnd(QuicPacketNumber(1)))
339 .WillOnce(Return(true));
340 if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
341 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
342 }
343 if (client_framer_.version().HasHeaderProtection()) {
344 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_))
345 .Times(testing::AnyNumber());
346 }
347 EXPECT_CALL(framer_visitor_, OnPacketComplete());
348 }
349 ProcessPacket(serialized);
350 }
351 }
352
TEST_P(QuicPacketCreatorTest,SerializeConnectionClose)353 TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
354 QuicConnectionCloseFrame frame(creator_.transport_version(), QUIC_NO_ERROR,
355 "error",
356 /*transport_close_frame_type=*/0);
357
358 QuicFrames frames;
359 frames.push_back(QuicFrame(&frame));
360 SerializedPacket serialized = SerializeAllFrames(frames);
361 EXPECT_EQ(ENCRYPTION_INITIAL, serialized.encryption_level);
362 ASSERT_EQ(QuicPacketNumber(1u), serialized.packet_number);
363 ASSERT_EQ(QuicPacketNumber(1u), creator_.packet_number());
364
365 InSequence s;
366 EXPECT_CALL(framer_visitor_, OnPacket());
367 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
368 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
369 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
370 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
371 EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
372 EXPECT_CALL(framer_visitor_, OnPacketComplete());
373
374 ProcessPacket(serialized);
375 }
376
TEST_P(QuicPacketCreatorTest,ConsumeCryptoDataToFillCurrentPacket)377 TEST_P(QuicPacketCreatorTest, ConsumeCryptoDataToFillCurrentPacket) {
378 std::string data = "crypto data";
379 QuicFrame frame;
380 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
381 ENCRYPTION_INITIAL, data.length(), 0,
382 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
383 EXPECT_EQ(frame.crypto_frame->data_length, data.length());
384 EXPECT_TRUE(creator_.HasPendingFrames());
385 }
386
TEST_P(QuicPacketCreatorTest,ConsumeDataToFillCurrentPacket)387 TEST_P(QuicPacketCreatorTest, ConsumeDataToFillCurrentPacket) {
388 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
389 QuicFrame frame;
390 MakeIOVector("test", &iov_);
391 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
392 client_framer_.transport_version(), Perspective::IS_CLIENT);
393 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
394 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
395 NOT_RETRANSMISSION, &frame));
396 size_t consumed = frame.stream_frame.data_length;
397 EXPECT_EQ(4u, consumed);
398 CheckStreamFrame(frame, stream_id, "test", 0u, false);
399 EXPECT_TRUE(creator_.HasPendingFrames());
400 }
401
TEST_P(QuicPacketCreatorTest,ConsumeDataFin)402 TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
403 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
404 QuicFrame frame;
405 MakeIOVector("test", &iov_);
406 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
407 client_framer_.transport_version(), Perspective::IS_CLIENT);
408 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
409 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false,
410 NOT_RETRANSMISSION, &frame));
411 size_t consumed = frame.stream_frame.data_length;
412 EXPECT_EQ(4u, consumed);
413 CheckStreamFrame(frame, stream_id, "test", 0u, true);
414 EXPECT_TRUE(creator_.HasPendingFrames());
415 }
416
TEST_P(QuicPacketCreatorTest,ConsumeDataFinOnly)417 TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
418 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
419 QuicFrame frame;
420 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
421 client_framer_.transport_version(), Perspective::IS_CLIENT);
422 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
423 stream_id, nullptr, 0u, 0u, 0u, 0u, true, false, NOT_RETRANSMISSION,
424 &frame));
425 size_t consumed = frame.stream_frame.data_length;
426 EXPECT_EQ(0u, consumed);
427 CheckStreamFrame(frame, stream_id, std::string(), 0u, true);
428 EXPECT_TRUE(creator_.HasPendingFrames());
429 }
430
TEST_P(QuicPacketCreatorTest,CreateAllFreeBytesForStreamFrames)431 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
432 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
433 const size_t overhead =
434 GetPacketHeaderOverhead(client_framer_.transport_version()) +
435 GetEncryptionOverhead();
436 for (size_t i = overhead + QuicPacketCreator::MinPlaintextPacketSize(
437 client_framer_.version());
438 i < overhead + 100; ++i) {
439 SCOPED_TRACE(i);
440 creator_.SetMaxPacketLength(i);
441 const bool should_have_room =
442 i >
443 overhead + GetStreamFrameOverhead(client_framer_.transport_version());
444 ASSERT_EQ(should_have_room,
445 creator_.HasRoomForStreamFrame(GetNthClientInitiatedStreamId(1),
446 kOffset, /* data_size=*/0xffff));
447 if (should_have_room) {
448 QuicFrame frame;
449 MakeIOVector("testdata", &iov_);
450 EXPECT_CALL(delegate_, OnSerializedPacket(_))
451 .WillRepeatedly(Invoke(
452 this, &QuicPacketCreatorTest::ClearSerializedPacketForTests));
453 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
454 GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u,
455 kOffset, false, false, NOT_RETRANSMISSION, &frame));
456 size_t bytes_consumed = frame.stream_frame.data_length;
457 EXPECT_LT(0u, bytes_consumed);
458 creator_.FlushCurrentPacket();
459 }
460 }
461 }
462
TEST_P(QuicPacketCreatorTest,StreamFrameConsumption)463 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
464 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
465 // Compute the total overhead for a single frame in packet.
466 const size_t overhead =
467 GetPacketHeaderOverhead(client_framer_.transport_version()) +
468 GetEncryptionOverhead() +
469 GetStreamFrameOverhead(client_framer_.transport_version());
470 size_t capacity = kDefaultMaxPacketSize - overhead;
471 // Now, test various sizes around this size.
472 for (int delta = -5; delta <= 5; ++delta) {
473 std::string data(capacity + delta, 'A');
474 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
475 QuicFrame frame;
476 MakeIOVector(data, &iov_);
477 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
478 GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset,
479 false, false, NOT_RETRANSMISSION, &frame));
480
481 // BytesFree() returns bytes available for the next frame, which will
482 // be two bytes smaller since the stream frame would need to be grown.
483 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
484 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
485 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
486 EXPECT_CALL(delegate_, OnSerializedPacket(_))
487 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
488 creator_.FlushCurrentPacket();
489 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
490 DeleteSerializedPacket();
491 }
492 }
493
TEST_P(QuicPacketCreatorTest,CryptoStreamFramePacketPadding)494 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
495 // This test serializes crypto payloads slightly larger than a packet, which
496 // Causes the multi-packet ClientHello check to fail.
497 SetQuicFlag(FLAGS_quic_enforce_single_packet_chlo, false);
498 // Compute the total overhead for a single frame in packet.
499 size_t overhead =
500 GetPacketHeaderOverhead(client_framer_.transport_version()) +
501 GetEncryptionOverhead();
502 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
503 overhead +=
504 QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxOutgoingPacketSize);
505 } else {
506 overhead += GetStreamFrameOverhead(client_framer_.transport_version());
507 }
508 ASSERT_GT(kMaxOutgoingPacketSize, overhead);
509 size_t capacity = kDefaultMaxPacketSize - overhead;
510 // Now, test various sizes around this size.
511 for (int delta = -5; delta <= 5; ++delta) {
512 SCOPED_TRACE(delta);
513 std::string data(capacity + delta, 'A');
514 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
515
516 QuicFrame frame;
517 MakeIOVector(data, &iov_);
518 EXPECT_CALL(delegate_, OnSerializedPacket(_))
519 .WillRepeatedly(
520 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
521 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
522 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
523 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
524 &iov_, 1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION,
525 &frame));
526 size_t bytes_consumed = frame.stream_frame.data_length;
527 EXPECT_LT(0u, bytes_consumed);
528 } else {
529 producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
530 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
531 ENCRYPTION_INITIAL, data.length(), kOffset,
532 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
533 size_t bytes_consumed = frame.crypto_frame->data_length;
534 EXPECT_LT(0u, bytes_consumed);
535 }
536 creator_.FlushCurrentPacket();
537 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
538 // If there is not enough space in the packet to fit a padding frame
539 // (1 byte) and to expand the stream frame (another 2 bytes) the packet
540 // will not be padded.
541 // Padding is skipped when we try to send coalesced packets.
542 if ((bytes_free < 3 &&
543 !QuicVersionUsesCryptoFrames(client_framer_.transport_version())) ||
544 client_framer_.version().CanSendCoalescedPackets()) {
545 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
546 serialized_packet_.encrypted_length);
547 } else {
548 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
549 }
550 DeleteSerializedPacket();
551 }
552 }
553
TEST_P(QuicPacketCreatorTest,NonCryptoStreamFramePacketNonPadding)554 TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
555 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
556 // Compute the total overhead for a single frame in packet.
557 const size_t overhead =
558 GetPacketHeaderOverhead(client_framer_.transport_version()) +
559 GetEncryptionOverhead() +
560 GetStreamFrameOverhead(client_framer_.transport_version());
561 ASSERT_GT(kDefaultMaxPacketSize, overhead);
562 size_t capacity = kDefaultMaxPacketSize - overhead;
563 // Now, test various sizes around this size.
564 for (int delta = -5; delta <= 5; ++delta) {
565 std::string data(capacity + delta, 'A');
566 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
567
568 QuicFrame frame;
569 MakeIOVector(data, &iov_);
570 EXPECT_CALL(delegate_, OnSerializedPacket(_))
571 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
572 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
573 GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset,
574 false, false, NOT_RETRANSMISSION, &frame));
575 size_t bytes_consumed = frame.stream_frame.data_length;
576 EXPECT_LT(0u, bytes_consumed);
577 creator_.FlushCurrentPacket();
578 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
579 if (bytes_free > 0) {
580 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
581 serialized_packet_.encrypted_length);
582 } else {
583 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
584 }
585 DeleteSerializedPacket();
586 }
587 }
588
TEST_P(QuicPacketCreatorTest,SerializeVersionNegotiationPacket)589 TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
590 QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
591 ParsedQuicVersionVector versions;
592 versions.push_back(test::QuicVersionMax());
593 const bool ietf_quic =
594 VersionHasIetfInvariantHeader(creator_.transport_version());
595 const bool has_length_prefix =
596 GetParam().version.HasLengthPrefixedConnectionIds();
597 std::unique_ptr<QuicEncryptedPacket> encrypted(
598 creator_.SerializeVersionNegotiationPacket(ietf_quic, has_length_prefix,
599 versions));
600
601 {
602 InSequence s;
603 EXPECT_CALL(framer_visitor_, OnPacket());
604 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
605 EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
606 }
607 QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_CLIENT);
608 client_framer_.ProcessPacket(*encrypted);
609 }
610
611 // Test that the path challenge connectivity probing packet is serialized
612 // correctly as a padded PATH CHALLENGE packet.
TEST_P(QuicPacketCreatorTest,BuildPathChallengePacket)613 TEST_P(QuicPacketCreatorTest, BuildPathChallengePacket) {
614 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
615 // This frame is only for IETF QUIC.
616 return;
617 }
618
619 QuicPacketHeader header;
620 header.destination_connection_id = CreateTestConnectionId();
621 header.reset_flag = false;
622 header.version_flag = false;
623 header.packet_number = kPacketNumber;
624 QuicPathFrameBuffer payload;
625
626 // clang-format off
627 unsigned char packet[] = {
628 // type (short header, 4 byte packet number)
629 0x43,
630 // connection_id
631 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
632 // packet number
633 0x12, 0x34, 0x56, 0x78,
634
635 // Path Challenge Frame type (IETF_PATH_CHALLENGE)
636 0x1a,
637 // 8 "random" bytes, MockRandom makes lots of r's
638 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r',
639 // frame type (padding frame)
640 0x00,
641 0x00, 0x00, 0x00, 0x00
642 };
643 // clang-format on
644
645 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
646 MockRandom randomizer;
647
648 size_t length = creator_.BuildPaddedPathChallengePacket(
649 header, buffer.get(), QUICHE_ARRAYSIZE(packet), &payload, &randomizer,
650 ENCRYPTION_INITIAL);
651 EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
652
653 // Payload has the random bytes that were generated. Copy them into packet,
654 // above, before checking that the generated packet is correct.
655 EXPECT_EQ(kQuicPathFrameBufferSize, payload.size());
656
657 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
658 header);
659
660 quiche::test::CompareCharArraysWithHexError(
661 "constructed packet", data.data(), data.length(),
662 reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
663 }
664
TEST_P(QuicPacketCreatorTest,BuildConnectivityProbingPacket)665 TEST_P(QuicPacketCreatorTest, BuildConnectivityProbingPacket) {
666 QuicPacketHeader header;
667 header.destination_connection_id = CreateTestConnectionId();
668 header.reset_flag = false;
669 header.version_flag = false;
670 header.packet_number = kPacketNumber;
671
672 // clang-format off
673 unsigned char packet[] = {
674 // public flags (8 byte connection_id)
675 0x2C,
676 // connection_id
677 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
678 // packet number
679 0x12, 0x34, 0x56, 0x78,
680
681 // frame type (ping frame)
682 0x07,
683 // frame type (padding frame)
684 0x00,
685 0x00, 0x00, 0x00, 0x00
686 };
687
688 unsigned char packet46[] = {
689 // type (short header, 4 byte packet number)
690 0x43,
691 // connection_id
692 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
693 // packet number
694 0x12, 0x34, 0x56, 0x78,
695
696 // frame type
697 0x07,
698 // frame type (padding frame)
699 0x00,
700 0x00, 0x00, 0x00, 0x00
701 };
702
703 unsigned char packet99[] = {
704 // type (short header, 4 byte packet number)
705 0x43,
706 // connection_id
707 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
708 // packet number
709 0x12, 0x34, 0x56, 0x78,
710
711 // frame type (IETF_PING frame)
712 0x01,
713 // frame type (padding frame)
714 0x00,
715 0x00, 0x00, 0x00, 0x00
716 };
717 // clang-format on
718
719 unsigned char* p = packet;
720 size_t packet_size = QUICHE_ARRAYSIZE(packet);
721 if (VersionHasIetfQuicFrames(creator_.transport_version())) {
722 p = packet99;
723 packet_size = QUICHE_ARRAYSIZE(packet99);
724 } else if (creator_.transport_version() >= QUIC_VERSION_46) {
725 p = packet46;
726 packet_size = QUICHE_ARRAYSIZE(packet46);
727 }
728
729 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
730
731 size_t length = creator_.BuildConnectivityProbingPacket(
732 header, buffer.get(), packet_size, ENCRYPTION_INITIAL);
733
734 EXPECT_NE(0u, length);
735 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
736 header);
737
738 quiche::test::CompareCharArraysWithHexError(
739 "constructed packet", data.data(), data.length(),
740 reinterpret_cast<char*>(p), packet_size);
741 }
742
743 // Several tests that the path response connectivity probing packet is
744 // serialized correctly as either a padded and unpadded PATH RESPONSE
745 // packet. Also generates packets with 1 and 3 PATH_RESPONSES in them to
746 // exercised the single- and multiple- payload cases.
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket1ResponseUnpadded)747 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponseUnpadded) {
748 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
749 // This frame is only for IETF QUIC.
750 return;
751 }
752
753 QuicPacketHeader header;
754 header.destination_connection_id = CreateTestConnectionId();
755 header.reset_flag = false;
756 header.version_flag = false;
757 header.packet_number = kPacketNumber;
758 QuicPathFrameBuffer payload0 = {
759 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
760
761 // Build 1 PATH RESPONSE, not padded
762 // clang-format off
763 unsigned char packet[] = {
764 // type (short header, 4 byte packet number)
765 0x43,
766 // connection_id
767 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
768 // packet number
769 0x12, 0x34, 0x56, 0x78,
770
771 // Path Response Frame type (IETF_PATH_RESPONSE)
772 0x1b,
773 // 8 "random" bytes
774 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
775 };
776 // clang-format on
777 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
778 QuicCircularDeque<QuicPathFrameBuffer> payloads;
779 payloads.push_back(payload0);
780 size_t length = creator_.BuildPathResponsePacket(
781 header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
782 /*is_padded=*/false, ENCRYPTION_INITIAL);
783 EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
784 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
785 header);
786
787 quiche::test::CompareCharArraysWithHexError(
788 "constructed packet", data.data(), data.length(),
789 reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
790 }
791
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket1ResponsePadded)792 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket1ResponsePadded) {
793 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
794 // This frame is only for IETF QUIC.
795 return;
796 }
797
798 QuicPacketHeader header;
799 header.destination_connection_id = CreateTestConnectionId();
800 header.reset_flag = false;
801 header.version_flag = false;
802 header.packet_number = kPacketNumber;
803 QuicPathFrameBuffer payload0 = {
804 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
805
806 // Build 1 PATH RESPONSE, padded
807 // clang-format off
808 unsigned char packet[] = {
809 // type (short header, 4 byte packet number)
810 0x43,
811 // connection_id
812 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
813 // packet number
814 0x12, 0x34, 0x56, 0x78,
815
816 // Path Response Frame type (IETF_PATH_RESPONSE)
817 0x1b,
818 // 8 "random" bytes
819 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
820 // Padding type and pad
821 0x00, 0x00, 0x00, 0x00, 0x00
822 };
823 // clang-format on
824 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
825 QuicCircularDeque<QuicPathFrameBuffer> payloads;
826 payloads.push_back(payload0);
827 size_t length = creator_.BuildPathResponsePacket(
828 header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
829 /*is_padded=*/true, ENCRYPTION_INITIAL);
830 EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
831 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
832 header);
833
834 quiche::test::CompareCharArraysWithHexError(
835 "constructed packet", data.data(), data.length(),
836 reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
837 }
838
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket3ResponsesUnpadded)839 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesUnpadded) {
840 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
841 // This frame is only for IETF QUIC.
842 return;
843 }
844
845 QuicPacketHeader header;
846 header.destination_connection_id = CreateTestConnectionId();
847 header.reset_flag = false;
848 header.version_flag = false;
849 header.packet_number = kPacketNumber;
850 QuicPathFrameBuffer payload0 = {
851 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
852 QuicPathFrameBuffer payload1 = {
853 {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}};
854 QuicPathFrameBuffer payload2 = {
855 {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28}};
856
857 // Build one packet with 3 PATH RESPONSES, no padding
858 // clang-format off
859 unsigned char packet[] = {
860 // type (short header, 4 byte packet number)
861 0x43,
862 // connection_id
863 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
864 // packet number
865 0x12, 0x34, 0x56, 0x78,
866
867 // 3 path response frames (IETF_PATH_RESPONSE type byte and payload)
868 0x1b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
869 0x1b, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
870 0x1b, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
871 };
872 // clang-format on
873
874 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
875 QuicCircularDeque<QuicPathFrameBuffer> payloads;
876 payloads.push_back(payload0);
877 payloads.push_back(payload1);
878 payloads.push_back(payload2);
879 size_t length = creator_.BuildPathResponsePacket(
880 header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
881 /*is_padded=*/false, ENCRYPTION_INITIAL);
882 EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
883 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
884 header);
885
886 quiche::test::CompareCharArraysWithHexError(
887 "constructed packet", data.data(), data.length(),
888 reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
889 }
890
TEST_P(QuicPacketCreatorTest,BuildPathResponsePacket3ResponsesPadded)891 TEST_P(QuicPacketCreatorTest, BuildPathResponsePacket3ResponsesPadded) {
892 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
893 // This frame is only for IETF QUIC.
894 return;
895 }
896
897 QuicPacketHeader header;
898 header.destination_connection_id = CreateTestConnectionId();
899 header.reset_flag = false;
900 header.version_flag = false;
901 header.packet_number = kPacketNumber;
902 QuicPathFrameBuffer payload0 = {
903 {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}};
904 QuicPathFrameBuffer payload1 = {
905 {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}};
906 QuicPathFrameBuffer payload2 = {
907 {0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28}};
908
909 // Build one packet with 3 PATH RESPONSES, with padding
910 // clang-format off
911 unsigned char packet[] = {
912 // type (short header, 4 byte packet number)
913 0x43,
914 // connection_id
915 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10,
916 // packet number
917 0x12, 0x34, 0x56, 0x78,
918
919 // 3 path response frames (IETF_PATH_RESPONSE byte and payload)
920 0x1b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
921 0x1b, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
922 0x1b, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
923 // Padding
924 0x00, 0x00, 0x00, 0x00, 0x00
925 };
926 // clang-format on
927
928 std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
929 QuicCircularDeque<QuicPathFrameBuffer> payloads;
930 payloads.push_back(payload0);
931 payloads.push_back(payload1);
932 payloads.push_back(payload2);
933 size_t length = creator_.BuildPathResponsePacket(
934 header, buffer.get(), QUICHE_ARRAYSIZE(packet), payloads,
935 /*is_padded=*/true, ENCRYPTION_INITIAL);
936 EXPECT_EQ(length, QUICHE_ARRAYSIZE(packet));
937 QuicPacket data(creator_.transport_version(), buffer.release(), length, true,
938 header);
939
940 quiche::test::CompareCharArraysWithHexError(
941 "constructed packet", data.data(), data.length(),
942 reinterpret_cast<char*>(packet), QUICHE_ARRAYSIZE(packet));
943 }
944
TEST_P(QuicPacketCreatorTest,SerializeConnectivityProbingPacket)945 TEST_P(QuicPacketCreatorTest, SerializeConnectivityProbingPacket) {
946 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
947 EncryptionLevel level = static_cast<EncryptionLevel>(i);
948
949 creator_.set_encryption_level(level);
950
951 OwningSerializedPacketPointer encrypted;
952 if (VersionHasIetfQuicFrames(creator_.transport_version())) {
953 QuicPathFrameBuffer payload = {
954 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
955 encrypted =
956 creator_.SerializePathChallengeConnectivityProbingPacket(&payload);
957 } else {
958 encrypted = creator_.SerializeConnectivityProbingPacket();
959 }
960 {
961 InSequence s;
962 EXPECT_CALL(framer_visitor_, OnPacket());
963 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
964 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
965 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
966 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
967 if (VersionHasIetfQuicFrames(creator_.transport_version())) {
968 EXPECT_CALL(framer_visitor_, OnPathChallengeFrame(_));
969 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
970 } else {
971 EXPECT_CALL(framer_visitor_, OnPingFrame(_));
972 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
973 }
974 EXPECT_CALL(framer_visitor_, OnPacketComplete());
975 }
976 // QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
977 server_framer_.ProcessPacket(QuicEncryptedPacket(
978 encrypted->encrypted_buffer, encrypted->encrypted_length));
979 }
980 }
981
TEST_P(QuicPacketCreatorTest,SerializePathChallengeProbePacket)982 TEST_P(QuicPacketCreatorTest, SerializePathChallengeProbePacket) {
983 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
984 return;
985 }
986 QuicPathFrameBuffer payload = {
987 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
988
989 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
990 EncryptionLevel level = static_cast<EncryptionLevel>(i);
991
992 creator_.set_encryption_level(level);
993
994 OwningSerializedPacketPointer encrypted(
995 creator_.SerializePathChallengeConnectivityProbingPacket(&payload));
996 {
997 InSequence s;
998 EXPECT_CALL(framer_visitor_, OnPacket());
999 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1000 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1001 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1002 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1003 EXPECT_CALL(framer_visitor_, OnPathChallengeFrame(_));
1004 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1005 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1006 }
1007 // QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER);
1008 server_framer_.ProcessPacket(QuicEncryptedPacket(
1009 encrypted->encrypted_buffer, encrypted->encrypted_length));
1010 }
1011 }
1012
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket1PayloadPadded)1013 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket1PayloadPadded) {
1014 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1015 return;
1016 }
1017 QuicPathFrameBuffer payload0 = {
1018 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1019
1020 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1021 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1022 creator_.set_encryption_level(level);
1023
1024 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1025 payloads.push_back(payload0);
1026
1027 OwningSerializedPacketPointer encrypted(
1028 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1029 true));
1030 {
1031 InSequence s;
1032 EXPECT_CALL(framer_visitor_, OnPacket());
1033 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1034 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1035 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1036 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1037 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_));
1038 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1039 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1040 }
1041 server_framer_.ProcessPacket(QuicEncryptedPacket(
1042 encrypted->encrypted_buffer, encrypted->encrypted_length));
1043 }
1044 }
1045
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket1PayloadUnPadded)1046 TEST_P(QuicPacketCreatorTest,
1047 SerializePathResponseProbePacket1PayloadUnPadded) {
1048 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1049 return;
1050 }
1051 QuicPathFrameBuffer payload0 = {
1052 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1053
1054 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1055 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1056 creator_.set_encryption_level(level);
1057
1058 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1059 payloads.push_back(payload0);
1060
1061 OwningSerializedPacketPointer encrypted(
1062 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1063 false));
1064 {
1065 InSequence s;
1066 EXPECT_CALL(framer_visitor_, OnPacket());
1067 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1068 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1069 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1070 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1071 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_));
1072 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1073 }
1074 server_framer_.ProcessPacket(QuicEncryptedPacket(
1075 encrypted->encrypted_buffer, encrypted->encrypted_length));
1076 }
1077 }
1078
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket2PayloadsPadded)1079 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket2PayloadsPadded) {
1080 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1081 return;
1082 }
1083 QuicPathFrameBuffer payload0 = {
1084 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1085 QuicPathFrameBuffer payload1 = {
1086 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1087
1088 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1089 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1090 creator_.set_encryption_level(level);
1091
1092 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1093 payloads.push_back(payload0);
1094 payloads.push_back(payload1);
1095
1096 OwningSerializedPacketPointer encrypted(
1097 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1098 true));
1099 {
1100 InSequence s;
1101 EXPECT_CALL(framer_visitor_, OnPacket());
1102 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1103 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1104 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1105 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1106 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(2);
1107 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1108 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1109 }
1110 server_framer_.ProcessPacket(QuicEncryptedPacket(
1111 encrypted->encrypted_buffer, encrypted->encrypted_length));
1112 }
1113 }
1114
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket2PayloadsUnPadded)1115 TEST_P(QuicPacketCreatorTest,
1116 SerializePathResponseProbePacket2PayloadsUnPadded) {
1117 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1118 return;
1119 }
1120 QuicPathFrameBuffer payload0 = {
1121 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1122 QuicPathFrameBuffer payload1 = {
1123 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1124
1125 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1126 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1127 creator_.set_encryption_level(level);
1128
1129 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1130 payloads.push_back(payload0);
1131 payloads.push_back(payload1);
1132
1133 OwningSerializedPacketPointer encrypted(
1134 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1135 false));
1136 {
1137 InSequence s;
1138 EXPECT_CALL(framer_visitor_, OnPacket());
1139 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1140 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1141 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1142 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1143 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(2);
1144 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1145 }
1146 server_framer_.ProcessPacket(QuicEncryptedPacket(
1147 encrypted->encrypted_buffer, encrypted->encrypted_length));
1148 }
1149 }
1150
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket3PayloadsPadded)1151 TEST_P(QuicPacketCreatorTest, SerializePathResponseProbePacket3PayloadsPadded) {
1152 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1153 return;
1154 }
1155 QuicPathFrameBuffer payload0 = {
1156 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1157 QuicPathFrameBuffer payload1 = {
1158 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1159 QuicPathFrameBuffer payload2 = {
1160 {0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde, 0xad}};
1161
1162 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1163 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1164 creator_.set_encryption_level(level);
1165
1166 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1167 payloads.push_back(payload0);
1168 payloads.push_back(payload1);
1169 payloads.push_back(payload2);
1170
1171 OwningSerializedPacketPointer encrypted(
1172 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1173 true));
1174 {
1175 InSequence s;
1176 EXPECT_CALL(framer_visitor_, OnPacket());
1177 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1178 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1179 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1180 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1181 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(3);
1182 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1183 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1184 }
1185 server_framer_.ProcessPacket(QuicEncryptedPacket(
1186 encrypted->encrypted_buffer, encrypted->encrypted_length));
1187 }
1188 }
1189
TEST_P(QuicPacketCreatorTest,SerializePathResponseProbePacket3PayloadsUnpadded)1190 TEST_P(QuicPacketCreatorTest,
1191 SerializePathResponseProbePacket3PayloadsUnpadded) {
1192 if (!VersionHasIetfQuicFrames(creator_.transport_version())) {
1193 return;
1194 }
1195 QuicPathFrameBuffer payload0 = {
1196 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee}};
1197 QuicPathFrameBuffer payload1 = {
1198 {0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde}};
1199 QuicPathFrameBuffer payload2 = {
1200 {0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xee, 0xde, 0xad}};
1201
1202 for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
1203 EncryptionLevel level = static_cast<EncryptionLevel>(i);
1204 creator_.set_encryption_level(level);
1205
1206 QuicCircularDeque<QuicPathFrameBuffer> payloads;
1207 payloads.push_back(payload0);
1208 payloads.push_back(payload1);
1209 payloads.push_back(payload2);
1210
1211 OwningSerializedPacketPointer encrypted(
1212 creator_.SerializePathResponseConnectivityProbingPacket(payloads,
1213 false));
1214 InSequence s;
1215 EXPECT_CALL(framer_visitor_, OnPacket());
1216 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1217 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1218 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1219 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1220 EXPECT_CALL(framer_visitor_, OnPathResponseFrame(_)).Times(3);
1221 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1222
1223 server_framer_.ProcessPacket(QuicEncryptedPacket(
1224 encrypted->encrypted_buffer, encrypted->encrypted_length));
1225 }
1226 }
1227
TEST_P(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthLeastAwaiting)1228 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
1229 if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
1230 !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1231 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1232 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1233 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1234 } else {
1235 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1236 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1237 }
1238
1239 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64);
1240 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1241 10000 / kDefaultMaxPacketSize);
1242 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1243 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1244
1245 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256);
1246 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1247 10000 / kDefaultMaxPacketSize);
1248 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1249 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1250
1251 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 * 256);
1252 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1253 10000 / kDefaultMaxPacketSize);
1254 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1255 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1256
1257 QuicPacketCreatorPeer::SetPacketNumber(&creator_,
1258 UINT64_C(64) * 256 * 256 * 256 * 256);
1259 creator_.UpdatePacketNumberLength(QuicPacketNumber(2),
1260 10000 / kDefaultMaxPacketSize);
1261 EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
1262 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1263 }
1264
TEST_P(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthCwnd)1265 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthCwnd) {
1266 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
1267 if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
1268 !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1269 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1270 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1271 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1272 } else {
1273 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1274 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1275 }
1276
1277 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1278 10000 / kDefaultMaxPacketSize);
1279 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1280 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1281
1282 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1283 10000 * 256 / kDefaultMaxPacketSize);
1284 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1285 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1286
1287 creator_.UpdatePacketNumberLength(QuicPacketNumber(1),
1288 10000 * 256 * 256 / kDefaultMaxPacketSize);
1289 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1290 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1291
1292 creator_.UpdatePacketNumberLength(
1293 QuicPacketNumber(1),
1294 UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize);
1295 EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
1296 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1297 }
1298
TEST_P(QuicPacketCreatorTest,SkipNPacketNumbers)1299 TEST_P(QuicPacketCreatorTest, SkipNPacketNumbers) {
1300 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1);
1301 if (VersionHasIetfInvariantHeader(creator_.transport_version()) &&
1302 !GetParam().version.SendsVariableLengthPacketNumberInLongHeader()) {
1303 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1304 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1305 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1306 } else {
1307 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1308 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1309 }
1310 creator_.SkipNPacketNumbers(63, QuicPacketNumber(2),
1311 10000 / kDefaultMaxPacketSize);
1312 EXPECT_EQ(QuicPacketNumber(64), creator_.packet_number());
1313 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
1314 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1315
1316 creator_.SkipNPacketNumbers(64 * 255, QuicPacketNumber(2),
1317 10000 / kDefaultMaxPacketSize);
1318 EXPECT_EQ(QuicPacketNumber(64 * 256), creator_.packet_number());
1319 EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
1320 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1321
1322 creator_.SkipNPacketNumbers(64 * 256 * 255, QuicPacketNumber(2),
1323 10000 / kDefaultMaxPacketSize);
1324 EXPECT_EQ(QuicPacketNumber(64 * 256 * 256), creator_.packet_number());
1325 EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
1326 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
1327 }
1328
TEST_P(QuicPacketCreatorTest,SerializeFrame)1329 TEST_P(QuicPacketCreatorTest, SerializeFrame) {
1330 if (!GetParam().version_serialization) {
1331 creator_.StopSendingVersion();
1332 }
1333 std::string data("test data");
1334 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1335 QuicStreamFrame stream_frame(
1336 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1337 /*fin=*/false, 0u, quiche::QuicheStringPiece());
1338 frames_.push_back(QuicFrame(stream_frame));
1339 } else {
1340 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1341 frames_.push_back(
1342 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1343 }
1344 SerializedPacket serialized = SerializeAllFrames(frames_);
1345
1346 QuicPacketHeader header;
1347 {
1348 InSequence s;
1349 EXPECT_CALL(framer_visitor_, OnPacket());
1350 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1351 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1352 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1353 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
1354 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
1355 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1356 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
1357 } else {
1358 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1359 }
1360 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1361 }
1362 ProcessPacket(serialized);
1363 EXPECT_EQ(GetParam().version_serialization, header.version_flag);
1364 DeleteFrames(&frames_);
1365 }
1366
TEST_P(QuicPacketCreatorTest,SerializeFrameShortData)1367 TEST_P(QuicPacketCreatorTest, SerializeFrameShortData) {
1368 if (!GetParam().version_serialization) {
1369 creator_.StopSendingVersion();
1370 }
1371 std::string data("a");
1372 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1373 QuicStreamFrame stream_frame(
1374 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1375 /*fin=*/false, 0u, quiche::QuicheStringPiece());
1376 frames_.push_back(QuicFrame(stream_frame));
1377 } else {
1378 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1379 frames_.push_back(
1380 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1381 }
1382 SerializedPacket serialized = SerializeAllFrames(frames_);
1383
1384 QuicPacketHeader header;
1385 {
1386 InSequence s;
1387 EXPECT_CALL(framer_visitor_, OnPacket());
1388 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1389 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1390 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1391 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
1392 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
1393 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1394 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
1395 } else {
1396 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1397 }
1398 if (client_framer_.version().HasHeaderProtection()) {
1399 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1400 }
1401 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1402 }
1403 ProcessPacket(serialized);
1404 EXPECT_EQ(GetParam().version_serialization, header.version_flag);
1405 DeleteFrames(&frames_);
1406 }
1407
TEST_P(QuicPacketCreatorTest,ConsumeDataLargerThanOneStreamFrame)1408 TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) {
1409 if (!GetParam().version_serialization) {
1410 creator_.StopSendingVersion();
1411 }
1412 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1413 // A string larger than fits into a frame.
1414 QuicFrame frame;
1415 size_t payload_length = creator_.max_packet_length();
1416 const std::string too_long_payload(payload_length, 'a');
1417 MakeIOVector(too_long_payload, &iov_);
1418 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1419 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1420 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1421 client_framer_.transport_version(), Perspective::IS_CLIENT);
1422 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1423 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false,
1424 NOT_RETRANSMISSION, &frame));
1425 size_t consumed = frame.stream_frame.data_length;
1426 // The entire payload could not be consumed.
1427 EXPECT_GT(payload_length, consumed);
1428 creator_.FlushCurrentPacket();
1429 DeleteSerializedPacket();
1430 }
1431
TEST_P(QuicPacketCreatorTest,AddFrameAndFlush)1432 TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) {
1433 if (!GetParam().version_serialization) {
1434 creator_.StopSendingVersion();
1435 }
1436 const size_t max_plaintext_size =
1437 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
1438 EXPECT_FALSE(creator_.HasPendingFrames());
1439 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1440 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1441 client_framer_.transport_version(), Perspective::IS_CLIENT);
1442 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1443 stream_id =
1444 QuicUtils::GetCryptoStreamId(client_framer_.transport_version());
1445 }
1446 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1447 EXPECT_EQ(max_plaintext_size -
1448 GetPacketHeaderSize(
1449 client_framer_.transport_version(),
1450 creator_.GetDestinationConnectionIdLength(),
1451 creator_.GetSourceConnectionIdLength(),
1452 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
1453 !kIncludeDiversificationNonce,
1454 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
1455 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
1456 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
1457 creator_.BytesFree());
1458 StrictMock<MockDebugDelegate> debug;
1459 creator_.set_debug_delegate(&debug);
1460
1461 // Add a variety of frame types and then a padding frame.
1462 QuicAckFrame ack_frame(InitAckFrame(10u));
1463 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1464 EXPECT_TRUE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
1465 EXPECT_TRUE(creator_.HasPendingFrames());
1466 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1467
1468 QuicFrame frame;
1469 MakeIOVector("test", &iov_);
1470 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1471 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1472 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
1473 NOT_RETRANSMISSION, &frame));
1474 size_t consumed = frame.stream_frame.data_length;
1475 EXPECT_EQ(4u, consumed);
1476 EXPECT_TRUE(creator_.HasPendingFrames());
1477 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id));
1478
1479 QuicPaddingFrame padding_frame;
1480 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1481 EXPECT_TRUE(creator_.AddFrame(QuicFrame(padding_frame), NOT_RETRANSMISSION));
1482 EXPECT_TRUE(creator_.HasPendingFrames());
1483 EXPECT_EQ(0u, creator_.BytesFree());
1484
1485 // Packet is full. Creator will flush.
1486 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1487 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1488 EXPECT_FALSE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
1489
1490 // Ensure the packet is successfully created.
1491 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
1492 ASSERT_FALSE(serialized_packet_.retransmittable_frames.empty());
1493 const QuicFrames& retransmittable = serialized_packet_.retransmittable_frames;
1494 ASSERT_EQ(1u, retransmittable.size());
1495 EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
1496 EXPECT_TRUE(serialized_packet_.has_ack);
1497 EXPECT_EQ(QuicPacketNumber(10u), serialized_packet_.largest_acked);
1498 DeleteSerializedPacket();
1499
1500 EXPECT_FALSE(creator_.HasPendingFrames());
1501 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id));
1502 EXPECT_EQ(max_plaintext_size -
1503 GetPacketHeaderSize(
1504 client_framer_.transport_version(),
1505 creator_.GetDestinationConnectionIdLength(),
1506 creator_.GetSourceConnectionIdLength(),
1507 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
1508 !kIncludeDiversificationNonce,
1509 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
1510 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
1511 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
1512 creator_.BytesFree());
1513 }
1514
TEST_P(QuicPacketCreatorTest,SerializeAndSendStreamFrame)1515 TEST_P(QuicPacketCreatorTest, SerializeAndSendStreamFrame) {
1516 if (!GetParam().version_serialization) {
1517 creator_.StopSendingVersion();
1518 }
1519 EXPECT_FALSE(creator_.HasPendingFrames());
1520
1521 MakeIOVector("test", &iov_);
1522 producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), &iov_, 1u, 0u,
1523 iov_.iov_len);
1524 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1525 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1526 size_t num_bytes_consumed;
1527 StrictMock<MockDebugDelegate> debug;
1528 creator_.set_debug_delegate(&debug);
1529 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
1530 creator_.CreateAndSerializeStreamFrame(
1531 GetNthClientInitiatedStreamId(0), iov_.iov_len, 0, 0, true,
1532 NOT_RETRANSMISSION, &num_bytes_consumed);
1533 EXPECT_EQ(4u, num_bytes_consumed);
1534
1535 // Ensure the packet is successfully created.
1536 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
1537 ASSERT_FALSE(serialized_packet_.retransmittable_frames.empty());
1538 const QuicFrames& retransmittable = serialized_packet_.retransmittable_frames;
1539 ASSERT_EQ(1u, retransmittable.size());
1540 EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
1541 DeleteSerializedPacket();
1542
1543 EXPECT_FALSE(creator_.HasPendingFrames());
1544 }
1545
TEST_P(QuicPacketCreatorTest,SerializeStreamFrameWithPadding)1546 TEST_P(QuicPacketCreatorTest, SerializeStreamFrameWithPadding) {
1547 // Regression test to check that CreateAndSerializeStreamFrame uses a
1548 // correctly formatted stream frame header when appending padding.
1549
1550 if (!GetParam().version_serialization) {
1551 creator_.StopSendingVersion();
1552 }
1553 EXPECT_FALSE(creator_.HasPendingFrames());
1554
1555 // Send one byte of stream data.
1556 MakeIOVector("a", &iov_);
1557 producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), &iov_, 1u, 0u,
1558 iov_.iov_len);
1559 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1560 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1561 size_t num_bytes_consumed;
1562 creator_.CreateAndSerializeStreamFrame(
1563 GetNthClientInitiatedStreamId(0), iov_.iov_len, 0, 0, true,
1564 NOT_RETRANSMISSION, &num_bytes_consumed);
1565 EXPECT_EQ(1u, num_bytes_consumed);
1566
1567 // Check that a packet is created.
1568 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
1569 ASSERT_FALSE(serialized_packet_.retransmittable_frames.empty());
1570 {
1571 InSequence s;
1572 EXPECT_CALL(framer_visitor_, OnPacket());
1573 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1574 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1575 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1576 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1577 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1578 if (client_framer_.version().HasHeaderProtection()) {
1579 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1580 }
1581 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1582 }
1583 ProcessPacket(serialized_packet_);
1584 }
1585
TEST_P(QuicPacketCreatorTest,AddUnencryptedStreamDataClosesConnection)1586 TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
1587 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1588 if (!IsDefaultTestConfiguration()) {
1589 return;
1590 }
1591
1592 creator_.set_encryption_level(ENCRYPTION_INITIAL);
1593 EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
1594 QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
1595 /*fin=*/false, 0u, quiche::QuicheStringPiece());
1596 EXPECT_QUIC_BUG(
1597 creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
1598 "Cannot send stream data with level: ENCRYPTION_INITIAL");
1599 }
1600
TEST_P(QuicPacketCreatorTest,SendStreamDataWithEncryptionHandshake)1601 TEST_P(QuicPacketCreatorTest, SendStreamDataWithEncryptionHandshake) {
1602 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1603 if (!IsDefaultTestConfiguration()) {
1604 return;
1605 }
1606
1607 creator_.set_encryption_level(ENCRYPTION_HANDSHAKE);
1608 EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
1609 QuicStreamFrame stream_frame(GetNthClientInitiatedStreamId(0),
1610 /*fin=*/false, 0u, quiche::QuicheStringPiece());
1611 EXPECT_QUIC_BUG(
1612 creator_.AddFrame(QuicFrame(stream_frame), NOT_RETRANSMISSION),
1613 "Cannot send stream data with level: ENCRYPTION_HANDSHAKE");
1614 }
1615
TEST_P(QuicPacketCreatorTest,ChloTooLarge)1616 TEST_P(QuicPacketCreatorTest, ChloTooLarge) {
1617 // EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
1618 if (!IsDefaultTestConfiguration()) {
1619 return;
1620 }
1621
1622 // This test only matters when the crypto handshake is sent in stream frames.
1623 // TODO(b/128596274): Re-enable when this check is supported for CRYPTO
1624 // frames.
1625 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1626 return;
1627 }
1628
1629 CryptoHandshakeMessage message;
1630 message.set_tag(kCHLO);
1631 message.set_minimum_size(kMaxOutgoingPacketSize);
1632 CryptoFramer framer;
1633 std::unique_ptr<QuicData> message_data;
1634 message_data = framer.ConstructHandshakeMessage(message);
1635
1636 struct iovec iov;
1637 MakeIOVector(
1638 quiche::QuicheStringPiece(message_data->data(), message_data->length()),
1639 &iov);
1640 QuicFrame frame;
1641 EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _));
1642 EXPECT_QUIC_BUG(
1643 creator_.ConsumeDataToFillCurrentPacket(
1644 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1645 &iov, 1u, iov.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION,
1646 &frame),
1647 "Client hello won't fit in a single packet.");
1648 }
1649
TEST_P(QuicPacketCreatorTest,PendingPadding)1650 TEST_P(QuicPacketCreatorTest, PendingPadding) {
1651 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1652 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes * 10);
1653 EXPECT_EQ(kMaxNumRandomPaddingBytes * 10, creator_.pending_padding_bytes());
1654
1655 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1656 .WillRepeatedly(
1657 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1658 // Flush all paddings.
1659 while (creator_.pending_padding_bytes() > 0) {
1660 creator_.FlushCurrentPacket();
1661 {
1662 InSequence s;
1663 EXPECT_CALL(framer_visitor_, OnPacket());
1664 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1665 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1666 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1667 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
1668 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1669 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1670 }
1671 // Packet only contains padding.
1672 ProcessPacket(serialized_packet_);
1673 }
1674 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1675 }
1676
TEST_P(QuicPacketCreatorTest,FullPaddingDoesNotConsumePendingPadding)1677 TEST_P(QuicPacketCreatorTest, FullPaddingDoesNotConsumePendingPadding) {
1678 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1679 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
1680 QuicFrame frame;
1681 MakeIOVector("test", &iov_);
1682 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1683 client_framer_.transport_version(), Perspective::IS_CLIENT);
1684 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1685 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
1686 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
1687 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1688 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1689 creator_.FlushCurrentPacket();
1690 EXPECT_EQ(kMaxNumRandomPaddingBytes, creator_.pending_padding_bytes());
1691 }
1692
TEST_P(QuicPacketCreatorTest,ConsumeDataAndRandomPadding)1693 TEST_P(QuicPacketCreatorTest, ConsumeDataAndRandomPadding) {
1694 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1695 const QuicByteCount kStreamFramePayloadSize = 100u;
1696 // Set the packet size be enough for one stream frame with 0 stream offset +
1697 // 1.
1698 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1699 client_framer_.transport_version(), Perspective::IS_CLIENT);
1700 size_t length =
1701 GetPacketHeaderOverhead(client_framer_.transport_version()) +
1702 GetEncryptionOverhead() +
1703 QuicFramer::GetMinStreamFrameSize(
1704 client_framer_.transport_version(), stream_id, 0,
1705 /*last_frame_in_packet=*/false, kStreamFramePayloadSize + 1) +
1706 kStreamFramePayloadSize + 1;
1707 creator_.SetMaxPacketLength(length);
1708 creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
1709 QuicByteCount pending_padding_bytes = creator_.pending_padding_bytes();
1710 QuicFrame frame;
1711 char buf[kStreamFramePayloadSize + 1] = {};
1712 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1713 .WillRepeatedly(
1714 Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1715 // Send stream frame of size kStreamFramePayloadSize.
1716 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
1717 creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
1718 0u, 0u, false, false,
1719 NOT_RETRANSMISSION, &frame);
1720 creator_.FlushCurrentPacket();
1721 // 1 byte padding is sent.
1722 EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
1723 // Send stream frame of size kStreamFramePayloadSize + 1.
1724 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize + 1),
1725 &iov_);
1726 creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
1727 0u, kStreamFramePayloadSize, false,
1728 false, NOT_RETRANSMISSION, &frame);
1729 // No padding is sent.
1730 creator_.FlushCurrentPacket();
1731 EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
1732 // Flush all paddings.
1733 while (creator_.pending_padding_bytes() > 0) {
1734 creator_.FlushCurrentPacket();
1735 }
1736 EXPECT_EQ(0u, creator_.pending_padding_bytes());
1737 }
1738
TEST_P(QuicPacketCreatorTest,FlushWithExternalBuffer)1739 TEST_P(QuicPacketCreatorTest, FlushWithExternalBuffer) {
1740 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1741 char external_buffer[kMaxOutgoingPacketSize];
1742 char* expected_buffer = external_buffer;
1743 EXPECT_CALL(delegate_, GetPacketBuffer()).WillOnce(Return(expected_buffer));
1744
1745 QuicFrame frame;
1746 MakeIOVector("test", &iov_);
1747 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1748 client_framer_.transport_version(), Perspective::IS_CLIENT);
1749 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1750 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
1751 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
1752
1753 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1754 .WillOnce(Invoke([expected_buffer](SerializedPacket* serialized_packet) {
1755 EXPECT_EQ(expected_buffer, serialized_packet->encrypted_buffer);
1756 ClearSerializedPacket(serialized_packet);
1757 }));
1758 creator_.FlushCurrentPacket();
1759 }
1760
1761 // Test for error found in
1762 // https://bugs.chromium.org/p/chromium/issues/detail?id=859949 where a gap
1763 // length that crosses an IETF VarInt length boundary would cause a
1764 // failure. While this test is not applicable to versions other than version 99,
1765 // it should still work. Hence, it is not made version-specific.
TEST_P(QuicPacketCreatorTest,IetfAckGapErrorRegression)1766 TEST_P(QuicPacketCreatorTest, IetfAckGapErrorRegression) {
1767 QuicAckFrame ack_frame =
1768 InitAckFrame({{QuicPacketNumber(60), QuicPacketNumber(61)},
1769 {QuicPacketNumber(125), QuicPacketNumber(126)}});
1770 frames_.push_back(QuicFrame(&ack_frame));
1771 SerializeAllFrames(frames_);
1772 }
1773
TEST_P(QuicPacketCreatorTest,AddMessageFrame)1774 TEST_P(QuicPacketCreatorTest, AddMessageFrame) {
1775 if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
1776 return;
1777 }
1778 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1779 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1780 .Times(3)
1781 .WillRepeatedly(
1782 Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacketForTests));
1783 QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
1784 // Verify that there is enough room for the largest message payload.
1785 EXPECT_TRUE(creator_.HasRoomForMessageFrame(
1786 creator_.GetCurrentLargestMessagePayload()));
1787 std::string message(creator_.GetCurrentLargestMessagePayload(), 'a');
1788 QuicMessageFrame* message_frame =
1789 new QuicMessageFrame(1, MakeSpan(&allocator_, message, &storage));
1790 EXPECT_TRUE(creator_.AddFrame(QuicFrame(message_frame), NOT_RETRANSMISSION));
1791 EXPECT_TRUE(creator_.HasPendingFrames());
1792 creator_.FlushCurrentPacket();
1793
1794 QuicMessageFrame* frame2 =
1795 new QuicMessageFrame(2, MakeSpan(&allocator_, "message", &storage));
1796 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame2), NOT_RETRANSMISSION));
1797 EXPECT_TRUE(creator_.HasPendingFrames());
1798 // Verify if a new frame is added, 1 byte message length will be added.
1799 EXPECT_EQ(1u, creator_.ExpansionOnNewFrame());
1800 QuicMessageFrame* frame3 =
1801 new QuicMessageFrame(3, MakeSpan(&allocator_, "message2", &storage));
1802 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame3), NOT_RETRANSMISSION));
1803 EXPECT_EQ(1u, creator_.ExpansionOnNewFrame());
1804 creator_.FlushCurrentPacket();
1805
1806 QuicFrame frame;
1807 MakeIOVector("test", &iov_);
1808 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1809 client_framer_.transport_version(), Perspective::IS_CLIENT);
1810 EXPECT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
1811 stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
1812 NOT_RETRANSMISSION, &frame));
1813 QuicMessageFrame* frame4 =
1814 new QuicMessageFrame(4, MakeSpan(&allocator_, "message", &storage));
1815 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame4), NOT_RETRANSMISSION));
1816 EXPECT_TRUE(creator_.HasPendingFrames());
1817 // Verify there is not enough room for largest payload.
1818 EXPECT_FALSE(creator_.HasRoomForMessageFrame(
1819 creator_.GetCurrentLargestMessagePayload()));
1820 // Add largest message will causes the flush of the stream frame.
1821 QuicMessageFrame frame5(5, MakeSpan(&allocator_, message, &storage));
1822 EXPECT_FALSE(creator_.AddFrame(QuicFrame(&frame5), NOT_RETRANSMISSION));
1823 EXPECT_FALSE(creator_.HasPendingFrames());
1824 }
1825
TEST_P(QuicPacketCreatorTest,MessageFrameConsumption)1826 TEST_P(QuicPacketCreatorTest, MessageFrameConsumption) {
1827 if (!VersionSupportsMessageFrames(client_framer_.transport_version())) {
1828 return;
1829 }
1830 std::string message_data(kDefaultMaxPacketSize, 'a');
1831 quiche::QuicheStringPiece message_buffer(message_data);
1832 QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
1833 // Test all possible encryption levels of message frames.
1834 for (EncryptionLevel level :
1835 {ENCRYPTION_ZERO_RTT, ENCRYPTION_FORWARD_SECURE}) {
1836 creator_.set_encryption_level(level);
1837 // Test all possible sizes of message frames.
1838 for (size_t message_size = 0;
1839 message_size <= creator_.GetCurrentLargestMessagePayload();
1840 ++message_size) {
1841 QuicMessageFrame* frame = new QuicMessageFrame(
1842 0, MakeSpan(
1843 &allocator_,
1844 quiche::QuicheStringPiece(message_buffer.data(), message_size),
1845 &storage));
1846 EXPECT_TRUE(creator_.AddFrame(QuicFrame(frame), NOT_RETRANSMISSION));
1847 EXPECT_TRUE(creator_.HasPendingFrames());
1848
1849 size_t expansion_bytes = message_size >= 64 ? 2 : 1;
1850 EXPECT_EQ(expansion_bytes, creator_.ExpansionOnNewFrame());
1851 // Verify BytesFree returns bytes available for the next frame, which
1852 // should subtract the message length.
1853 size_t expected_bytes_free =
1854 creator_.GetCurrentLargestMessagePayload() - message_size <
1855 expansion_bytes
1856 ? 0
1857 : creator_.GetCurrentLargestMessagePayload() - expansion_bytes -
1858 message_size;
1859 EXPECT_EQ(expected_bytes_free, creator_.BytesFree());
1860 EXPECT_LE(creator_.GetGuaranteedLargestMessagePayload(),
1861 creator_.GetCurrentLargestMessagePayload());
1862 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1863 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1864 creator_.FlushCurrentPacket();
1865 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
1866 DeleteSerializedPacket();
1867 }
1868 }
1869 }
1870
1871 // Regression test for bugfix of GetPacketHeaderSize.
TEST_P(QuicPacketCreatorTest,GetGuaranteedLargestMessagePayload)1872 TEST_P(QuicPacketCreatorTest, GetGuaranteedLargestMessagePayload) {
1873 QuicTransportVersion version = creator_.transport_version();
1874 if (!VersionSupportsMessageFrames(version)) {
1875 return;
1876 }
1877 QuicPacketLength expected_largest_payload = 1319;
1878 if (QuicVersionHasLongHeaderLengths(version)) {
1879 expected_largest_payload -= 2;
1880 }
1881 if (GetParam().version.HasLengthPrefixedConnectionIds()) {
1882 expected_largest_payload -= 1;
1883 }
1884 EXPECT_EQ(expected_largest_payload,
1885 creator_.GetGuaranteedLargestMessagePayload());
1886 }
1887
TEST_P(QuicPacketCreatorTest,PacketTransmissionType)1888 TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
1889 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
1890
1891 QuicAckFrame temp_ack_frame = InitAckFrame(1);
1892 QuicFrame ack_frame(&temp_ack_frame);
1893 ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(ack_frame.type));
1894
1895 QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
1896 client_framer_.transport_version(), Perspective::IS_CLIENT);
1897 QuicFrame stream_frame(QuicStreamFrame(stream_id,
1898 /*fin=*/false, 0u,
1899 quiche::QuicheStringPiece()));
1900 ASSERT_TRUE(QuicUtils::IsRetransmittableFrame(stream_frame.type));
1901
1902 QuicFrame padding_frame{QuicPaddingFrame()};
1903 ASSERT_FALSE(QuicUtils::IsRetransmittableFrame(padding_frame.type));
1904
1905 EXPECT_CALL(delegate_, OnSerializedPacket(_))
1906 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
1907
1908 EXPECT_TRUE(creator_.AddFrame(ack_frame, LOSS_RETRANSMISSION));
1909 ASSERT_FALSE(serialized_packet_.encrypted_buffer);
1910
1911 EXPECT_TRUE(creator_.AddFrame(stream_frame, RTO_RETRANSMISSION));
1912 ASSERT_FALSE(serialized_packet_.encrypted_buffer);
1913
1914 EXPECT_TRUE(creator_.AddFrame(padding_frame, TLP_RETRANSMISSION));
1915 creator_.FlushCurrentPacket();
1916 ASSERT_TRUE(serialized_packet_.encrypted_buffer);
1917
1918 // The last retransmittable frame on packet is a stream frame, the packet's
1919 // transmission type should be the same as the stream frame's.
1920 EXPECT_EQ(serialized_packet_.transmission_type, RTO_RETRANSMISSION);
1921 DeleteSerializedPacket();
1922 }
1923
TEST_P(QuicPacketCreatorTest,RetryToken)1924 TEST_P(QuicPacketCreatorTest, RetryToken) {
1925 if (!GetParam().version_serialization ||
1926 !QuicVersionHasLongHeaderLengths(client_framer_.transport_version())) {
1927 return;
1928 }
1929
1930 char retry_token_bytes[] = {1, 2, 3, 4, 5, 6, 7, 8,
1931 9, 10, 11, 12, 13, 14, 15, 16};
1932
1933 creator_.SetRetryToken(
1934 std::string(retry_token_bytes, sizeof(retry_token_bytes)));
1935
1936 std::string data("a");
1937 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1938 QuicStreamFrame stream_frame(
1939 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
1940 /*fin=*/false, 0u, quiche::QuicheStringPiece());
1941 frames_.push_back(QuicFrame(stream_frame));
1942 } else {
1943 producer_.SaveCryptoData(ENCRYPTION_INITIAL, 0, data);
1944 frames_.push_back(
1945 QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
1946 }
1947 SerializedPacket serialized = SerializeAllFrames(frames_);
1948
1949 QuicPacketHeader header;
1950 {
1951 InSequence s;
1952 EXPECT_CALL(framer_visitor_, OnPacket());
1953 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
1954 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
1955 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
1956 EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
1957 .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
1958 if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
1959 EXPECT_CALL(framer_visitor_, OnCryptoFrame(_));
1960 } else {
1961 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
1962 }
1963 if (client_framer_.version().HasHeaderProtection()) {
1964 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
1965 }
1966 EXPECT_CALL(framer_visitor_, OnPacketComplete());
1967 }
1968 ProcessPacket(serialized);
1969 ASSERT_TRUE(header.version_flag);
1970 ASSERT_EQ(header.long_packet_type, INITIAL);
1971 ASSERT_EQ(header.retry_token.length(), sizeof(retry_token_bytes));
1972 quiche::test::CompareCharArraysWithHexError(
1973 "retry token", header.retry_token.data(), header.retry_token.length(),
1974 retry_token_bytes, sizeof(retry_token_bytes));
1975 DeleteFrames(&frames_);
1976 }
1977
TEST_P(QuicPacketCreatorTest,GetConnectionId)1978 TEST_P(QuicPacketCreatorTest, GetConnectionId) {
1979 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
1980 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
1981 }
1982
TEST_P(QuicPacketCreatorTest,ClientConnectionId)1983 TEST_P(QuicPacketCreatorTest, ClientConnectionId) {
1984 if (!client_framer_.version().SupportsClientConnectionIds()) {
1985 return;
1986 }
1987 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
1988 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
1989 creator_.SetClientConnectionId(TestConnectionId(0x33));
1990 EXPECT_EQ(TestConnectionId(2), creator_.GetDestinationConnectionId());
1991 EXPECT_EQ(TestConnectionId(0x33), creator_.GetSourceConnectionId());
1992 }
1993
TEST_P(QuicPacketCreatorTest,CoalesceStreamFrames)1994 TEST_P(QuicPacketCreatorTest, CoalesceStreamFrames) {
1995 InSequence s;
1996 if (!GetParam().version_serialization) {
1997 creator_.StopSendingVersion();
1998 }
1999 const size_t max_plaintext_size =
2000 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
2001 EXPECT_FALSE(creator_.HasPendingFrames());
2002 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2003 QuicStreamId stream_id1 = QuicUtils::GetFirstBidirectionalStreamId(
2004 client_framer_.transport_version(), Perspective::IS_CLIENT);
2005 QuicStreamId stream_id2 = GetNthClientInitiatedStreamId(1);
2006 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(stream_id1));
2007 EXPECT_EQ(max_plaintext_size -
2008 GetPacketHeaderSize(
2009 client_framer_.transport_version(),
2010 creator_.GetDestinationConnectionIdLength(),
2011 creator_.GetSourceConnectionIdLength(),
2012 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
2013 !kIncludeDiversificationNonce,
2014 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
2015 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
2016 0, QuicPacketCreatorPeer::GetLengthLength(&creator_)),
2017 creator_.BytesFree());
2018 StrictMock<MockDebugDelegate> debug;
2019 creator_.set_debug_delegate(&debug);
2020
2021 MakeIOVector("test", &iov_);
2022 QuicFrame frame;
2023 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
2024 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2025 stream_id1, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
2026 NOT_RETRANSMISSION, &frame));
2027 EXPECT_TRUE(creator_.HasPendingFrames());
2028 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id1));
2029
2030 MakeIOVector("coalesce", &iov_);
2031 // frame will be coalesced with the first frame.
2032 const auto previous_size = creator_.PacketSize();
2033 QuicStreamFrame target(stream_id1, true, 0, 12);
2034 EXPECT_CALL(debug, OnStreamFrameCoalesced(target));
2035 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2036 stream_id1, &iov_, 1u, iov_.iov_len, 0u, 4u, true, false,
2037 NOT_RETRANSMISSION, &frame));
2038 EXPECT_EQ(frame.stream_frame.data_length,
2039 creator_.PacketSize() - previous_size);
2040
2041 // frame is for another stream, so it won't be coalesced.
2042 const auto length = creator_.BytesFree() - 10u;
2043 std::string large_data(length, 'x');
2044 MakeIOVector(large_data, &iov_);
2045 EXPECT_CALL(debug, OnFrameAddedToPacket(_));
2046 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2047 stream_id2, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
2048 NOT_RETRANSMISSION, &frame));
2049 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(stream_id2));
2050
2051 // The packet doesn't have enough free bytes for all data, but will still be
2052 // able to consume and coalesce part of them.
2053 EXPECT_CALL(debug, OnStreamFrameCoalesced(_));
2054 MakeIOVector("somerandomdata", &iov_);
2055 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2056 stream_id2, &iov_, 1u, iov_.iov_len, 0u, length, false, false,
2057 NOT_RETRANSMISSION, &frame));
2058
2059 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2060 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2061 creator_.FlushCurrentPacket();
2062 EXPECT_CALL(framer_visitor_, OnPacket());
2063 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
2064 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
2065 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
2066 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
2067 // The packet should only have 2 stream frames.
2068 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2069 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2070 EXPECT_CALL(framer_visitor_, OnPacketComplete());
2071 ProcessPacket(serialized_packet_);
2072 }
2073
TEST_P(QuicPacketCreatorTest,SaveNonRetransmittableFrames)2074 TEST_P(QuicPacketCreatorTest, SaveNonRetransmittableFrames) {
2075 QuicAckFrame ack_frame(InitAckFrame(1));
2076 frames_.push_back(QuicFrame(&ack_frame));
2077 frames_.push_back(QuicFrame(QuicPaddingFrame(-1)));
2078 SerializedPacket serialized = SerializeAllFrames(frames_);
2079 ASSERT_EQ(2u, serialized.nonretransmittable_frames.size());
2080 EXPECT_EQ(ACK_FRAME, serialized.nonretransmittable_frames[0].type);
2081 EXPECT_EQ(PADDING_FRAME, serialized.nonretransmittable_frames[1].type);
2082 // Verify full padding frame is translated to a padding frame with actual
2083 // bytes of padding.
2084 EXPECT_LT(
2085 0,
2086 serialized.nonretransmittable_frames[1].padding_frame.num_padding_bytes);
2087 frames_.clear();
2088
2089 // Serialize another packet with the same frames.
2090 SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
2091 &creator_, serialized.nonretransmittable_frames, buffer_,
2092 kMaxOutgoingPacketSize);
2093 // Verify the packet length of both packets are equal.
2094 EXPECT_EQ(serialized.encrypted_length, packet.encrypted_length);
2095 }
2096
TEST_P(QuicPacketCreatorTest,SerializeCoalescedPacket)2097 TEST_P(QuicPacketCreatorTest, SerializeCoalescedPacket) {
2098 QuicCoalescedPacket coalesced;
2099 SimpleBufferAllocator allocator;
2100 QuicSocketAddress self_address(QuicIpAddress::Loopback4(), 1);
2101 QuicSocketAddress peer_address(QuicIpAddress::Loopback4(), 2);
2102 for (size_t i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
2103 EncryptionLevel level = static_cast<EncryptionLevel>(i);
2104 creator_.set_encryption_level(level);
2105 QuicAckFrame ack_frame(InitAckFrame(1));
2106 frames_.push_back(QuicFrame(&ack_frame));
2107 if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
2108 frames_.push_back(QuicFrame(
2109 QuicStreamFrame(1, false, 0u, quiche::QuicheStringPiece())));
2110 }
2111 SerializedPacket serialized = SerializeAllFrames(frames_);
2112 EXPECT_EQ(level, serialized.encryption_level);
2113 frames_.clear();
2114 ASSERT_TRUE(coalesced.MaybeCoalescePacket(serialized, self_address,
2115 peer_address, &allocator,
2116 creator_.max_packet_length()));
2117 }
2118 char buffer[kMaxOutgoingPacketSize];
2119 size_t coalesced_length = creator_.SerializeCoalescedPacket(
2120 coalesced, buffer, kMaxOutgoingPacketSize);
2121 // Verify packet is padded to full.
2122 ASSERT_EQ(coalesced.max_packet_length(), coalesced_length);
2123 if (!QuicVersionHasLongHeaderLengths(server_framer_.transport_version())) {
2124 return;
2125 }
2126 // Verify packet process.
2127 std::unique_ptr<QuicEncryptedPacket> packets[NUM_ENCRYPTION_LEVELS];
2128 packets[ENCRYPTION_INITIAL] =
2129 std::make_unique<QuicEncryptedPacket>(buffer, coalesced_length);
2130 for (size_t i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
2131 InSequence s;
2132 EXPECT_CALL(framer_visitor_, OnPacket());
2133 EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
2134 if (i < ENCRYPTION_FORWARD_SECURE) {
2135 // Save coalesced packet.
2136 EXPECT_CALL(framer_visitor_, OnCoalescedPacket(_))
2137 .WillOnce(Invoke([i, &packets](const QuicEncryptedPacket& packet) {
2138 packets[i + 1] = packet.Clone();
2139 }));
2140 }
2141 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
2142 EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
2143 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
2144 EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _)).WillOnce(Return(true));
2145 EXPECT_CALL(framer_visitor_,
2146 OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2)))
2147 .WillOnce(Return(true));
2148 EXPECT_CALL(framer_visitor_, OnAckFrameEnd(_)).WillOnce(Return(true));
2149 if (i == ENCRYPTION_INITIAL) {
2150 // Verify padding is added.
2151 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
2152 } else {
2153 EXPECT_CALL(framer_visitor_, OnPaddingFrame(_)).Times(testing::AtMost(1));
2154 }
2155 if (i != ENCRYPTION_INITIAL && i != ENCRYPTION_HANDSHAKE) {
2156 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
2157 }
2158 EXPECT_CALL(framer_visitor_, OnPacketComplete());
2159
2160 server_framer_.ProcessPacket(*packets[i]);
2161 }
2162 }
2163
TEST_P(QuicPacketCreatorTest,SoftMaxPacketLength)2164 TEST_P(QuicPacketCreatorTest, SoftMaxPacketLength) {
2165 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2166 QuicByteCount previous_max_packet_length = creator_.max_packet_length();
2167 const size_t overhead =
2168 GetPacketHeaderOverhead(client_framer_.transport_version()) +
2169 QuicPacketCreator::MinPlaintextPacketSize(client_framer_.version()) +
2170 GetEncryptionOverhead();
2171 // Make sure a length which cannot accommodate header (includes header
2172 // protection minimal length) gets rejected.
2173 creator_.SetSoftMaxPacketLength(overhead - 1);
2174 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2175
2176 creator_.SetSoftMaxPacketLength(overhead);
2177 EXPECT_EQ(overhead, creator_.max_packet_length());
2178
2179 // Verify creator has room for stream frame because max_packet_length_ gets
2180 // restored.
2181 ASSERT_TRUE(creator_.HasRoomForStreamFrame(
2182 GetNthClientInitiatedStreamId(1), kMaxIetfVarInt,
2183 std::numeric_limits<uint32_t>::max()));
2184 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2185
2186 // Same for message frame.
2187 if (VersionSupportsMessageFrames(client_framer_.transport_version())) {
2188 creator_.SetSoftMaxPacketLength(overhead);
2189 // Verify GetCurrentLargestMessagePayload is based on the actual
2190 // max_packet_length.
2191 EXPECT_LT(1u, creator_.GetCurrentLargestMessagePayload());
2192 EXPECT_EQ(overhead, creator_.max_packet_length());
2193 ASSERT_TRUE(creator_.HasRoomForMessageFrame(
2194 creator_.GetCurrentLargestMessagePayload()));
2195 EXPECT_EQ(previous_max_packet_length, creator_.max_packet_length());
2196 }
2197
2198 // Verify creator can consume crypto data because max_packet_length_ gets
2199 // restored.
2200 creator_.SetSoftMaxPacketLength(overhead);
2201 EXPECT_EQ(overhead, creator_.max_packet_length());
2202 std::string data = "crypto data";
2203 MakeIOVector(data, &iov_);
2204 QuicFrame frame;
2205 if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
2206 ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
2207 QuicUtils::GetCryptoStreamId(client_framer_.transport_version()), &iov_,
2208 1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION,
2209 &frame));
2210 size_t bytes_consumed = frame.stream_frame.data_length;
2211 EXPECT_LT(0u, bytes_consumed);
2212 } else {
2213 producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
2214 ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
2215 ENCRYPTION_INITIAL, data.length(), kOffset,
2216 /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
2217 size_t bytes_consumed = frame.crypto_frame->data_length;
2218 EXPECT_LT(0u, bytes_consumed);
2219 }
2220 EXPECT_TRUE(creator_.HasPendingFrames());
2221 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2222 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
2223 creator_.FlushCurrentPacket();
2224
2225 // Verify ACK frame can be consumed.
2226 creator_.SetSoftMaxPacketLength(overhead);
2227 EXPECT_EQ(overhead, creator_.max_packet_length());
2228 QuicAckFrame ack_frame(InitAckFrame(10u));
2229 EXPECT_TRUE(creator_.AddFrame(QuicFrame(&ack_frame), NOT_RETRANSMISSION));
2230 EXPECT_TRUE(creator_.HasPendingFrames());
2231 }
2232
2233 class MockDelegate : public QuicPacketCreator::DelegateInterface {
2234 public:
MockDelegate()2235 MockDelegate() {}
2236 MockDelegate(const MockDelegate&) = delete;
2237 MockDelegate& operator=(const MockDelegate&) = delete;
~MockDelegate()2238 ~MockDelegate() override {}
2239
2240 MOCK_METHOD2(ShouldGeneratePacket,
2241 bool(HasRetransmittableData retransmittable,
2242 IsHandshake handshake));
2243 MOCK_METHOD0(MaybeBundleAckOpportunistically, const QuicFrames());
2244 MOCK_METHOD0(GetPacketBuffer, char*());
2245 MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
2246 MOCK_METHOD2(OnUnrecoverableError, void(QuicErrorCode, const std::string&));
2247
SetCanWriteAnything()2248 void SetCanWriteAnything() {
2249 EXPECT_CALL(*this, ShouldGeneratePacket(_, _)).WillRepeatedly(Return(true));
2250 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2251 .WillRepeatedly(Return(true));
2252 }
2253
SetCanNotWrite()2254 void SetCanNotWrite() {
2255 EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
2256 .WillRepeatedly(Return(false));
2257 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2258 .WillRepeatedly(Return(false));
2259 }
2260
2261 // Use this when only ack frames should be allowed to be written.
SetCanWriteOnlyNonRetransmittable()2262 void SetCanWriteOnlyNonRetransmittable() {
2263 EXPECT_CALL(*this, ShouldGeneratePacket(_, _))
2264 .WillRepeatedly(Return(false));
2265 EXPECT_CALL(*this, ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, _))
2266 .WillRepeatedly(Return(true));
2267 }
2268 };
2269
2270 // Simple struct for describing the contents of a packet.
2271 // Useful in conjunction with a SimpleQuicFrame for validating that a packet
2272 // contains the expected frames.
2273 struct PacketContents {
PacketContentsquic::test::__anonc6aac9380111::PacketContents2274 PacketContents()
2275 : num_ack_frames(0),
2276 num_connection_close_frames(0),
2277 num_goaway_frames(0),
2278 num_rst_stream_frames(0),
2279 num_stop_waiting_frames(0),
2280 num_stream_frames(0),
2281 num_crypto_frames(0),
2282 num_ping_frames(0),
2283 num_mtu_discovery_frames(0),
2284 num_padding_frames(0) {}
2285
2286 size_t num_ack_frames;
2287 size_t num_connection_close_frames;
2288 size_t num_goaway_frames;
2289 size_t num_rst_stream_frames;
2290 size_t num_stop_waiting_frames;
2291 size_t num_stream_frames;
2292 size_t num_crypto_frames;
2293 size_t num_ping_frames;
2294 size_t num_mtu_discovery_frames;
2295 size_t num_padding_frames;
2296 };
2297
2298 class MultiplePacketsTestPacketCreator : public QuicPacketCreator {
2299 public:
MultiplePacketsTestPacketCreator(QuicConnectionId connection_id,QuicFramer * framer,QuicRandom * random_generator,QuicPacketCreator::DelegateInterface * delegate,SimpleDataProducer * producer)2300 MultiplePacketsTestPacketCreator(
2301 QuicConnectionId connection_id,
2302 QuicFramer* framer,
2303 QuicRandom* random_generator,
2304 QuicPacketCreator::DelegateInterface* delegate,
2305 SimpleDataProducer* producer)
2306 : QuicPacketCreator(connection_id, framer, random_generator, delegate),
2307 ack_frame_(InitAckFrame(1)),
2308 delegate_(static_cast<MockDelegate*>(delegate)),
2309 producer_(producer) {}
2310
ConsumeRetransmittableControlFrame(const QuicFrame & frame,bool bundle_ack)2311 bool ConsumeRetransmittableControlFrame(const QuicFrame& frame,
2312 bool bundle_ack) {
2313 if (!has_ack()) {
2314 QuicFrames frames;
2315 if (bundle_ack) {
2316 frames.push_back(QuicFrame(&ack_frame_));
2317 }
2318 if (delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2319 NOT_HANDSHAKE)) {
2320 EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically())
2321 .WillOnce(Return(frames));
2322 }
2323 }
2324 return QuicPacketCreator::ConsumeRetransmittableControlFrame(frame);
2325 }
2326
ConsumeDataFastPath(QuicStreamId id,const struct iovec * iov,int iov_count,size_t total_length,QuicStreamOffset offset,bool fin)2327 QuicConsumedData ConsumeDataFastPath(QuicStreamId id,
2328 const struct iovec* iov,
2329 int iov_count,
2330 size_t total_length,
2331 QuicStreamOffset offset,
2332 bool fin) {
2333 // Save data before data is consumed.
2334 if (total_length > 0) {
2335 producer_->SaveStreamData(id, iov, iov_count, 0, total_length);
2336 }
2337 return QuicPacketCreator::ConsumeDataFastPath(id, total_length, offset, fin,
2338 0);
2339 }
2340
ConsumeData(QuicStreamId id,const struct iovec * iov,int iov_count,size_t total_length,QuicStreamOffset offset,StreamSendingState state)2341 QuicConsumedData ConsumeData(QuicStreamId id,
2342 const struct iovec* iov,
2343 int iov_count,
2344 size_t total_length,
2345 QuicStreamOffset offset,
2346 StreamSendingState state) {
2347 // Save data before data is consumed.
2348 if (total_length > 0) {
2349 producer_->SaveStreamData(id, iov, iov_count, 0, total_length);
2350 }
2351 if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2352 NOT_HANDSHAKE)) {
2353 EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically()).Times(1);
2354 }
2355 return QuicPacketCreator::ConsumeData(id, total_length, offset, state);
2356 }
2357
AddMessageFrame(QuicMessageId message_id,QuicMemSliceSpan message)2358 MessageStatus AddMessageFrame(QuicMessageId message_id,
2359 QuicMemSliceSpan message) {
2360 if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2361 NOT_HANDSHAKE)) {
2362 EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically()).Times(1);
2363 }
2364 return QuicPacketCreator::AddMessageFrame(message_id, message);
2365 }
2366
ConsumeCryptoData(EncryptionLevel level,quiche::QuicheStringPiece data,QuicStreamOffset offset)2367 size_t ConsumeCryptoData(EncryptionLevel level,
2368 quiche::QuicheStringPiece data,
2369 QuicStreamOffset offset) {
2370 producer_->SaveCryptoData(level, offset, data);
2371 if (!has_ack() && delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA,
2372 NOT_HANDSHAKE)) {
2373 EXPECT_CALL(*delegate_, MaybeBundleAckOpportunistically()).Times(1);
2374 }
2375 return QuicPacketCreator::ConsumeCryptoData(level, data.length(), offset);
2376 }
2377
2378 QuicAckFrame ack_frame_;
2379 MockDelegate* delegate_;
2380 SimpleDataProducer* producer_;
2381 };
2382
2383 class QuicPacketCreatorMultiplePacketsTest : public QuicTest {
2384 public:
QuicPacketCreatorMultiplePacketsTest()2385 QuicPacketCreatorMultiplePacketsTest()
2386 : framer_(AllSupportedVersions(),
2387 QuicTime::Zero(),
2388 Perspective::IS_CLIENT,
2389 kQuicDefaultConnectionIdLength),
2390 creator_(TestConnectionId(),
2391 &framer_,
2392 &random_creator_,
2393 &delegate_,
2394 &producer_),
2395 ack_frame_(InitAckFrame(1)) {
2396 EXPECT_CALL(delegate_, GetPacketBuffer()).WillRepeatedly(Return(nullptr));
2397 creator_.SetEncrypter(
2398 ENCRYPTION_FORWARD_SECURE,
2399 std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
2400 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
2401 framer_.set_data_producer(&producer_);
2402 if (simple_framer_.framer()->version().KnowsWhichDecrypterToUse()) {
2403 simple_framer_.framer()->InstallDecrypter(
2404 ENCRYPTION_FORWARD_SECURE,
2405 std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
2406 }
2407 creator_.AttachPacketFlusher();
2408 }
2409
~QuicPacketCreatorMultiplePacketsTest()2410 ~QuicPacketCreatorMultiplePacketsTest() override {
2411 for (SerializedPacket& packet : packets_) {
2412 delete[] packet.encrypted_buffer;
2413 ClearSerializedPacket(&packet);
2414 }
2415 }
2416
SavePacket(SerializedPacket * packet)2417 void SavePacket(SerializedPacket* packet) {
2418 packet->encrypted_buffer = CopyBuffer(*packet);
2419 packets_.push_back(*packet);
2420 packet->encrypted_buffer = nullptr;
2421 packet->retransmittable_frames.clear();
2422 }
2423
2424 protected:
CreateRstStreamFrame()2425 QuicRstStreamFrame* CreateRstStreamFrame() {
2426 return new QuicRstStreamFrame(1, 1, QUIC_STREAM_NO_ERROR, 0);
2427 }
2428
CreateGoAwayFrame()2429 QuicGoAwayFrame* CreateGoAwayFrame() {
2430 return new QuicGoAwayFrame(2, QUIC_NO_ERROR, 1, std::string());
2431 }
2432
CheckPacketContains(const PacketContents & contents,size_t packet_index)2433 void CheckPacketContains(const PacketContents& contents,
2434 size_t packet_index) {
2435 ASSERT_GT(packets_.size(), packet_index);
2436 const SerializedPacket& packet = packets_[packet_index];
2437 size_t num_retransmittable_frames =
2438 contents.num_connection_close_frames + contents.num_goaway_frames +
2439 contents.num_rst_stream_frames + contents.num_stream_frames +
2440 contents.num_crypto_frames + contents.num_ping_frames;
2441 size_t num_frames =
2442 contents.num_ack_frames + contents.num_stop_waiting_frames +
2443 contents.num_mtu_discovery_frames + contents.num_padding_frames +
2444 num_retransmittable_frames;
2445
2446 if (num_retransmittable_frames == 0) {
2447 ASSERT_TRUE(packet.retransmittable_frames.empty());
2448 } else {
2449 ASSERT_FALSE(packet.retransmittable_frames.empty());
2450 EXPECT_EQ(num_retransmittable_frames,
2451 packet.retransmittable_frames.size());
2452 }
2453
2454 ASSERT_TRUE(packet.encrypted_buffer != nullptr);
2455 ASSERT_TRUE(simple_framer_.ProcessPacket(
2456 QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
2457 size_t num_padding_frames = 0;
2458 if (contents.num_padding_frames == 0) {
2459 num_padding_frames = simple_framer_.padding_frames().size();
2460 }
2461 EXPECT_EQ(num_frames + num_padding_frames, simple_framer_.num_frames());
2462 EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
2463 EXPECT_EQ(contents.num_connection_close_frames,
2464 simple_framer_.connection_close_frames().size());
2465 EXPECT_EQ(contents.num_goaway_frames,
2466 simple_framer_.goaway_frames().size());
2467 EXPECT_EQ(contents.num_rst_stream_frames,
2468 simple_framer_.rst_stream_frames().size());
2469 EXPECT_EQ(contents.num_stream_frames,
2470 simple_framer_.stream_frames().size());
2471 EXPECT_EQ(contents.num_crypto_frames,
2472 simple_framer_.crypto_frames().size());
2473 EXPECT_EQ(contents.num_stop_waiting_frames,
2474 simple_framer_.stop_waiting_frames().size());
2475 if (contents.num_padding_frames != 0) {
2476 EXPECT_EQ(contents.num_padding_frames,
2477 simple_framer_.padding_frames().size());
2478 }
2479
2480 // From the receiver's perspective, MTU discovery frames are ping frames.
2481 EXPECT_EQ(contents.num_ping_frames + contents.num_mtu_discovery_frames,
2482 simple_framer_.ping_frames().size());
2483 }
2484
CheckPacketHasSingleStreamFrame(size_t packet_index)2485 void CheckPacketHasSingleStreamFrame(size_t packet_index) {
2486 ASSERT_GT(packets_.size(), packet_index);
2487 const SerializedPacket& packet = packets_[packet_index];
2488 ASSERT_FALSE(packet.retransmittable_frames.empty());
2489 EXPECT_EQ(1u, packet.retransmittable_frames.size());
2490 ASSERT_TRUE(packet.encrypted_buffer != nullptr);
2491 ASSERT_TRUE(simple_framer_.ProcessPacket(
2492 QuicEncryptedPacket(packet.encrypted_buffer, packet.encrypted_length)));
2493 EXPECT_EQ(1u, simple_framer_.num_frames());
2494 EXPECT_EQ(1u, simple_framer_.stream_frames().size());
2495 }
2496
CheckAllPacketsHaveSingleStreamFrame()2497 void CheckAllPacketsHaveSingleStreamFrame() {
2498 for (size_t i = 0; i < packets_.size(); i++) {
2499 CheckPacketHasSingleStreamFrame(i);
2500 }
2501 }
2502
CreateData(size_t len)2503 void CreateData(size_t len) {
2504 data_array_.reset(new char[len]);
2505 memset(data_array_.get(), '?', len);
2506 iov_.iov_base = data_array_.get();
2507 iov_.iov_len = len;
2508 }
2509
2510 QuicFramer framer_;
2511 MockRandom random_creator_;
2512 StrictMock<MockDelegate> delegate_;
2513 MultiplePacketsTestPacketCreator creator_;
2514 SimpleQuicFramer simple_framer_;
2515 std::vector<SerializedPacket> packets_;
2516 QuicAckFrame ack_frame_;
2517 struct iovec iov_;
2518 SimpleBufferAllocator allocator_;
2519
2520 private:
2521 std::unique_ptr<char[]> data_array_;
2522 SimpleDataProducer producer_;
2523 };
2524
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_NotWritable)2525 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddControlFrame_NotWritable) {
2526 delegate_.SetCanNotWrite();
2527
2528 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2529 const bool consumed =
2530 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2531 /*bundle_ack=*/false);
2532 EXPECT_FALSE(consumed);
2533 EXPECT_FALSE(creator_.HasPendingFrames());
2534 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2535 delete rst_frame;
2536 }
2537
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_OnlyAckWritable)2538 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddControlFrame_OnlyAckWritable) {
2539 delegate_.SetCanWriteOnlyNonRetransmittable();
2540
2541 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2542 const bool consumed =
2543 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2544 /*bundle_ack=*/false);
2545 EXPECT_FALSE(consumed);
2546 EXPECT_FALSE(creator_.HasPendingFrames());
2547 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2548 delete rst_frame;
2549 }
2550
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_WritableAndShouldNotFlush)2551 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2552 AddControlFrame_WritableAndShouldNotFlush) {
2553 delegate_.SetCanWriteAnything();
2554
2555 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
2556 /*bundle_ack=*/false);
2557 EXPECT_TRUE(creator_.HasPendingFrames());
2558 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2559 }
2560
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_NotWritableBatchThenFlush)2561 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2562 AddControlFrame_NotWritableBatchThenFlush) {
2563 delegate_.SetCanNotWrite();
2564
2565 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2566 const bool consumed =
2567 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2568 /*bundle_ack=*/false);
2569 EXPECT_FALSE(consumed);
2570 EXPECT_FALSE(creator_.HasPendingFrames());
2571 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2572 delete rst_frame;
2573 }
2574
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddControlFrame_WritableAndShouldFlush)2575 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2576 AddControlFrame_WritableAndShouldFlush) {
2577 delegate_.SetCanWriteAnything();
2578
2579 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2580 .WillOnce(
2581 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2582
2583 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
2584 /*bundle_ack=*/false);
2585 creator_.Flush();
2586 EXPECT_FALSE(creator_.HasPendingFrames());
2587 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2588
2589 PacketContents contents;
2590 contents.num_rst_stream_frames = 1;
2591 CheckPacketContains(contents, 0);
2592 }
2593
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeCryptoData)2594 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeCryptoData) {
2595 delegate_.SetCanWriteAnything();
2596
2597 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2598 .WillOnce(
2599 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2600 std::string data = "crypto data";
2601 size_t consumed_bytes =
2602 creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
2603 creator_.Flush();
2604 EXPECT_EQ(data.length(), consumed_bytes);
2605 EXPECT_FALSE(creator_.HasPendingFrames());
2606 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2607
2608 PacketContents contents;
2609 contents.num_crypto_frames = 1;
2610 contents.num_padding_frames = 1;
2611 CheckPacketContains(contents, 0);
2612 }
2613
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_NotWritable)2614 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_NotWritable) {
2615 delegate_.SetCanNotWrite();
2616
2617 MakeIOVector("foo", &iov_);
2618 QuicConsumedData consumed = creator_.ConsumeData(
2619 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2620 Perspective::IS_CLIENT),
2621 &iov_, 1u, iov_.iov_len, 0, FIN);
2622 EXPECT_EQ(0u, consumed.bytes_consumed);
2623 EXPECT_FALSE(consumed.fin_consumed);
2624 EXPECT_FALSE(creator_.HasPendingFrames());
2625 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2626 }
2627
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_WritableAndShouldNotFlush)2628 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2629 ConsumeData_WritableAndShouldNotFlush) {
2630 delegate_.SetCanWriteAnything();
2631
2632 MakeIOVector("foo", &iov_);
2633 QuicConsumedData consumed = creator_.ConsumeData(
2634 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2635 Perspective::IS_CLIENT),
2636 &iov_, 1u, iov_.iov_len, 0, FIN);
2637 EXPECT_EQ(3u, consumed.bytes_consumed);
2638 EXPECT_TRUE(consumed.fin_consumed);
2639 EXPECT_TRUE(creator_.HasPendingFrames());
2640 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2641 }
2642
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_WritableAndShouldFlush)2643 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2644 ConsumeData_WritableAndShouldFlush) {
2645 delegate_.SetCanWriteAnything();
2646
2647 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2648 .WillOnce(
2649 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2650 MakeIOVector("foo", &iov_);
2651 QuicConsumedData consumed = creator_.ConsumeData(
2652 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2653 Perspective::IS_CLIENT),
2654 &iov_, 1u, iov_.iov_len, 0, FIN);
2655 creator_.Flush();
2656 EXPECT_EQ(3u, consumed.bytes_consumed);
2657 EXPECT_TRUE(consumed.fin_consumed);
2658 EXPECT_FALSE(creator_.HasPendingFrames());
2659 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2660
2661 PacketContents contents;
2662 contents.num_stream_frames = 1;
2663 CheckPacketContains(contents, 0);
2664 }
2665
2666 // Test the behavior of ConsumeData when the data consumed is for the crypto
2667 // handshake stream. Ensure that the packet is always sent and padded even if
2668 // the creator operates in batch mode.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_Handshake)2669 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_Handshake) {
2670 delegate_.SetCanWriteAnything();
2671
2672 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2673 .WillOnce(
2674 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2675 std::string data = "foo bar";
2676 MakeIOVector(data, &iov_);
2677 size_t consumed_bytes = 0;
2678 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
2679 consumed_bytes = creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
2680 } else {
2681 consumed_bytes =
2682 creator_
2683 .ConsumeData(
2684 QuicUtils::GetCryptoStreamId(framer_.transport_version()),
2685 &iov_, 1u, iov_.iov_len, 0, NO_FIN)
2686 .bytes_consumed;
2687 }
2688 EXPECT_EQ(7u, consumed_bytes);
2689 EXPECT_FALSE(creator_.HasPendingFrames());
2690 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2691
2692 PacketContents contents;
2693 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
2694 contents.num_crypto_frames = 1;
2695 } else {
2696 contents.num_stream_frames = 1;
2697 }
2698 contents.num_padding_frames = 1;
2699 CheckPacketContains(contents, 0);
2700
2701 ASSERT_EQ(1u, packets_.size());
2702 ASSERT_EQ(kDefaultMaxPacketSize, creator_.max_packet_length());
2703 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
2704 }
2705
2706 // Test the behavior of ConsumeData when the data is for the crypto handshake
2707 // stream, but padding is disabled.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_Handshake_PaddingDisabled)2708 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2709 ConsumeData_Handshake_PaddingDisabled) {
2710 creator_.set_fully_pad_crypto_handshake_packets(false);
2711
2712 delegate_.SetCanWriteAnything();
2713
2714 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2715 .WillOnce(
2716 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2717 std::string data = "foo";
2718 MakeIOVector(data, &iov_);
2719 size_t bytes_consumed = 0;
2720 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
2721 bytes_consumed = creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
2722 } else {
2723 bytes_consumed =
2724 creator_
2725 .ConsumeData(
2726 QuicUtils::GetCryptoStreamId(framer_.transport_version()),
2727 &iov_, 1u, iov_.iov_len, 0, NO_FIN)
2728 .bytes_consumed;
2729 }
2730 EXPECT_EQ(3u, bytes_consumed);
2731 EXPECT_FALSE(creator_.HasPendingFrames());
2732 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2733
2734 PacketContents contents;
2735 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
2736 contents.num_crypto_frames = 1;
2737 } else {
2738 contents.num_stream_frames = 1;
2739 }
2740 contents.num_padding_frames = 0;
2741 CheckPacketContains(contents, 0);
2742
2743 ASSERT_EQ(1u, packets_.size());
2744
2745 // Packet is not fully padded, but we want to future packets to be larger.
2746 ASSERT_EQ(kDefaultMaxPacketSize, creator_.max_packet_length());
2747 size_t expected_packet_length = 27;
2748 if (QuicVersionUsesCryptoFrames(framer_.transport_version())) {
2749 // The framing of CRYPTO frames is slightly different than that of stream
2750 // frames, so the expected packet length differs slightly.
2751 expected_packet_length = 28;
2752 }
2753 if (framer_.version().HasHeaderProtection()) {
2754 expected_packet_length = 29;
2755 }
2756 EXPECT_EQ(expected_packet_length, packets_[0].encrypted_length);
2757 }
2758
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_EmptyData)2759 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_EmptyData) {
2760 delegate_.SetCanWriteAnything();
2761
2762 EXPECT_QUIC_BUG(creator_.ConsumeData(
2763 QuicUtils::QuicUtils::GetFirstBidirectionalStreamId(
2764 framer_.transport_version(), Perspective::IS_CLIENT),
2765 nullptr, 0, 0, 0, NO_FIN),
2766 "Attempt to consume empty data without FIN.");
2767 }
2768
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataMultipleTimes_WritableAndShouldNotFlush)2769 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2770 ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
2771 delegate_.SetCanWriteAnything();
2772
2773 MakeIOVector("foo", &iov_);
2774 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
2775 framer_.transport_version(), Perspective::IS_CLIENT),
2776 &iov_, 1u, iov_.iov_len, 0, FIN);
2777 MakeIOVector("quux", &iov_);
2778 QuicConsumedData consumed =
2779 creator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 3, NO_FIN);
2780 EXPECT_EQ(4u, consumed.bytes_consumed);
2781 EXPECT_FALSE(consumed.fin_consumed);
2782 EXPECT_TRUE(creator_.HasPendingFrames());
2783 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2784 }
2785
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_BatchOperations)2786 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeData_BatchOperations) {
2787 delegate_.SetCanWriteAnything();
2788
2789 MakeIOVector("foo", &iov_);
2790 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
2791 framer_.transport_version(), Perspective::IS_CLIENT),
2792 &iov_, 1u, iov_.iov_len, 0, NO_FIN);
2793 MakeIOVector("quux", &iov_);
2794 QuicConsumedData consumed = creator_.ConsumeData(
2795 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2796 Perspective::IS_CLIENT),
2797 &iov_, 1u, iov_.iov_len, 3, FIN);
2798 EXPECT_EQ(4u, consumed.bytes_consumed);
2799 EXPECT_TRUE(consumed.fin_consumed);
2800 EXPECT_TRUE(creator_.HasPendingFrames());
2801 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2802
2803 // Now both frames will be flushed out.
2804 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2805 .WillOnce(
2806 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2807 creator_.Flush();
2808 EXPECT_FALSE(creator_.HasPendingFrames());
2809 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2810
2811 PacketContents contents;
2812 contents.num_stream_frames = 1;
2813 CheckPacketContains(contents, 0);
2814 }
2815
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeData_FramesPreviouslyQueued)2816 TEST_F(QuicPacketCreatorMultiplePacketsTest,
2817 ConsumeData_FramesPreviouslyQueued) {
2818 // Set the packet size be enough for two stream frames with 0 stream offset,
2819 // but not enough for a stream frame of 0 offset and one with non-zero offset.
2820 size_t length =
2821 NullEncrypter(Perspective::IS_CLIENT).GetCiphertextSize(0) +
2822 GetPacketHeaderSize(
2823 framer_.transport_version(),
2824 creator_.GetDestinationConnectionIdLength(),
2825 creator_.GetSourceConnectionIdLength(),
2826 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
2827 !kIncludeDiversificationNonce,
2828 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
2829 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
2830 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
2831 // Add an extra 3 bytes for the payload and 1 byte so
2832 // BytesFree is larger than the GetMinStreamFrameSize.
2833 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(), 1, 0,
2834 false, 3) +
2835 3 +
2836 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(), 1, 0, true,
2837 1) +
2838 1;
2839 creator_.SetMaxPacketLength(length);
2840 delegate_.SetCanWriteAnything();
2841 {
2842 InSequence dummy;
2843 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2844 .WillOnce(
2845 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2846 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2847 .WillOnce(
2848 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2849 }
2850 // Queue enough data to prevent a stream frame with a non-zero offset from
2851 // fitting.
2852 MakeIOVector("foo", &iov_);
2853 QuicConsumedData consumed = creator_.ConsumeData(
2854 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2855 Perspective::IS_CLIENT),
2856 &iov_, 1u, iov_.iov_len, 0, NO_FIN);
2857 EXPECT_EQ(3u, consumed.bytes_consumed);
2858 EXPECT_FALSE(consumed.fin_consumed);
2859 EXPECT_TRUE(creator_.HasPendingFrames());
2860 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2861
2862 // This frame will not fit with the existing frame, causing the queued frame
2863 // to be serialized, and it will be added to a new open packet.
2864 MakeIOVector("bar", &iov_);
2865 consumed = creator_.ConsumeData(
2866 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2867 Perspective::IS_CLIENT),
2868 &iov_, 1u, iov_.iov_len, 3, FIN);
2869 EXPECT_EQ(3u, consumed.bytes_consumed);
2870 EXPECT_TRUE(consumed.fin_consumed);
2871 EXPECT_TRUE(creator_.HasPendingFrames());
2872 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
2873
2874 creator_.FlushCurrentPacket();
2875 EXPECT_FALSE(creator_.HasPendingFrames());
2876 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2877
2878 PacketContents contents;
2879 contents.num_stream_frames = 1;
2880 CheckPacketContains(contents, 0);
2881 CheckPacketContains(contents, 1);
2882 }
2883
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataFastPath)2884 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataFastPath) {
2885 delegate_.SetCanWriteAnything();
2886 creator_.SetTransmissionType(LOSS_RETRANSMISSION);
2887
2888 // Create a 10000 byte IOVector.
2889 CreateData(10000);
2890 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2891 .WillRepeatedly(
2892 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2893 QuicConsumedData consumed = creator_.ConsumeDataFastPath(
2894 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2895 Perspective::IS_CLIENT),
2896 &iov_, 1u, iov_.iov_len, 0, true);
2897 EXPECT_EQ(10000u, consumed.bytes_consumed);
2898 EXPECT_TRUE(consumed.fin_consumed);
2899 EXPECT_FALSE(creator_.HasPendingFrames());
2900 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2901
2902 PacketContents contents;
2903 contents.num_stream_frames = 1;
2904 CheckPacketContains(contents, 0);
2905 EXPECT_FALSE(packets_.empty());
2906 SerializedPacket packet = packets_.back();
2907 EXPECT_TRUE(!packet.retransmittable_frames.empty());
2908 EXPECT_EQ(LOSS_RETRANSMISSION, packet.transmission_type);
2909 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
2910 const QuicStreamFrame& stream_frame =
2911 packet.retransmittable_frames.front().stream_frame;
2912 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
2913 }
2914
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLarge)2915 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLarge) {
2916 delegate_.SetCanWriteAnything();
2917
2918 // Create a 10000 byte IOVector.
2919 CreateData(10000);
2920 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2921 .WillRepeatedly(
2922 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2923 QuicConsumedData consumed = creator_.ConsumeData(
2924 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2925 Perspective::IS_CLIENT),
2926 &iov_, 1u, iov_.iov_len, 0, FIN);
2927 EXPECT_EQ(10000u, consumed.bytes_consumed);
2928 EXPECT_TRUE(consumed.fin_consumed);
2929 EXPECT_FALSE(creator_.HasPendingFrames());
2930 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2931
2932 PacketContents contents;
2933 contents.num_stream_frames = 1;
2934 CheckPacketContains(contents, 0);
2935 EXPECT_FALSE(packets_.empty());
2936 SerializedPacket packet = packets_.back();
2937 EXPECT_TRUE(!packet.retransmittable_frames.empty());
2938 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
2939 const QuicStreamFrame& stream_frame =
2940 packet.retransmittable_frames.front().stream_frame;
2941 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
2942 }
2943
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLargeSendAckFalse)2944 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLargeSendAckFalse) {
2945 delegate_.SetCanNotWrite();
2946
2947 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
2948 const bool success =
2949 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2950 /*bundle_ack=*/true);
2951 EXPECT_FALSE(success);
2952 EXPECT_FALSE(creator_.HasPendingFrames());
2953 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2954
2955 delegate_.SetCanWriteAnything();
2956
2957 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
2958 /*bundle_ack=*/false);
2959
2960 // Create a 10000 byte IOVector.
2961 CreateData(10000);
2962 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2963 .WillRepeatedly(
2964 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2965 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateRstStreamFrame()),
2966 /*bundle_ack=*/true);
2967 QuicConsumedData consumed = creator_.ConsumeData(
2968 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2969 Perspective::IS_CLIENT),
2970 &iov_, 1u, iov_.iov_len, 0, FIN);
2971 creator_.Flush();
2972
2973 EXPECT_EQ(10000u, consumed.bytes_consumed);
2974 EXPECT_TRUE(consumed.fin_consumed);
2975 EXPECT_FALSE(creator_.HasPendingFrames());
2976 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
2977
2978 EXPECT_FALSE(packets_.empty());
2979 SerializedPacket packet = packets_.back();
2980 EXPECT_TRUE(!packet.retransmittable_frames.empty());
2981 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
2982 const QuicStreamFrame& stream_frame =
2983 packet.retransmittable_frames.front().stream_frame;
2984 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
2985 }
2986
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConsumeDataLargeSendAckTrue)2987 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConsumeDataLargeSendAckTrue) {
2988 delegate_.SetCanNotWrite();
2989 delegate_.SetCanWriteAnything();
2990
2991 // Create a 10000 byte IOVector.
2992 CreateData(10000);
2993 EXPECT_CALL(delegate_, OnSerializedPacket(_))
2994 .WillRepeatedly(
2995 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
2996 QuicConsumedData consumed = creator_.ConsumeData(
2997 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
2998 Perspective::IS_CLIENT),
2999 &iov_, 1u, iov_.iov_len, 0, FIN);
3000 creator_.Flush();
3001
3002 EXPECT_EQ(10000u, consumed.bytes_consumed);
3003 EXPECT_TRUE(consumed.fin_consumed);
3004 EXPECT_FALSE(creator_.HasPendingFrames());
3005 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3006
3007 EXPECT_FALSE(packets_.empty());
3008 SerializedPacket packet = packets_.back();
3009 EXPECT_TRUE(!packet.retransmittable_frames.empty());
3010 EXPECT_EQ(STREAM_FRAME, packet.retransmittable_frames.front().type);
3011 const QuicStreamFrame& stream_frame =
3012 packet.retransmittable_frames.front().stream_frame;
3013 EXPECT_EQ(10000u, stream_frame.data_length + stream_frame.offset);
3014 }
3015
TEST_F(QuicPacketCreatorMultiplePacketsTest,NotWritableThenBatchOperations)3016 TEST_F(QuicPacketCreatorMultiplePacketsTest, NotWritableThenBatchOperations) {
3017 delegate_.SetCanNotWrite();
3018
3019 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
3020 const bool consumed =
3021 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3022 /*bundle_ack=*/true);
3023 EXPECT_FALSE(consumed);
3024 EXPECT_FALSE(creator_.HasPendingFrames());
3025 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3026 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(3));
3027
3028 delegate_.SetCanWriteAnything();
3029
3030 EXPECT_TRUE(
3031 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3032 /*bundle_ack=*/false));
3033 // Send some data and a control frame
3034 MakeIOVector("quux", &iov_);
3035 creator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
3036 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3037 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateGoAwayFrame()),
3038 /*bundle_ack=*/false);
3039 }
3040 EXPECT_TRUE(creator_.HasPendingStreamFramesOfStream(3));
3041
3042 // All five frames will be flushed out in a single packet.
3043 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3044 .WillOnce(
3045 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3046 creator_.Flush();
3047 EXPECT_FALSE(creator_.HasPendingFrames());
3048 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3049 EXPECT_FALSE(creator_.HasPendingStreamFramesOfStream(3));
3050
3051 PacketContents contents;
3052 // ACK will be flushed by connection.
3053 contents.num_ack_frames = 0;
3054 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3055 contents.num_goaway_frames = 1;
3056 } else {
3057 contents.num_goaway_frames = 0;
3058 }
3059 contents.num_rst_stream_frames = 1;
3060 contents.num_stream_frames = 1;
3061 CheckPacketContains(contents, 0);
3062 }
3063
TEST_F(QuicPacketCreatorMultiplePacketsTest,NotWritableThenBatchOperations2)3064 TEST_F(QuicPacketCreatorMultiplePacketsTest, NotWritableThenBatchOperations2) {
3065 delegate_.SetCanNotWrite();
3066
3067 QuicRstStreamFrame* rst_frame = CreateRstStreamFrame();
3068 const bool success =
3069 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3070 /*bundle_ack=*/true);
3071 EXPECT_FALSE(success);
3072 EXPECT_FALSE(creator_.HasPendingFrames());
3073 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3074
3075 delegate_.SetCanWriteAnything();
3076
3077 {
3078 InSequence dummy;
3079 // All five frames will be flushed out in a single packet
3080 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3081 .WillOnce(
3082 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3083 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3084 .WillOnce(
3085 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3086 }
3087 EXPECT_TRUE(
3088 creator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
3089 /*bundle_ack=*/false));
3090 // Send enough data to exceed one packet
3091 size_t data_len = kDefaultMaxPacketSize + 100;
3092 CreateData(data_len);
3093 QuicConsumedData consumed =
3094 creator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 0, FIN);
3095 EXPECT_EQ(data_len, consumed.bytes_consumed);
3096 EXPECT_TRUE(consumed.fin_consumed);
3097 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3098 creator_.ConsumeRetransmittableControlFrame(QuicFrame(CreateGoAwayFrame()),
3099 /*bundle_ack=*/false);
3100 }
3101
3102 creator_.Flush();
3103 EXPECT_FALSE(creator_.HasPendingFrames());
3104 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3105
3106 // The first packet should have the queued data and part of the stream data.
3107 PacketContents contents;
3108 // ACK will be sent by connection.
3109 contents.num_ack_frames = 0;
3110 contents.num_rst_stream_frames = 1;
3111 contents.num_stream_frames = 1;
3112 CheckPacketContains(contents, 0);
3113
3114 // The second should have the remainder of the stream data.
3115 PacketContents contents2;
3116 if (!VersionHasIetfQuicFrames(framer_.transport_version())) {
3117 contents2.num_goaway_frames = 1;
3118 } else {
3119 contents2.num_goaway_frames = 0;
3120 }
3121 contents2.num_stream_frames = 1;
3122 CheckPacketContains(contents2, 1);
3123 }
3124
3125 // Regression test of b/120493795.
TEST_F(QuicPacketCreatorMultiplePacketsTest,PacketTransmissionType)3126 TEST_F(QuicPacketCreatorMultiplePacketsTest, PacketTransmissionType) {
3127 delegate_.SetCanWriteAnything();
3128
3129 // The first ConsumeData will fill the packet without flush.
3130 creator_.SetTransmissionType(LOSS_RETRANSMISSION);
3131
3132 size_t data_len = 1324;
3133 CreateData(data_len);
3134 QuicStreamId stream1_id = QuicUtils::GetFirstBidirectionalStreamId(
3135 framer_.transport_version(), Perspective::IS_CLIENT);
3136 QuicConsumedData consumed =
3137 creator_.ConsumeData(stream1_id, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
3138 EXPECT_EQ(data_len, consumed.bytes_consumed);
3139 ASSERT_EQ(0u, creator_.BytesFree())
3140 << "Test setup failed: Please increase data_len to "
3141 << data_len + creator_.BytesFree() << " bytes.";
3142
3143 // The second ConsumeData can not be added to the packet and will flush.
3144 creator_.SetTransmissionType(NOT_RETRANSMISSION);
3145
3146 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3147 .WillOnce(
3148 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3149
3150 QuicStreamId stream2_id = stream1_id + 4;
3151
3152 consumed =
3153 creator_.ConsumeData(stream2_id, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
3154 EXPECT_EQ(data_len, consumed.bytes_consumed);
3155
3156 // Ensure the packet is successfully created.
3157 ASSERT_EQ(1u, packets_.size());
3158 ASSERT_TRUE(packets_[0].encrypted_buffer);
3159 ASSERT_EQ(1u, packets_[0].retransmittable_frames.size());
3160 EXPECT_EQ(stream1_id,
3161 packets_[0].retransmittable_frames[0].stream_frame.stream_id);
3162
3163 // Since the second frame was not added, the packet's transmission type
3164 // should be the first frame's type.
3165 EXPECT_EQ(packets_[0].transmission_type, LOSS_RETRANSMISSION);
3166 }
3167
TEST_F(QuicPacketCreatorMultiplePacketsTest,TestConnectionIdLength)3168 TEST_F(QuicPacketCreatorMultiplePacketsTest, TestConnectionIdLength) {
3169 QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
3170 creator_.SetServerConnectionIdLength(0);
3171 EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
3172 creator_.GetDestinationConnectionIdLength());
3173
3174 for (size_t i = 1; i < 10; i++) {
3175 creator_.SetServerConnectionIdLength(i);
3176 if (VersionHasIetfInvariantHeader(framer_.transport_version())) {
3177 EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID,
3178 creator_.GetDestinationConnectionIdLength());
3179 } else {
3180 EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID,
3181 creator_.GetDestinationConnectionIdLength());
3182 }
3183 }
3184 }
3185
3186 // Test whether SetMaxPacketLength() works in the situation when the queue is
3187 // empty, and we send three packets worth of data.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_Initial)3188 TEST_F(QuicPacketCreatorMultiplePacketsTest, SetMaxPacketLength_Initial) {
3189 delegate_.SetCanWriteAnything();
3190
3191 // Send enough data for three packets.
3192 size_t data_len = 3 * kDefaultMaxPacketSize + 1;
3193 size_t packet_len = kDefaultMaxPacketSize + 100;
3194 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3195 creator_.SetMaxPacketLength(packet_len);
3196 EXPECT_EQ(packet_len, creator_.max_packet_length());
3197
3198 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3199 .Times(3)
3200 .WillRepeatedly(
3201 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3202 CreateData(data_len);
3203 QuicConsumedData consumed = creator_.ConsumeData(
3204 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3205 Perspective::IS_CLIENT),
3206 &iov_, 1u, iov_.iov_len,
3207 /*offset=*/0, FIN);
3208 EXPECT_EQ(data_len, consumed.bytes_consumed);
3209 EXPECT_TRUE(consumed.fin_consumed);
3210 EXPECT_FALSE(creator_.HasPendingFrames());
3211 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3212
3213 // We expect three packets, and first two of them have to be of packet_len
3214 // size. We check multiple packets (instead of just one) because we want to
3215 // ensure that |max_packet_length_| does not get changed incorrectly by the
3216 // creator after first packet is serialized.
3217 ASSERT_EQ(3u, packets_.size());
3218 EXPECT_EQ(packet_len, packets_[0].encrypted_length);
3219 EXPECT_EQ(packet_len, packets_[1].encrypted_length);
3220 CheckAllPacketsHaveSingleStreamFrame();
3221 }
3222
3223 // Test whether SetMaxPacketLength() works in the situation when we first write
3224 // data, then change packet size, then write data again.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_Middle)3225 TEST_F(QuicPacketCreatorMultiplePacketsTest, SetMaxPacketLength_Middle) {
3226 delegate_.SetCanWriteAnything();
3227
3228 // We send enough data to overflow default packet length, but not the altered
3229 // one.
3230 size_t data_len = kDefaultMaxPacketSize;
3231 size_t packet_len = kDefaultMaxPacketSize + 100;
3232 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3233
3234 // We expect to see three packets in total.
3235 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3236 .Times(3)
3237 .WillRepeatedly(
3238 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3239
3240 // Send two packets before packet size change.
3241 CreateData(data_len);
3242 QuicConsumedData consumed = creator_.ConsumeData(
3243 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3244 Perspective::IS_CLIENT),
3245 &iov_, 1u, iov_.iov_len,
3246 /*offset=*/0, NO_FIN);
3247 creator_.Flush();
3248 EXPECT_EQ(data_len, consumed.bytes_consumed);
3249 EXPECT_FALSE(consumed.fin_consumed);
3250 EXPECT_FALSE(creator_.HasPendingFrames());
3251 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3252
3253 // Make sure we already have two packets.
3254 ASSERT_EQ(2u, packets_.size());
3255
3256 // Increase packet size.
3257 creator_.SetMaxPacketLength(packet_len);
3258 EXPECT_EQ(packet_len, creator_.max_packet_length());
3259
3260 // Send a packet after packet size change.
3261 CreateData(data_len);
3262 creator_.AttachPacketFlusher();
3263 consumed = creator_.ConsumeData(
3264 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3265 Perspective::IS_CLIENT),
3266 &iov_, 1u, iov_.iov_len, data_len, FIN);
3267 creator_.Flush();
3268 EXPECT_EQ(data_len, consumed.bytes_consumed);
3269 EXPECT_TRUE(consumed.fin_consumed);
3270 EXPECT_FALSE(creator_.HasPendingFrames());
3271 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3272
3273 // We expect first data chunk to get fragmented, but the second one to fit
3274 // into a single packet.
3275 ASSERT_EQ(3u, packets_.size());
3276 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3277 EXPECT_LE(kDefaultMaxPacketSize, packets_[2].encrypted_length);
3278 CheckAllPacketsHaveSingleStreamFrame();
3279 }
3280
3281 // Test whether SetMaxPacketLength() works correctly when we force the change of
3282 // the packet size in the middle of the batched packet.
TEST_F(QuicPacketCreatorMultiplePacketsTest,SetMaxPacketLength_MidpacketFlush)3283 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3284 SetMaxPacketLength_MidpacketFlush) {
3285 delegate_.SetCanWriteAnything();
3286
3287 size_t first_write_len = kDefaultMaxPacketSize / 2;
3288 size_t packet_len = kDefaultMaxPacketSize + 100;
3289 size_t second_write_len = packet_len + 1;
3290 ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
3291
3292 // First send half of the packet worth of data. We are in the batch mode, so
3293 // should not cause packet serialization.
3294 CreateData(first_write_len);
3295 QuicConsumedData consumed = creator_.ConsumeData(
3296 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3297 Perspective::IS_CLIENT),
3298 &iov_, 1u, iov_.iov_len,
3299 /*offset=*/0, NO_FIN);
3300 EXPECT_EQ(first_write_len, consumed.bytes_consumed);
3301 EXPECT_FALSE(consumed.fin_consumed);
3302 EXPECT_TRUE(creator_.HasPendingFrames());
3303 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3304
3305 // Make sure we have no packets so far.
3306 ASSERT_EQ(0u, packets_.size());
3307
3308 // Expect a packet to be flushed.
3309 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3310 .WillOnce(
3311 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3312
3313 // Increase packet size after flushing all frames.
3314 // Ensure it's immediately enacted.
3315 creator_.FlushCurrentPacket();
3316 creator_.SetMaxPacketLength(packet_len);
3317 EXPECT_EQ(packet_len, creator_.max_packet_length());
3318 EXPECT_FALSE(creator_.HasPendingFrames());
3319 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3320
3321 // We expect to see exactly one packet serialized after that, because we send
3322 // a value somewhat exceeding new max packet size, and the tail data does not
3323 // get serialized because we are still in the batch mode.
3324 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3325 .WillOnce(
3326 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3327
3328 // Send a more than a packet worth of data to the same stream. This should
3329 // trigger serialization of one packet, and queue another one.
3330 CreateData(second_write_len);
3331 consumed = creator_.ConsumeData(
3332 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3333 Perspective::IS_CLIENT),
3334 &iov_, 1u, iov_.iov_len,
3335 /*offset=*/first_write_len, FIN);
3336 EXPECT_EQ(second_write_len, consumed.bytes_consumed);
3337 EXPECT_TRUE(consumed.fin_consumed);
3338 EXPECT_TRUE(creator_.HasPendingFrames());
3339 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3340
3341 // We expect the first packet to be underfilled, and the second packet be up
3342 // to the new max packet size.
3343 ASSERT_EQ(2u, packets_.size());
3344 EXPECT_GT(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3345 EXPECT_EQ(packet_len, packets_[1].encrypted_length);
3346
3347 CheckAllPacketsHaveSingleStreamFrame();
3348 }
3349
3350 // Test sending a connectivity probing packet.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateConnectivityProbingPacket)3351 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3352 GenerateConnectivityProbingPacket) {
3353 delegate_.SetCanWriteAnything();
3354
3355 OwningSerializedPacketPointer probing_packet;
3356 if (VersionHasIetfQuicFrames(framer_.transport_version())) {
3357 QuicPathFrameBuffer payload = {
3358 {0xde, 0xad, 0xbe, 0xef, 0xba, 0xdc, 0x0f, 0xfe}};
3359 probing_packet =
3360 creator_.SerializePathChallengeConnectivityProbingPacket(&payload);
3361 } else {
3362 probing_packet = creator_.SerializeConnectivityProbingPacket();
3363 }
3364
3365 ASSERT_TRUE(simple_framer_.ProcessPacket(QuicEncryptedPacket(
3366 probing_packet->encrypted_buffer, probing_packet->encrypted_length)));
3367
3368 EXPECT_EQ(2u, simple_framer_.num_frames());
3369 if (VersionHasIetfQuicFrames(framer_.transport_version())) {
3370 EXPECT_EQ(1u, simple_framer_.path_challenge_frames().size());
3371 } else {
3372 EXPECT_EQ(1u, simple_framer_.ping_frames().size());
3373 }
3374 EXPECT_EQ(1u, simple_framer_.padding_frames().size());
3375 }
3376
3377 // Test sending an MTU probe, without any surrounding data.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateMtuDiscoveryPacket_Simple)3378 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3379 GenerateMtuDiscoveryPacket_Simple) {
3380 delegate_.SetCanWriteAnything();
3381
3382 const size_t target_mtu = kDefaultMaxPacketSize + 100;
3383 static_assert(target_mtu < kMaxOutgoingPacketSize,
3384 "The MTU probe used by the test exceeds maximum packet size");
3385
3386 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3387 .WillOnce(
3388 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3389
3390 creator_.GenerateMtuDiscoveryPacket(target_mtu);
3391
3392 EXPECT_FALSE(creator_.HasPendingFrames());
3393 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3394 ASSERT_EQ(1u, packets_.size());
3395 EXPECT_EQ(target_mtu, packets_[0].encrypted_length);
3396
3397 PacketContents contents;
3398 contents.num_mtu_discovery_frames = 1;
3399 contents.num_padding_frames = 1;
3400 CheckPacketContains(contents, 0);
3401 }
3402
3403 // Test sending an MTU probe. Surround it with data, to ensure that it resets
3404 // the MTU to the value before the probe was sent.
TEST_F(QuicPacketCreatorMultiplePacketsTest,GenerateMtuDiscoveryPacket_SurroundedByData)3405 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3406 GenerateMtuDiscoveryPacket_SurroundedByData) {
3407 delegate_.SetCanWriteAnything();
3408
3409 const size_t target_mtu = kDefaultMaxPacketSize + 100;
3410 static_assert(target_mtu < kMaxOutgoingPacketSize,
3411 "The MTU probe used by the test exceeds maximum packet size");
3412
3413 // Send enough data so it would always cause two packets to be sent.
3414 const size_t data_len = target_mtu + 1;
3415
3416 // Send a total of five packets: two packets before the probe, the probe
3417 // itself, and two packets after the probe.
3418 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3419 .Times(5)
3420 .WillRepeatedly(
3421 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3422
3423 // Send data before the MTU probe.
3424 CreateData(data_len);
3425 QuicConsumedData consumed = creator_.ConsumeData(
3426 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3427 Perspective::IS_CLIENT),
3428 &iov_, 1u, iov_.iov_len,
3429 /*offset=*/0, NO_FIN);
3430 creator_.Flush();
3431 EXPECT_EQ(data_len, consumed.bytes_consumed);
3432 EXPECT_FALSE(consumed.fin_consumed);
3433 EXPECT_FALSE(creator_.HasPendingFrames());
3434 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3435
3436 // Send the MTU probe.
3437 creator_.GenerateMtuDiscoveryPacket(target_mtu);
3438 EXPECT_FALSE(creator_.HasPendingFrames());
3439 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3440
3441 // Send data after the MTU probe.
3442 CreateData(data_len);
3443 creator_.AttachPacketFlusher();
3444 consumed = creator_.ConsumeData(
3445 QuicUtils::GetFirstBidirectionalStreamId(framer_.transport_version(),
3446 Perspective::IS_CLIENT),
3447 &iov_, 1u, iov_.iov_len,
3448 /*offset=*/data_len, FIN);
3449 creator_.Flush();
3450 EXPECT_EQ(data_len, consumed.bytes_consumed);
3451 EXPECT_TRUE(consumed.fin_consumed);
3452 EXPECT_FALSE(creator_.HasPendingFrames());
3453 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3454
3455 ASSERT_EQ(5u, packets_.size());
3456 EXPECT_EQ(kDefaultMaxPacketSize, packets_[0].encrypted_length);
3457 EXPECT_EQ(target_mtu, packets_[2].encrypted_length);
3458 EXPECT_EQ(kDefaultMaxPacketSize, packets_[3].encrypted_length);
3459
3460 PacketContents probe_contents;
3461 probe_contents.num_mtu_discovery_frames = 1;
3462 probe_contents.num_padding_frames = 1;
3463
3464 CheckPacketHasSingleStreamFrame(0);
3465 CheckPacketHasSingleStreamFrame(1);
3466 CheckPacketContains(probe_contents, 2);
3467 CheckPacketHasSingleStreamFrame(3);
3468 CheckPacketHasSingleStreamFrame(4);
3469 }
3470
TEST_F(QuicPacketCreatorMultiplePacketsTest,DontCrashOnInvalidStopWaiting)3471 TEST_F(QuicPacketCreatorMultiplePacketsTest, DontCrashOnInvalidStopWaiting) {
3472 if (VersionSupportsMessageFrames(framer_.transport_version())) {
3473 return;
3474 }
3475 // Test added to ensure the creator does not crash when an invalid frame is
3476 // added. Because this is an indication of internal programming errors,
3477 // DFATALs are expected.
3478 // A 1 byte packet number length can't encode a gap of 1000.
3479 QuicPacketCreatorPeer::SetPacketNumber(&creator_, 1000);
3480
3481 delegate_.SetCanNotWrite();
3482 delegate_.SetCanWriteAnything();
3483
3484 // This will not serialize any packets, because of the invalid frame.
3485 EXPECT_CALL(delegate_,
3486 OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET, _));
3487 EXPECT_QUIC_BUG(creator_.Flush(),
3488 "packet_number_length 1 is too small "
3489 "for least_unacked_delta: 1001");
3490 }
3491
3492 // Regression test for b/31486443.
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConnectionCloseFrameLargerThanPacketSize)3493 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3494 ConnectionCloseFrameLargerThanPacketSize) {
3495 delegate_.SetCanWriteAnything();
3496 char buf[2000] = {};
3497 quiche::QuicheStringPiece error_details(buf, 2000);
3498 const QuicErrorCode kQuicErrorCode = QUIC_PACKET_WRITE_ERROR;
3499
3500 QuicConnectionCloseFrame* frame = new QuicConnectionCloseFrame(
3501 framer_.transport_version(), kQuicErrorCode, std::string(error_details),
3502 /*transport_close_frame_type=*/0);
3503 creator_.ConsumeRetransmittableControlFrame(QuicFrame(frame),
3504 /*bundle_ack=*/false);
3505 EXPECT_TRUE(creator_.HasPendingFrames());
3506 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3507 }
3508
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinSingleStreamSinglePacket)3509 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3510 RandomPaddingAfterFinSingleStreamSinglePacket) {
3511 const QuicByteCount kStreamFramePayloadSize = 100u;
3512 char buf[kStreamFramePayloadSize] = {};
3513 const QuicStreamId kDataStreamId = 5;
3514 // Set the packet size be enough for one stream frame with 0 stream offset and
3515 // max size of random padding.
3516 size_t length =
3517 NullEncrypter(Perspective::IS_CLIENT).GetCiphertextSize(0) +
3518 GetPacketHeaderSize(
3519 framer_.transport_version(),
3520 creator_.GetDestinationConnectionIdLength(),
3521 creator_.GetSourceConnectionIdLength(),
3522 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3523 !kIncludeDiversificationNonce,
3524 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3525 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3526 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3527 QuicFramer::GetMinStreamFrameSize(
3528 framer_.transport_version(), kDataStreamId, 0,
3529 /*last_frame_in_packet=*/false,
3530 kStreamFramePayloadSize + kMaxNumRandomPaddingBytes) +
3531 kStreamFramePayloadSize + kMaxNumRandomPaddingBytes;
3532 creator_.SetMaxPacketLength(length);
3533 delegate_.SetCanWriteAnything();
3534 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3535 .WillOnce(
3536 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3537 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
3538 QuicConsumedData consumed = creator_.ConsumeData(
3539 kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
3540 creator_.Flush();
3541 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3542 EXPECT_FALSE(creator_.HasPendingFrames());
3543 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3544
3545 EXPECT_EQ(1u, packets_.size());
3546 PacketContents contents;
3547 // The packet has both stream and padding frames.
3548 contents.num_padding_frames = 1;
3549 contents.num_stream_frames = 1;
3550 CheckPacketContains(contents, 0);
3551 }
3552
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinSingleStreamMultiplePackets)3553 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3554 RandomPaddingAfterFinSingleStreamMultiplePackets) {
3555 const QuicByteCount kStreamFramePayloadSize = 100u;
3556 char buf[kStreamFramePayloadSize] = {};
3557 const QuicStreamId kDataStreamId = 5;
3558 // Set the packet size be enough for one stream frame with 0 stream offset +
3559 // 1. One or more packets will accommodate.
3560 size_t length =
3561 NullEncrypter(Perspective::IS_CLIENT).GetCiphertextSize(0) +
3562 GetPacketHeaderSize(
3563 framer_.transport_version(),
3564 creator_.GetDestinationConnectionIdLength(),
3565 creator_.GetSourceConnectionIdLength(),
3566 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3567 !kIncludeDiversificationNonce,
3568 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3569 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3570 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3571 QuicFramer::GetMinStreamFrameSize(
3572 framer_.transport_version(), kDataStreamId, 0,
3573 /*last_frame_in_packet=*/false, kStreamFramePayloadSize + 1) +
3574 kStreamFramePayloadSize + 1;
3575 creator_.SetMaxPacketLength(length);
3576 delegate_.SetCanWriteAnything();
3577 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3578 .WillRepeatedly(
3579 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3580 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
3581 QuicConsumedData consumed = creator_.ConsumeData(
3582 kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
3583 creator_.Flush();
3584 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3585 EXPECT_FALSE(creator_.HasPendingFrames());
3586 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3587
3588 EXPECT_LE(1u, packets_.size());
3589 PacketContents contents;
3590 // The first packet has both stream and padding frames.
3591 contents.num_stream_frames = 1;
3592 contents.num_padding_frames = 1;
3593 CheckPacketContains(contents, 0);
3594
3595 for (size_t i = 1; i < packets_.size(); ++i) {
3596 // Following packets only have paddings.
3597 contents.num_stream_frames = 0;
3598 contents.num_padding_frames = 1;
3599 CheckPacketContains(contents, i);
3600 }
3601 }
3602
TEST_F(QuicPacketCreatorMultiplePacketsTest,RandomPaddingAfterFinMultipleStreamsMultiplePackets)3603 TEST_F(QuicPacketCreatorMultiplePacketsTest,
3604 RandomPaddingAfterFinMultipleStreamsMultiplePackets) {
3605 const QuicByteCount kStreamFramePayloadSize = 100u;
3606 char buf[kStreamFramePayloadSize] = {};
3607 const QuicStreamId kDataStreamId1 = 5;
3608 const QuicStreamId kDataStreamId2 = 6;
3609 // Set the packet size be enough for first frame with 0 stream offset + second
3610 // frame + 1 byte payload. two or more packets will accommodate.
3611 size_t length =
3612 NullEncrypter(Perspective::IS_CLIENT).GetCiphertextSize(0) +
3613 GetPacketHeaderSize(
3614 framer_.transport_version(),
3615 creator_.GetDestinationConnectionIdLength(),
3616 creator_.GetSourceConnectionIdLength(),
3617 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
3618 !kIncludeDiversificationNonce,
3619 QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
3620 QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_), 0,
3621 QuicPacketCreatorPeer::GetLengthLength(&creator_)) +
3622 QuicFramer::GetMinStreamFrameSize(
3623 framer_.transport_version(), kDataStreamId1, 0,
3624 /*last_frame_in_packet=*/false, kStreamFramePayloadSize) +
3625 kStreamFramePayloadSize +
3626 QuicFramer::GetMinStreamFrameSize(framer_.transport_version(),
3627 kDataStreamId1, 0,
3628 /*last_frame_in_packet=*/false, 1) +
3629 1;
3630 creator_.SetMaxPacketLength(length);
3631 delegate_.SetCanWriteAnything();
3632 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3633 .WillRepeatedly(
3634 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3635 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
3636 QuicConsumedData consumed = creator_.ConsumeData(
3637 kDataStreamId1, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
3638 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3639 MakeIOVector(quiche::QuicheStringPiece(buf, kStreamFramePayloadSize), &iov_);
3640 consumed = creator_.ConsumeData(kDataStreamId2, &iov_, 1u, iov_.iov_len, 0,
3641 FIN_AND_PADDING);
3642 EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
3643 creator_.Flush();
3644 EXPECT_FALSE(creator_.HasPendingFrames());
3645 EXPECT_FALSE(creator_.HasPendingRetransmittableFrames());
3646
3647 EXPECT_LE(2u, packets_.size());
3648 PacketContents contents;
3649 // The first packet has two stream frames.
3650 contents.num_stream_frames = 2;
3651 CheckPacketContains(contents, 0);
3652
3653 // The second packet has one stream frame and padding frames.
3654 contents.num_stream_frames = 1;
3655 contents.num_padding_frames = 1;
3656 CheckPacketContains(contents, 1);
3657
3658 for (size_t i = 2; i < packets_.size(); ++i) {
3659 // Following packets only have paddings.
3660 contents.num_stream_frames = 0;
3661 contents.num_padding_frames = 1;
3662 CheckPacketContains(contents, i);
3663 }
3664 }
3665
TEST_F(QuicPacketCreatorMultiplePacketsTest,AddMessageFrame)3666 TEST_F(QuicPacketCreatorMultiplePacketsTest, AddMessageFrame) {
3667 if (!VersionSupportsMessageFrames(framer_.transport_version())) {
3668 return;
3669 }
3670 quic::QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
3671 delegate_.SetCanWriteAnything();
3672 EXPECT_CALL(delegate_, OnSerializedPacket(_))
3673 .WillOnce(
3674 Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
3675
3676 MakeIOVector("foo", &iov_);
3677 creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
3678 framer_.transport_version(), Perspective::IS_CLIENT),
3679 &iov_, 1u, iov_.iov_len, 0, FIN);
3680 EXPECT_EQ(
3681 MESSAGE_STATUS_SUCCESS,
3682 creator_.AddMessageFrame(1, MakeSpan(&allocator_, "message", &storage)));
3683 EXPECT_TRUE(creator_.HasPendingFrames());
3684 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3685
3686 // Add a message which causes the flush of current packet.
3687 EXPECT_EQ(
3688 MESSAGE_STATUS_SUCCESS,
3689 creator_.AddMessageFrame(
3690 2,
3691 MakeSpan(&allocator_,
3692 std::string(creator_.GetCurrentLargestMessagePayload(), 'a'),
3693 &storage)));
3694 EXPECT_TRUE(creator_.HasPendingRetransmittableFrames());
3695
3696 // Failed to send messages which cannot fit into one packet.
3697 EXPECT_EQ(
3698 MESSAGE_STATUS_TOO_LARGE,
3699 creator_.AddMessageFrame(
3700 3, MakeSpan(&allocator_,
3701 std::string(
3702 creator_.GetCurrentLargestMessagePayload() + 10, 'a'),
3703 &storage)));
3704 }
3705
TEST_F(QuicPacketCreatorMultiplePacketsTest,ConnectionId)3706 TEST_F(QuicPacketCreatorMultiplePacketsTest, ConnectionId) {
3707 creator_.SetServerConnectionId(TestConnectionId(0x1337));
3708 EXPECT_EQ(TestConnectionId(0x1337), creator_.GetDestinationConnectionId());
3709 EXPECT_EQ(EmptyQuicConnectionId(), creator_.GetSourceConnectionId());
3710 if (!framer_.version().SupportsClientConnectionIds()) {
3711 return;
3712 }
3713 creator_.SetClientConnectionId(TestConnectionId(0x33));
3714 EXPECT_EQ(TestConnectionId(0x1337), creator_.GetDestinationConnectionId());
3715 EXPECT_EQ(TestConnectionId(0x33), creator_.GetSourceConnectionId());
3716 }
3717
3718 } // namespace
3719 } // namespace test
3720 } // namespace quic
3721