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.
5 #include "net/quic/quic_framer.h"
12 #include "base/containers/hash_tables.h"
13 #include "base/logging.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/port.h"
16 #include "base/stl_util.h"
17 #include "net/quic/crypto/quic_decrypter.h"
18 #include "net/quic/crypto/quic_encrypter.h"
19 #include "net/quic/quic_protocol.h"
20 #include "net/quic/quic_utils.h"
21 #include "net/quic/test_tools/quic_framer_peer.h"
22 #include "net/quic/test_tools/quic_test_utils.h"
23 #include "net/test/gtest_util.h"
26 using base::StringPiece;
29 using std::numeric_limits;
33 using testing::Return;
39 const QuicPacketSequenceNumber kEpoch = GG_UINT64_C(1) << 48;
40 const QuicPacketSequenceNumber kMask = kEpoch - 1;
42 // Index into the guid offset in the header.
43 const size_t kGuidOffset = kPublicFlagsSize;
44 // Index into the version string in the header. (if present).
45 const size_t kVersionOffset = kGuidOffset + PACKET_8BYTE_GUID;
47 // Size in bytes of the stream frame fields for an arbitrary StreamID and
48 // offset and the last frame in a packet.
49 size_t GetMinStreamFrameSize(QuicVersion version) {
50 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
53 // Index into the sequence number offset in the header.
54 size_t GetSequenceNumberOffset(QuicGuidLength guid_length,
55 bool include_version) {
56 return kGuidOffset + guid_length +
57 (include_version ? kQuicVersionSize : 0);
60 size_t GetSequenceNumberOffset(bool include_version) {
61 return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version);
64 // Index into the private flags offset in the data packet header.
65 size_t GetPrivateFlagsOffset(QuicGuidLength guid_length, bool include_version) {
66 return GetSequenceNumberOffset(guid_length, include_version) +
67 PACKET_6BYTE_SEQUENCE_NUMBER;
70 size_t GetPrivateFlagsOffset(bool include_version) {
71 return GetPrivateFlagsOffset(PACKET_8BYTE_GUID, include_version);
74 size_t GetPrivateFlagsOffset(bool include_version,
75 QuicSequenceNumberLength sequence_number_length) {
76 return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version) +
77 sequence_number_length;
80 // Index into the fec group offset in the header.
81 size_t GetFecGroupOffset(QuicGuidLength guid_length, bool include_version) {
82 return GetPrivateFlagsOffset(guid_length, include_version) +
86 size_t GetFecGroupOffset(bool include_version) {
87 return GetPrivateFlagsOffset(PACKET_8BYTE_GUID, include_version) +
91 size_t GetFecGroupOffset(bool include_version,
92 QuicSequenceNumberLength sequence_number_length) {
93 return GetPrivateFlagsOffset(include_version, sequence_number_length) +
97 // Index into the message tag of the public reset packet.
98 // Public resets always have full guids.
99 const size_t kPublicResetPacketMessageTagOffset =
100 kGuidOffset + PACKET_8BYTE_GUID;
102 // TODO(wtc): remove this when we drop support for QUIC_VERSION_13.
103 // Index into the nonce proof of the public reset packet.
104 // Public resets always have full guids.
105 const size_t kPublicResetPacketNonceProofOffset =
106 kGuidOffset + PACKET_8BYTE_GUID;
108 // TODO(wtc): remove this when we drop support for QUIC_VERSION_13.
109 // Index into the rejected sequence number of the public reset packet.
110 const size_t kPublicResetPacketRejectedSequenceNumberOffset =
111 kPublicResetPacketNonceProofOffset + kPublicResetNonceSize;
113 class TestEncrypter : public QuicEncrypter {
115 virtual ~TestEncrypter() {}
116 virtual bool SetKey(StringPiece key) OVERRIDE {
119 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
122 virtual bool Encrypt(StringPiece nonce,
123 StringPiece associated_data,
124 StringPiece plaintext,
125 unsigned char* output) OVERRIDE {
126 CHECK(false) << "Not implemented";
129 virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
130 StringPiece associated_data,
131 StringPiece plaintext) OVERRIDE {
132 sequence_number_ = sequence_number;
133 associated_data_ = associated_data.as_string();
134 plaintext_ = plaintext.as_string();
135 return new QuicData(plaintext.data(), plaintext.length());
137 virtual size_t GetKeySize() const OVERRIDE {
140 virtual size_t GetNoncePrefixSize() const OVERRIDE {
143 virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
144 return ciphertext_size;
146 virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
147 return plaintext_size;
149 virtual StringPiece GetKey() const OVERRIDE {
150 return StringPiece();
152 virtual StringPiece GetNoncePrefix() const OVERRIDE {
153 return StringPiece();
155 QuicPacketSequenceNumber sequence_number_;
156 string associated_data_;
160 class TestDecrypter : public QuicDecrypter {
162 virtual ~TestDecrypter() {}
163 virtual bool SetKey(StringPiece key) OVERRIDE {
166 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
169 virtual bool Decrypt(StringPiece nonce,
170 StringPiece associated_data,
171 StringPiece ciphertext,
172 unsigned char* output,
173 size_t* output_length) OVERRIDE {
174 CHECK(false) << "Not implemented";
177 virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
178 StringPiece associated_data,
179 StringPiece ciphertext) OVERRIDE {
180 sequence_number_ = sequence_number;
181 associated_data_ = associated_data.as_string();
182 ciphertext_ = ciphertext.as_string();
183 return new QuicData(ciphertext.data(), ciphertext.length());
185 virtual StringPiece GetKey() const OVERRIDE {
186 return StringPiece();
188 virtual StringPiece GetNoncePrefix() const OVERRIDE {
189 return StringPiece();
191 QuicPacketSequenceNumber sequence_number_;
192 string associated_data_;
196 class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
200 version_mismatch_(0),
204 complete_packets_(0),
206 accept_packet_(true),
207 accept_public_header_(true) {
210 virtual ~TestQuicVisitor() {
211 STLDeleteElements(&stream_frames_);
212 STLDeleteElements(&ack_frames_);
213 STLDeleteElements(&congestion_feedback_frames_);
214 STLDeleteElements(&fec_data_);
217 virtual void OnError(QuicFramer* f) OVERRIDE {
218 DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
219 << " (" << f->error() << ")";
223 virtual void OnPacket() OVERRIDE {}
225 virtual void OnPublicResetPacket(
226 const QuicPublicResetPacket& packet) OVERRIDE {
227 public_reset_packet_.reset(new QuicPublicResetPacket(packet));
230 virtual void OnVersionNegotiationPacket(
231 const QuicVersionNegotiationPacket& packet) OVERRIDE {
232 version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
235 virtual void OnRevivedPacket() OVERRIDE {
239 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
240 DVLOG(1) << "QuicFramer Version Mismatch, version: " << version;
245 virtual bool OnUnauthenticatedPublicHeader(
246 const QuicPacketPublicHeader& header) OVERRIDE {
247 public_header_.reset(new QuicPacketPublicHeader(header));
248 return accept_public_header_;
251 virtual bool OnUnauthenticatedHeader(
252 const QuicPacketHeader& header) OVERRIDE {
256 virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
258 header_.reset(new QuicPacketHeader(header));
259 return accept_packet_;
262 virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
264 stream_frames_.push_back(new QuicStreamFrame(frame));
268 virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {
269 fec_protected_payload_ = payload.as_string();
272 virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
274 ack_frames_.push_back(new QuicAckFrame(frame));
278 virtual bool OnCongestionFeedbackFrame(
279 const QuicCongestionFeedbackFrame& frame) OVERRIDE {
281 congestion_feedback_frames_.push_back(
282 new QuicCongestionFeedbackFrame(frame));
286 virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
288 fec_data_.push_back(new QuicFecData(fec));
291 virtual void OnPacketComplete() OVERRIDE {
295 virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
296 rst_stream_frame_ = frame;
300 virtual bool OnConnectionCloseFrame(
301 const QuicConnectionCloseFrame& frame) OVERRIDE {
302 connection_close_frame_ = frame;
306 virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
307 goaway_frame_ = frame;
311 virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame)
313 window_update_frame_ = frame;
317 virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
318 blocked_frame_ = frame;
322 // Counters from the visitor_ callbacks.
324 int version_mismatch_;
328 int complete_packets_;
329 int revived_packets_;
331 bool accept_public_header_;
333 scoped_ptr<QuicPacketHeader> header_;
334 scoped_ptr<QuicPacketPublicHeader> public_header_;
335 scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
336 scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
337 vector<QuicStreamFrame*> stream_frames_;
338 vector<QuicAckFrame*> ack_frames_;
339 vector<QuicCongestionFeedbackFrame*> congestion_feedback_frames_;
340 vector<QuicFecData*> fec_data_;
341 string fec_protected_payload_;
342 QuicRstStreamFrame rst_stream_frame_;
343 QuicConnectionCloseFrame connection_close_frame_;
344 QuicGoAwayFrame goaway_frame_;
345 QuicWindowUpdateFrame window_update_frame_;
346 QuicBlockedFrame blocked_frame_;
349 class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> {
352 : encrypter_(new test::TestEncrypter()),
353 decrypter_(new test::TestDecrypter()),
354 start_(QuicTime::Zero().Add(QuicTime::Delta::FromMicroseconds(0x10))),
355 framer_(QuicSupportedVersions(), start_, true) {
356 version_ = GetParam();
357 framer_.set_version(version_);
358 framer_.SetDecrypter(decrypter_);
359 framer_.SetEncrypter(ENCRYPTION_NONE, encrypter_);
360 framer_.set_visitor(&visitor_);
361 framer_.set_received_entropy_calculator(&entropy_calculator_);
364 // Helper function to get unsigned char representation of digit in the
365 // units place of the current QUIC version number.
366 unsigned char GetQuicVersionDigitOnes() {
367 return static_cast<unsigned char> ('0' + version_%10);
370 // Helper function to get unsigned char representation of digit in the
371 // tens place of the current QUIC version number.
372 unsigned char GetQuicVersionDigitTens() {
373 return static_cast<unsigned char> ('0' + (version_/10)%10);
376 bool CheckEncryption(QuicPacketSequenceNumber sequence_number,
377 QuicPacket* packet) {
378 if (sequence_number != encrypter_->sequence_number_) {
379 LOG(ERROR) << "Encrypted incorrect packet sequence number. expected "
380 << sequence_number << " actual: "
381 << encrypter_->sequence_number_;
384 if (packet->AssociatedData() != encrypter_->associated_data_) {
385 LOG(ERROR) << "Encrypted incorrect associated data. expected "
386 << packet->AssociatedData() << " actual: "
387 << encrypter_->associated_data_;
390 if (packet->Plaintext() != encrypter_->plaintext_) {
391 LOG(ERROR) << "Encrypted incorrect plaintext data. expected "
392 << packet->Plaintext() << " actual: "
393 << encrypter_->plaintext_;
399 bool CheckDecryption(const QuicEncryptedPacket& encrypted,
400 bool includes_version) {
401 if (visitor_.header_->packet_sequence_number !=
402 decrypter_->sequence_number_) {
403 LOG(ERROR) << "Decrypted incorrect packet sequence number. expected "
404 << visitor_.header_->packet_sequence_number << " actual: "
405 << decrypter_->sequence_number_;
408 if (QuicFramer::GetAssociatedDataFromEncryptedPacket(
409 encrypted, PACKET_8BYTE_GUID,
410 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) !=
411 decrypter_->associated_data_) {
412 LOG(ERROR) << "Decrypted incorrect associated data. expected "
413 << QuicFramer::GetAssociatedDataFromEncryptedPacket(
414 encrypted, PACKET_8BYTE_GUID,
415 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER)
416 << " actual: " << decrypter_->associated_data_;
419 StringPiece ciphertext(encrypted.AsStringPiece().substr(
420 GetStartOfEncryptedData(PACKET_8BYTE_GUID, includes_version,
421 PACKET_6BYTE_SEQUENCE_NUMBER)));
422 if (ciphertext != decrypter_->ciphertext_) {
423 LOG(ERROR) << "Decrypted incorrect ciphertext data. expected "
424 << ciphertext << " actual: "
425 << decrypter_->ciphertext_;
431 char* AsChars(unsigned char* data) {
432 return reinterpret_cast<char*>(data);
435 void CheckProcessingFails(unsigned char* packet,
437 string expected_error,
438 QuicErrorCode error_code) {
439 QuicEncryptedPacket encrypted(AsChars(packet), len, false);
440 EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len;
441 EXPECT_EQ(expected_error, framer_.detailed_error()) << "len: " << len;
442 EXPECT_EQ(error_code, framer_.error()) << "len: " << len;
445 // Checks if the supplied string matches data in the supplied StreamFrame.
446 void CheckStreamFrameData(string str, QuicStreamFrame* frame) {
447 scoped_ptr<string> frame_data(frame->GetDataAsString());
448 EXPECT_EQ(str, *frame_data);
451 void CheckStreamFrameBoundaries(unsigned char* packet,
452 size_t stream_id_size,
453 bool include_version) {
454 // Now test framing boundaries
455 for (size_t i = kQuicFrameTypeSize;
456 i < GetMinStreamFrameSize(framer_.version()); ++i) {
457 string expected_error;
458 if (i < kQuicFrameTypeSize + stream_id_size) {
459 expected_error = "Unable to read stream_id.";
460 } else if (i < kQuicFrameTypeSize + stream_id_size +
461 kQuicMaxStreamOffsetSize) {
462 expected_error = "Unable to read offset.";
464 expected_error = "Unable to read frame data.";
466 CheckProcessingFails(
468 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, include_version,
469 PACKET_6BYTE_SEQUENCE_NUMBER,
471 expected_error, QUIC_INVALID_STREAM_DATA);
475 void CheckCalculatePacketSequenceNumber(
476 QuicPacketSequenceNumber expected_sequence_number,
477 QuicPacketSequenceNumber last_sequence_number) {
478 QuicPacketSequenceNumber wire_sequence_number =
479 expected_sequence_number & kMask;
480 QuicFramerPeer::SetLastSequenceNumber(&framer_, last_sequence_number);
481 EXPECT_EQ(expected_sequence_number,
482 QuicFramerPeer::CalculatePacketSequenceNumberFromWire(
483 &framer_, PACKET_6BYTE_SEQUENCE_NUMBER, wire_sequence_number))
484 << "last_sequence_number: " << last_sequence_number
485 << " wire_sequence_number: " << wire_sequence_number;
488 test::TestEncrypter* encrypter_;
489 test::TestDecrypter* decrypter_;
490 QuicVersion version_;
493 test::TestQuicVisitor visitor_;
494 test::TestEntropyCalculator entropy_calculator_;
497 // Run all framer tests with all supported versions of QUIC.
498 INSTANTIATE_TEST_CASE_P(QuicFramerTests,
500 ::testing::ValuesIn(kSupportedQuicVersions));
502 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochStart) {
503 // A few quick manual sanity checks
504 CheckCalculatePacketSequenceNumber(GG_UINT64_C(1), GG_UINT64_C(0));
505 CheckCalculatePacketSequenceNumber(kEpoch + 1, kMask);
506 CheckCalculatePacketSequenceNumber(kEpoch, kMask);
508 // Cases where the last number was close to the start of the range
509 for (uint64 last = 0; last < 10; last++) {
510 // Small numbers should not wrap (even if they're out of order).
511 for (uint64 j = 0; j < 10; j++) {
512 CheckCalculatePacketSequenceNumber(j, last);
515 // Large numbers should not wrap either (because we're near 0 already).
516 for (uint64 j = 0; j < 10; j++) {
517 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last);
522 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochEnd) {
523 // Cases where the last number was close to the end of the range
524 for (uint64 i = 0; i < 10; i++) {
525 QuicPacketSequenceNumber last = kEpoch - i;
527 // Small numbers should wrap.
528 for (uint64 j = 0; j < 10; j++) {
529 CheckCalculatePacketSequenceNumber(kEpoch + j, last);
532 // Large numbers should not (even if they're out of order).
533 for (uint64 j = 0; j < 10; j++) {
534 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last);
539 // Next check where we're in a non-zero epoch to verify we handle
540 // reverse wrapping, too.
541 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearPrevEpoch) {
542 const uint64 prev_epoch = 1 * kEpoch;
543 const uint64 cur_epoch = 2 * kEpoch;
544 // Cases where the last number was close to the start of the range
545 for (uint64 i = 0; i < 10; i++) {
546 uint64 last = cur_epoch + i;
547 // Small number should not wrap (even if they're out of order).
548 for (uint64 j = 0; j < 10; j++) {
549 CheckCalculatePacketSequenceNumber(cur_epoch + j, last);
552 // But large numbers should reverse wrap.
553 for (uint64 j = 0; j < 10; j++) {
554 uint64 num = kEpoch - 1 - j;
555 CheckCalculatePacketSequenceNumber(prev_epoch + num, last);
560 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextEpoch) {
561 const uint64 cur_epoch = 2 * kEpoch;
562 const uint64 next_epoch = 3 * kEpoch;
563 // Cases where the last number was close to the end of the range
564 for (uint64 i = 0; i < 10; i++) {
565 QuicPacketSequenceNumber last = next_epoch - 1 - i;
567 // Small numbers should wrap.
568 for (uint64 j = 0; j < 10; j++) {
569 CheckCalculatePacketSequenceNumber(next_epoch + j, last);
572 // but large numbers should not (even if they're out of order).
573 for (uint64 j = 0; j < 10; j++) {
574 uint64 num = kEpoch - 1 - j;
575 CheckCalculatePacketSequenceNumber(cur_epoch + num, last);
580 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextMax) {
581 const uint64 max_number = numeric_limits<uint64>::max();
582 const uint64 max_epoch = max_number & ~kMask;
584 // Cases where the last number was close to the end of the range
585 for (uint64 i = 0; i < 10; i++) {
586 // Subtract 1, because the expected next sequence number is 1 more than the
587 // last sequence number.
588 QuicPacketSequenceNumber last = max_number - i - 1;
590 // Small numbers should not wrap, because they have nowhere to go.
591 for (uint64 j = 0; j < 10; j++) {
592 CheckCalculatePacketSequenceNumber(max_epoch + j, last);
595 // Large numbers should not wrap either.
596 for (uint64 j = 0; j < 10; j++) {
597 uint64 num = kEpoch - 1 - j;
598 CheckCalculatePacketSequenceNumber(max_epoch + num, last);
603 TEST_P(QuicFramerTest, EmptyPacket) {
604 char packet[] = { 0x00 };
605 QuicEncryptedPacket encrypted(packet, 0, false);
606 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
607 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
610 TEST_P(QuicFramerTest, LargePacket) {
611 unsigned char packet[kMaxPacketSize + 1] = {
612 // public flags (8 byte guid)
615 0x10, 0x32, 0x54, 0x76,
616 0x98, 0xBA, 0xDC, 0xFE,
617 // packet sequence number
618 0xBC, 0x9A, 0x78, 0x56,
624 memset(packet + GetPacketHeaderSize(
625 PACKET_8BYTE_GUID, !kIncludeVersion,
626 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 0,
627 kMaxPacketSize - GetPacketHeaderSize(
628 PACKET_8BYTE_GUID, !kIncludeVersion,
629 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) + 1);
631 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
632 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
634 ASSERT_TRUE(visitor_.header_.get());
635 // Make sure we've parsed the packet header, so we can send an error.
636 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
637 visitor_.header_->public_header.guid);
638 // Make sure the correct error is propagated.
639 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error());
642 TEST_P(QuicFramerTest, PacketHeader) {
643 unsigned char packet[] = {
644 // public flags (8 byte guid)
647 0x10, 0x32, 0x54, 0x76,
648 0x98, 0xBA, 0xDC, 0xFE,
649 // packet sequence number
650 0xBC, 0x9A, 0x78, 0x56,
656 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
657 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
658 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
659 ASSERT_TRUE(visitor_.header_.get());
660 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
661 visitor_.header_->public_header.guid);
662 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
663 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
664 EXPECT_FALSE(visitor_.header_->fec_flag);
665 EXPECT_FALSE(visitor_.header_->entropy_flag);
666 EXPECT_EQ(0, visitor_.header_->entropy_hash);
667 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
668 visitor_.header_->packet_sequence_number);
669 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
670 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
672 // Now test framing boundaries
674 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
675 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
677 string expected_error;
678 if (i < kGuidOffset) {
679 expected_error = "Unable to read public flags.";
680 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
681 expected_error = "Unable to read GUID.";
682 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion)) {
683 expected_error = "Unable to read sequence number.";
684 } else if (i < GetFecGroupOffset(!kIncludeVersion)) {
685 expected_error = "Unable to read private flags.";
687 expected_error = "Unable to read first fec protected packet offset.";
689 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
693 TEST_P(QuicFramerTest, PacketHeaderWith4ByteGuid) {
694 QuicFramerPeer::SetLastSerializedGuid(&framer_,
695 GG_UINT64_C(0xFEDCBA9876543210));
697 unsigned char packet[] = {
698 // public flags (4 byte guid)
701 0x10, 0x32, 0x54, 0x76,
702 // packet sequence number
703 0xBC, 0x9A, 0x78, 0x56,
709 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
710 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
711 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
712 ASSERT_TRUE(visitor_.header_.get());
713 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
714 visitor_.header_->public_header.guid);
715 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
716 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
717 EXPECT_FALSE(visitor_.header_->fec_flag);
718 EXPECT_FALSE(visitor_.header_->entropy_flag);
719 EXPECT_EQ(0, visitor_.header_->entropy_hash);
720 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
721 visitor_.header_->packet_sequence_number);
722 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
723 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
725 // Now test framing boundaries
727 i < GetPacketHeaderSize(PACKET_4BYTE_GUID, !kIncludeVersion,
728 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
730 string expected_error;
731 if (i < kGuidOffset) {
732 expected_error = "Unable to read public flags.";
733 } else if (i < GetSequenceNumberOffset(PACKET_4BYTE_GUID,
735 expected_error = "Unable to read GUID.";
736 } else if (i < GetPrivateFlagsOffset(PACKET_4BYTE_GUID,
738 expected_error = "Unable to read sequence number.";
739 } else if (i < GetFecGroupOffset(PACKET_4BYTE_GUID, !kIncludeVersion)) {
740 expected_error = "Unable to read private flags.";
742 expected_error = "Unable to read first fec protected packet offset.";
744 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
748 TEST_P(QuicFramerTest, PacketHeader1ByteGuid) {
749 QuicFramerPeer::SetLastSerializedGuid(&framer_,
750 GG_UINT64_C(0xFEDCBA9876543210));
752 unsigned char packet[] = {
753 // public flags (1 byte guid)
757 // packet sequence number
758 0xBC, 0x9A, 0x78, 0x56,
764 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
765 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
766 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
767 ASSERT_TRUE(visitor_.header_.get());
768 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
769 visitor_.header_->public_header.guid);
770 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
771 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
772 EXPECT_FALSE(visitor_.header_->fec_flag);
773 EXPECT_FALSE(visitor_.header_->entropy_flag);
774 EXPECT_EQ(0, visitor_.header_->entropy_hash);
775 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
776 visitor_.header_->packet_sequence_number);
777 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
778 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
780 // Now test framing boundaries
782 i < GetPacketHeaderSize(PACKET_1BYTE_GUID, !kIncludeVersion,
783 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
785 string expected_error;
786 if (i < kGuidOffset) {
787 expected_error = "Unable to read public flags.";
788 } else if (i < GetSequenceNumberOffset(PACKET_1BYTE_GUID,
790 expected_error = "Unable to read GUID.";
791 } else if (i < GetPrivateFlagsOffset(PACKET_1BYTE_GUID, !kIncludeVersion)) {
792 expected_error = "Unable to read sequence number.";
793 } else if (i < GetFecGroupOffset(PACKET_1BYTE_GUID, !kIncludeVersion)) {
794 expected_error = "Unable to read private flags.";
796 expected_error = "Unable to read first fec protected packet offset.";
798 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
802 TEST_P(QuicFramerTest, PacketHeaderWith0ByteGuid) {
803 QuicFramerPeer::SetLastSerializedGuid(&framer_,
804 GG_UINT64_C(0xFEDCBA9876543210));
806 unsigned char packet[] = {
807 // public flags (0 byte guid)
810 // packet sequence number
811 0xBC, 0x9A, 0x78, 0x56,
817 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
818 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
819 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
820 ASSERT_TRUE(visitor_.header_.get());
821 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
822 visitor_.header_->public_header.guid);
823 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
824 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
825 EXPECT_FALSE(visitor_.header_->fec_flag);
826 EXPECT_FALSE(visitor_.header_->entropy_flag);
827 EXPECT_EQ(0, visitor_.header_->entropy_hash);
828 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
829 visitor_.header_->packet_sequence_number);
830 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
831 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
833 // Now test framing boundaries
835 i < GetPacketHeaderSize(PACKET_0BYTE_GUID, !kIncludeVersion,
836 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
838 string expected_error;
839 if (i < kGuidOffset) {
840 expected_error = "Unable to read public flags.";
841 } else if (i < GetSequenceNumberOffset(PACKET_0BYTE_GUID,
843 expected_error = "Unable to read GUID.";
844 } else if (i < GetPrivateFlagsOffset(PACKET_0BYTE_GUID, !kIncludeVersion)) {
845 expected_error = "Unable to read sequence number.";
846 } else if (i < GetFecGroupOffset(PACKET_0BYTE_GUID, !kIncludeVersion)) {
847 expected_error = "Unable to read private flags.";
849 expected_error = "Unable to read first fec protected packet offset.";
851 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
855 TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) {
856 unsigned char packet[] = {
857 // public flags (version)
860 0x10, 0x32, 0x54, 0x76,
861 0x98, 0xBA, 0xDC, 0xFE,
863 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
864 // packet sequence number
865 0xBC, 0x9A, 0x78, 0x56,
871 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
872 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
873 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
874 ASSERT_TRUE(visitor_.header_.get());
875 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
876 visitor_.header_->public_header.guid);
877 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
878 EXPECT_TRUE(visitor_.header_->public_header.version_flag);
879 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
880 EXPECT_FALSE(visitor_.header_->fec_flag);
881 EXPECT_FALSE(visitor_.header_->entropy_flag);
882 EXPECT_EQ(0, visitor_.header_->entropy_hash);
883 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
884 visitor_.header_->packet_sequence_number);
885 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
886 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
888 // Now test framing boundaries
890 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion,
891 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
893 string expected_error;
894 if (i < kGuidOffset) {
895 expected_error = "Unable to read public flags.";
896 } else if (i < kVersionOffset) {
897 expected_error = "Unable to read GUID.";
898 } else if (i < GetSequenceNumberOffset(kIncludeVersion)) {
899 expected_error = "Unable to read protocol version.";
900 } else if (i < GetPrivateFlagsOffset(kIncludeVersion)) {
901 expected_error = "Unable to read sequence number.";
902 } else if (i < GetFecGroupOffset(kIncludeVersion)) {
903 expected_error = "Unable to read private flags.";
905 expected_error = "Unable to read first fec protected packet offset.";
907 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
911 TEST_P(QuicFramerTest, PacketHeaderWith4ByteSequenceNumber) {
912 QuicFramerPeer::SetLastSequenceNumber(&framer_,
913 GG_UINT64_C(0x123456789ABA));
915 unsigned char packet[] = {
916 // public flags (8 byte guid and 4 byte sequence number)
919 0x10, 0x32, 0x54, 0x76,
920 0x98, 0xBA, 0xDC, 0xFE,
921 // packet sequence number
922 0xBC, 0x9A, 0x78, 0x56,
927 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
928 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
929 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
930 ASSERT_TRUE(visitor_.header_.get());
931 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
932 visitor_.header_->public_header.guid);
933 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
934 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
935 EXPECT_FALSE(visitor_.header_->fec_flag);
936 EXPECT_FALSE(visitor_.header_->entropy_flag);
937 EXPECT_EQ(0, visitor_.header_->entropy_hash);
938 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
939 visitor_.header_->packet_sequence_number);
940 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
941 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
943 // Now test framing boundaries
945 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
946 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
948 string expected_error;
949 if (i < kGuidOffset) {
950 expected_error = "Unable to read public flags.";
951 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
952 expected_error = "Unable to read GUID.";
953 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
954 PACKET_4BYTE_SEQUENCE_NUMBER)) {
955 expected_error = "Unable to read sequence number.";
956 } else if (i < GetFecGroupOffset(!kIncludeVersion,
957 PACKET_4BYTE_SEQUENCE_NUMBER)) {
958 expected_error = "Unable to read private flags.";
960 expected_error = "Unable to read first fec protected packet offset.";
962 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
966 TEST_P(QuicFramerTest, PacketHeaderWith2ByteSequenceNumber) {
967 QuicFramerPeer::SetLastSequenceNumber(&framer_,
968 GG_UINT64_C(0x123456789ABA));
970 unsigned char packet[] = {
971 // public flags (8 byte guid and 2 byte sequence number)
974 0x10, 0x32, 0x54, 0x76,
975 0x98, 0xBA, 0xDC, 0xFE,
976 // packet sequence number
982 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
983 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
984 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
985 ASSERT_TRUE(visitor_.header_.get());
986 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
987 visitor_.header_->public_header.guid);
988 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
989 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
990 EXPECT_FALSE(visitor_.header_->fec_flag);
991 EXPECT_FALSE(visitor_.header_->entropy_flag);
992 EXPECT_EQ(0, visitor_.header_->entropy_hash);
993 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
994 visitor_.header_->packet_sequence_number);
995 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
996 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
998 // Now test framing boundaries
1000 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1001 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
1003 string expected_error;
1004 if (i < kGuidOffset) {
1005 expected_error = "Unable to read public flags.";
1006 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
1007 expected_error = "Unable to read GUID.";
1008 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
1009 PACKET_2BYTE_SEQUENCE_NUMBER)) {
1010 expected_error = "Unable to read sequence number.";
1011 } else if (i < GetFecGroupOffset(!kIncludeVersion,
1012 PACKET_2BYTE_SEQUENCE_NUMBER)) {
1013 expected_error = "Unable to read private flags.";
1015 expected_error = "Unable to read first fec protected packet offset.";
1017 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
1021 TEST_P(QuicFramerTest, PacketHeaderWith1ByteSequenceNumber) {
1022 QuicFramerPeer::SetLastSequenceNumber(&framer_,
1023 GG_UINT64_C(0x123456789ABA));
1025 unsigned char packet[] = {
1026 // public flags (8 byte guid and 1 byte sequence number)
1029 0x10, 0x32, 0x54, 0x76,
1030 0x98, 0xBA, 0xDC, 0xFE,
1031 // packet sequence number
1037 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1038 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
1039 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
1040 ASSERT_TRUE(visitor_.header_.get());
1041 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
1042 visitor_.header_->public_header.guid);
1043 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
1044 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
1045 EXPECT_FALSE(visitor_.header_->fec_flag);
1046 EXPECT_FALSE(visitor_.header_->entropy_flag);
1047 EXPECT_EQ(0, visitor_.header_->entropy_hash);
1048 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
1049 visitor_.header_->packet_sequence_number);
1050 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1051 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
1053 // Now test framing boundaries
1055 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1056 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
1058 string expected_error;
1059 if (i < kGuidOffset) {
1060 expected_error = "Unable to read public flags.";
1061 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) {
1062 expected_error = "Unable to read GUID.";
1063 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
1064 PACKET_1BYTE_SEQUENCE_NUMBER)) {
1065 expected_error = "Unable to read sequence number.";
1066 } else if (i < GetFecGroupOffset(!kIncludeVersion,
1067 PACKET_1BYTE_SEQUENCE_NUMBER)) {
1068 expected_error = "Unable to read private flags.";
1070 expected_error = "Unable to read first fec protected packet offset.";
1072 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
1076 TEST_P(QuicFramerTest, InvalidPublicFlag) {
1077 unsigned char packet[] = {
1078 // public flags, unknown flag at bit 6
1081 0x10, 0x32, 0x54, 0x76,
1082 0x98, 0xBA, 0xDC, 0xFE,
1083 // packet sequence number
1084 0xBC, 0x9A, 0x78, 0x56,
1089 // frame type (padding)
1091 0x00, 0x00, 0x00, 0x00
1093 CheckProcessingFails(packet,
1095 "Illegal public flags value.",
1096 QUIC_INVALID_PACKET_HEADER);
1099 TEST_P(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) {
1100 unsigned char packet[] = {
1101 // public flags (8 byte guid and version flag and an unknown flag)
1104 0x10, 0x32, 0x54, 0x76,
1105 0x98, 0xBA, 0xDC, 0xFE,
1107 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
1108 // packet sequence number
1109 0xBC, 0x9A, 0x78, 0x56,
1114 // frame type (padding)
1116 0x00, 0x00, 0x00, 0x00
1118 CheckProcessingFails(packet,
1120 "Illegal public flags value.",
1121 QUIC_INVALID_PACKET_HEADER);
1124 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
1125 unsigned char packet[] = {
1126 // public flags (8 byte guid, version flag and an unknown flag)
1129 0x10, 0x32, 0x54, 0x76,
1130 0x98, 0xBA, 0xDC, 0xFE,
1133 // packet sequence number
1134 0xBC, 0x9A, 0x78, 0x56,
1139 // frame type (padding frame)
1141 0x00, 0x00, 0x00, 0x00
1143 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1144 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1145 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1146 ASSERT_TRUE(visitor_.header_.get());
1147 EXPECT_EQ(0, visitor_.frame_count_);
1148 EXPECT_EQ(1, visitor_.version_mismatch_);
1151 TEST_P(QuicFramerTest, InvalidPrivateFlag) {
1152 unsigned char packet[] = {
1153 // public flags (8 byte guid)
1156 0x10, 0x32, 0x54, 0x76,
1157 0x98, 0xBA, 0xDC, 0xFE,
1158 // packet sequence number
1159 0xBC, 0x9A, 0x78, 0x56,
1164 // frame type (padding)
1166 0x00, 0x00, 0x00, 0x00
1168 CheckProcessingFails(packet,
1170 "Illegal private flags value.",
1171 QUIC_INVALID_PACKET_HEADER);
1174 TEST_P(QuicFramerTest, InvalidFECGroupOffset) {
1175 unsigned char packet[] = {
1176 // public flags (8 byte guid)
1179 0x10, 0x32, 0x54, 0x76,
1180 0x98, 0xBA, 0xDC, 0xFE,
1181 // packet sequence number
1182 0x01, 0x00, 0x00, 0x00,
1184 // private flags (fec group)
1186 // first fec protected packet offset
1189 CheckProcessingFails(packet,
1191 "First fec protected packet offset must be less "
1192 "than the sequence number.",
1193 QUIC_INVALID_PACKET_HEADER);
1196 TEST_P(QuicFramerTest, PaddingFrame) {
1197 unsigned char packet[] = {
1198 // public flags (8 byte guid)
1201 0x10, 0x32, 0x54, 0x76,
1202 0x98, 0xBA, 0xDC, 0xFE,
1203 // packet sequence number
1204 0xBC, 0x9A, 0x78, 0x56,
1209 // frame type (padding frame)
1211 // Ignored data (which in this case is a stream frame)
1212 // frame type (stream frame with fin)
1215 0x04, 0x03, 0x02, 0x01,
1217 0x54, 0x76, 0x10, 0x32,
1218 0xDC, 0xFE, 0x98, 0xBA,
1227 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1228 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1229 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1230 ASSERT_TRUE(visitor_.header_.get());
1231 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1233 ASSERT_EQ(0u, visitor_.stream_frames_.size());
1234 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1235 // A packet with no frames is not acceptable.
1236 CheckProcessingFails(
1238 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1239 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
1240 "Packet has no frames.", QUIC_MISSING_PAYLOAD);
1243 TEST_P(QuicFramerTest, StreamFrame) {
1244 unsigned char packet[] = {
1245 // public flags (8 byte guid)
1248 0x10, 0x32, 0x54, 0x76,
1249 0x98, 0xBA, 0xDC, 0xFE,
1250 // packet sequence number
1251 0xBC, 0x9A, 0x78, 0x56,
1256 // frame type (stream frame with fin)
1259 0x04, 0x03, 0x02, 0x01,
1261 0x54, 0x76, 0x10, 0x32,
1262 0xDC, 0xFE, 0x98, 0xBA,
1271 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1272 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1274 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1275 ASSERT_TRUE(visitor_.header_.get());
1276 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1278 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1279 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1280 EXPECT_EQ(static_cast<uint64>(0x01020304),
1281 visitor_.stream_frames_[0]->stream_id);
1282 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1283 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1284 visitor_.stream_frames_[0]->offset);
1285 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1287 // Now test framing boundaries
1288 CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, !kIncludeVersion);
1291 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
1292 unsigned char packet[] = {
1293 // public flags (8 byte guid)
1296 0x10, 0x32, 0x54, 0x76,
1297 0x98, 0xBA, 0xDC, 0xFE,
1298 // packet sequence number
1299 0xBC, 0x9A, 0x78, 0x56,
1304 // frame type (stream frame with fin)
1309 0x54, 0x76, 0x10, 0x32,
1310 0xDC, 0xFE, 0x98, 0xBA,
1319 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1320 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1322 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1323 ASSERT_TRUE(visitor_.header_.get());
1324 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1326 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1327 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1328 EXPECT_EQ(GG_UINT64_C(0x00020304),
1329 visitor_.stream_frames_[0]->stream_id);
1330 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1331 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1332 visitor_.stream_frames_[0]->offset);
1333 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1335 // Now test framing boundaries
1336 const size_t stream_id_size = 3;
1337 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1340 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
1341 unsigned char packet[] = {
1342 // public flags (8 byte guid)
1345 0x10, 0x32, 0x54, 0x76,
1346 0x98, 0xBA, 0xDC, 0xFE,
1347 // packet sequence number
1348 0xBC, 0x9A, 0x78, 0x56,
1353 // frame type (stream frame with fin)
1358 0x54, 0x76, 0x10, 0x32,
1359 0xDC, 0xFE, 0x98, 0xBA,
1368 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1369 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1371 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1372 ASSERT_TRUE(visitor_.header_.get());
1373 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1375 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1376 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1377 EXPECT_EQ(static_cast<uint64>(0x00000304),
1378 visitor_.stream_frames_[0]->stream_id);
1379 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1380 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1381 visitor_.stream_frames_[0]->offset);
1382 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1384 // Now test framing boundaries
1385 const size_t stream_id_size = 2;
1386 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1389 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) {
1390 unsigned char packet[] = {
1391 // public flags (8 byte guid)
1394 0x10, 0x32, 0x54, 0x76,
1395 0x98, 0xBA, 0xDC, 0xFE,
1396 // packet sequence number
1397 0xBC, 0x9A, 0x78, 0x56,
1402 // frame type (stream frame with fin)
1407 0x54, 0x76, 0x10, 0x32,
1408 0xDC, 0xFE, 0x98, 0xBA,
1417 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1418 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1420 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1421 ASSERT_TRUE(visitor_.header_.get());
1422 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1424 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1425 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1426 EXPECT_EQ(static_cast<uint64>(0x00000004),
1427 visitor_.stream_frames_[0]->stream_id);
1428 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1429 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1430 visitor_.stream_frames_[0]->offset);
1431 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1433 // Now test framing boundaries
1434 const size_t stream_id_size = 1;
1435 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1438 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
1439 unsigned char packet[] = {
1440 // public flags (version, 8 byte guid)
1443 0x10, 0x32, 0x54, 0x76,
1444 0x98, 0xBA, 0xDC, 0xFE,
1446 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
1447 // packet sequence number
1448 0xBC, 0x9A, 0x78, 0x56,
1453 // frame type (stream frame with fin)
1456 0x04, 0x03, 0x02, 0x01,
1458 0x54, 0x76, 0x10, 0x32,
1459 0xDC, 0xFE, 0x98, 0xBA,
1468 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1469 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1471 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1472 ASSERT_TRUE(visitor_.header_.get());
1473 EXPECT_TRUE(visitor_.header_.get()->public_header.version_flag);
1474 EXPECT_EQ(GetParam(), visitor_.header_.get()->public_header.versions[0]);
1475 EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion));
1477 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1478 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1479 EXPECT_EQ(static_cast<uint64>(0x01020304),
1480 visitor_.stream_frames_[0]->stream_id);
1481 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1482 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1483 visitor_.stream_frames_[0]->offset);
1484 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1486 // Now test framing boundaries
1487 CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, kIncludeVersion);
1490 TEST_P(QuicFramerTest, RejectPacket) {
1491 visitor_.accept_packet_ = false;
1493 unsigned char packet[] = {
1494 // public flags (8 byte guid)
1497 0x10, 0x32, 0x54, 0x76,
1498 0x98, 0xBA, 0xDC, 0xFE,
1499 // packet sequence number
1500 0xBC, 0x9A, 0x78, 0x56,
1505 // frame type (stream frame with fin)
1508 0x04, 0x03, 0x02, 0x01,
1510 0x54, 0x76, 0x10, 0x32,
1511 0xDC, 0xFE, 0x98, 0xBA,
1520 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1521 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1523 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1524 ASSERT_TRUE(visitor_.header_.get());
1525 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1527 ASSERT_EQ(0u, visitor_.stream_frames_.size());
1528 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1531 TEST_P(QuicFramerTest, RejectPublicHeader) {
1532 visitor_.accept_public_header_ = false;
1534 unsigned char packet[] = {
1535 // public flags (8 byte guid)
1538 0x10, 0x32, 0x54, 0x76,
1539 0x98, 0xBA, 0xDC, 0xFE,
1542 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1543 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1545 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1546 ASSERT_TRUE(visitor_.public_header_.get());
1547 ASSERT_FALSE(visitor_.header_.get());
1550 TEST_P(QuicFramerTest, RevivedStreamFrame) {
1551 unsigned char payload[] = {
1552 // frame type (stream frame with fin)
1555 0x04, 0x03, 0x02, 0x01,
1557 0x54, 0x76, 0x10, 0x32,
1558 0xDC, 0xFE, 0x98, 0xBA,
1567 QuicPacketHeader header;
1568 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
1569 header.public_header.reset_flag = false;
1570 header.public_header.version_flag = false;
1571 header.fec_flag = true;
1572 header.entropy_flag = true;
1573 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
1574 header.fec_group = 0;
1576 // Do not encrypt the payload because the revived payload is post-encryption.
1577 EXPECT_TRUE(framer_.ProcessRevivedPacket(&header,
1578 StringPiece(AsChars(payload),
1579 arraysize(payload))));
1581 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1582 ASSERT_EQ(1, visitor_.revived_packets_);
1583 ASSERT_TRUE(visitor_.header_.get());
1584 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
1585 visitor_.header_->public_header.guid);
1586 EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
1587 EXPECT_FALSE(visitor_.header_->public_header.version_flag);
1588 EXPECT_TRUE(visitor_.header_->fec_flag);
1589 EXPECT_TRUE(visitor_.header_->entropy_flag);
1590 EXPECT_EQ(1 << (header.packet_sequence_number % 8),
1591 visitor_.header_->entropy_hash);
1592 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
1593 visitor_.header_->packet_sequence_number);
1594 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1595 EXPECT_EQ(0x00u, visitor_.header_->fec_group);
1597 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1598 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1599 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
1600 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1601 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1602 visitor_.stream_frames_[0]->offset);
1603 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1606 TEST_P(QuicFramerTest, StreamFrameInFecGroup) {
1607 unsigned char packet[] = {
1608 // public flags (8 byte guid)
1611 0x10, 0x32, 0x54, 0x76,
1612 0x98, 0xBA, 0xDC, 0xFE,
1613 // packet sequence number
1614 0xBC, 0x9A, 0x78, 0x56,
1616 // private flags (fec group)
1618 // first fec protected packet offset
1621 // frame type (stream frame with fin)
1624 0x04, 0x03, 0x02, 0x01,
1626 0x54, 0x76, 0x10, 0x32,
1627 0xDC, 0xFE, 0x98, 0xBA,
1636 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1637 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1639 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1640 ASSERT_TRUE(visitor_.header_.get());
1641 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1642 EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1643 EXPECT_EQ(GG_UINT64_C(0x341256789ABA),
1644 visitor_.header_->fec_group);
1645 const size_t fec_offset = GetStartOfFecProtectedData(
1646 PACKET_8BYTE_GUID, !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER);
1648 string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset),
1649 visitor_.fec_protected_payload_);
1651 ASSERT_EQ(1u, visitor_.stream_frames_.size());
1652 EXPECT_EQ(0u, visitor_.ack_frames_.size());
1653 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
1654 EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1655 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654),
1656 visitor_.stream_frames_[0]->offset);
1657 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1660 TEST_P(QuicFramerTest, AckFrameV14) {
1661 if (framer_.version() > QUIC_VERSION_14) {
1665 unsigned char packet[] = {
1666 // public flags (8 byte guid)
1669 0x10, 0x32, 0x54, 0x76,
1670 0x98, 0xBA, 0xDC, 0xFE,
1671 // packet sequence number
1672 0xA8, 0x9A, 0x78, 0x56,
1674 // private flags (entropy)
1677 // frame type (ack frame)
1678 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1680 // entropy hash of sent packets till least awaiting - 1.
1682 // least packet sequence number awaiting an ack, delta from sequence number.
1683 0x08, 0x00, 0x00, 0x00,
1685 // entropy hash of all received packets.
1687 // largest observed packet sequence number
1688 0xBF, 0x9A, 0x78, 0x56,
1692 // num missing packets
1694 // missing packet delta
1696 // 0 more missing packets in range.
1700 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1701 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1703 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1704 ASSERT_TRUE(visitor_.header_.get());
1705 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1707 EXPECT_EQ(0u, visitor_.stream_frames_.size());
1708 ASSERT_EQ(1u, visitor_.ack_frames_.size());
1709 const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1710 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash);
1711 EXPECT_EQ(0xBA, frame.received_info.entropy_hash);
1712 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed);
1713 ASSERT_EQ(1u, frame.received_info.missing_packets.size());
1714 SequenceNumberSet::const_iterator missing_iter =
1715 frame.received_info.missing_packets.begin();
1716 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter);
1717 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
1719 const size_t kSentEntropyOffset = kQuicFrameTypeSize;
1720 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
1721 const size_t kReceivedEntropyOffset = kLeastUnackedOffset +
1722 PACKET_6BYTE_SEQUENCE_NUMBER;
1723 const size_t kLargestObservedOffset = kReceivedEntropyOffset +
1724 kQuicEntropyHashSize;
1725 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset +
1726 PACKET_6BYTE_SEQUENCE_NUMBER;
1727 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset +
1728 kQuicDeltaTimeLargestObservedSize;
1729 const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
1730 kNumberOfMissingPacketsSize;
1731 const size_t kMissingPacketsRange = kMissingPacketsOffset +
1732 PACKET_1BYTE_SEQUENCE_NUMBER;
1733 // Now test framing boundaries
1734 const size_t ack_frame_size = kMissingPacketsRange +
1735 PACKET_1BYTE_SEQUENCE_NUMBER;
1736 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1737 string expected_error;
1738 if (i < kLeastUnackedOffset) {
1739 expected_error = "Unable to read entropy hash for sent packets.";
1740 } else if (i < kReceivedEntropyOffset) {
1741 expected_error = "Unable to read least unacked delta.";
1742 } else if (i < kLargestObservedOffset) {
1743 expected_error = "Unable to read entropy hash for received packets.";
1744 } else if (i < kMissingDeltaTimeOffset) {
1745 expected_error = "Unable to read largest observed.";
1746 } else if (i < kNumMissingPacketOffset) {
1747 expected_error = "Unable to read delta time largest observed.";
1748 } else if (i < kMissingPacketsOffset) {
1749 expected_error = "Unable to read num missing packet ranges.";
1750 } else if (i < kMissingPacketsRange) {
1751 expected_error = "Unable to read missing sequence number delta.";
1753 expected_error = "Unable to read missing sequence number range.";
1755 CheckProcessingFails(
1757 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1758 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
1759 expected_error, QUIC_INVALID_ACK_DATA);
1763 TEST_P(QuicFramerTest, AckFrame) {
1764 if (framer_.version() <= QUIC_VERSION_14) {
1768 unsigned char packet[] = {
1769 // public flags (8 byte guid)
1772 0x10, 0x32, 0x54, 0x76,
1773 0x98, 0xBA, 0xDC, 0xFE,
1774 // packet sequence number
1775 0xA8, 0x9A, 0x78, 0x56,
1777 // private flags (entropy)
1780 // frame type (ack frame)
1781 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1783 // entropy hash of sent packets till least awaiting - 1.
1785 // least packet sequence number awaiting an ack, delta from sequence number.
1786 0x08, 0x00, 0x00, 0x00,
1788 // entropy hash of all received packets.
1790 // largest observed packet sequence number
1791 0xBF, 0x9A, 0x78, 0x56,
1795 // num missing packets
1797 // missing packet delta
1799 // 0 more missing packets in range.
1801 // Number of revived packets.
1805 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1806 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1808 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1809 ASSERT_TRUE(visitor_.header_.get());
1810 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1812 EXPECT_EQ(0u, visitor_.stream_frames_.size());
1813 ASSERT_EQ(1u, visitor_.ack_frames_.size());
1814 const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1815 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash);
1816 EXPECT_EQ(0xBA, frame.received_info.entropy_hash);
1817 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed);
1818 ASSERT_EQ(1u, frame.received_info.missing_packets.size());
1819 SequenceNumberSet::const_iterator missing_iter =
1820 frame.received_info.missing_packets.begin();
1821 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter);
1822 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
1824 const size_t kSentEntropyOffset = kQuicFrameTypeSize;
1825 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
1826 const size_t kReceivedEntropyOffset = kLeastUnackedOffset +
1827 PACKET_6BYTE_SEQUENCE_NUMBER;
1828 const size_t kLargestObservedOffset = kReceivedEntropyOffset +
1829 kQuicEntropyHashSize;
1830 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset +
1831 PACKET_6BYTE_SEQUENCE_NUMBER;
1832 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset +
1833 kQuicDeltaTimeLargestObservedSize;
1834 const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
1835 kNumberOfMissingPacketsSize;
1836 const size_t kMissingPacketsRange = kMissingPacketsOffset +
1837 PACKET_1BYTE_SEQUENCE_NUMBER;
1838 const size_t kRevivedPacketsLength = kMissingPacketsRange +
1839 PACKET_1BYTE_SEQUENCE_NUMBER;
1840 // Now test framing boundaries
1841 const size_t ack_frame_size = kRevivedPacketsLength +
1842 PACKET_1BYTE_SEQUENCE_NUMBER;
1843 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1844 string expected_error;
1845 if (i < kLeastUnackedOffset) {
1846 expected_error = "Unable to read entropy hash for sent packets.";
1847 } else if (i < kReceivedEntropyOffset) {
1848 expected_error = "Unable to read least unacked delta.";
1849 } else if (i < kLargestObservedOffset) {
1850 expected_error = "Unable to read entropy hash for received packets.";
1851 } else if (i < kMissingDeltaTimeOffset) {
1852 expected_error = "Unable to read largest observed.";
1853 } else if (i < kNumMissingPacketOffset) {
1854 expected_error = "Unable to read delta time largest observed.";
1855 } else if (i < kMissingPacketsOffset) {
1856 expected_error = "Unable to read num missing packet ranges.";
1857 } else if (i < kMissingPacketsRange) {
1858 expected_error = "Unable to read missing sequence number delta.";
1859 } else if (i < kRevivedPacketsLength) {
1860 expected_error = "Unable to read missing sequence number range.";
1862 expected_error = "Unable to read num revived packets.";
1864 CheckProcessingFails(
1866 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1867 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
1868 expected_error, QUIC_INVALID_ACK_DATA);
1872 TEST_P(QuicFramerTest, AckFrameRevivedPackets) {
1873 if (framer_.version() <= QUIC_VERSION_14) {
1877 unsigned char packet[] = {
1878 // public flags (8 byte guid)
1881 0x10, 0x32, 0x54, 0x76,
1882 0x98, 0xBA, 0xDC, 0xFE,
1883 // packet sequence number
1884 0xA8, 0x9A, 0x78, 0x56,
1886 // private flags (entropy)
1889 // frame type (ack frame)
1890 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1892 // entropy hash of sent packets till least awaiting - 1.
1894 // least packet sequence number awaiting an ack, delta from sequence number.
1895 0x08, 0x00, 0x00, 0x00,
1897 // entropy hash of all received packets.
1899 // largest observed packet sequence number
1900 0xBF, 0x9A, 0x78, 0x56,
1904 // num missing packets
1906 // missing packet delta
1908 // 0 more missing packets in range.
1910 // Number of revived packets.
1912 // Revived packet sequence number.
1913 0xBE, 0x9A, 0x78, 0x56,
1917 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1918 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1920 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1921 ASSERT_TRUE(visitor_.header_.get());
1922 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1924 EXPECT_EQ(0u, visitor_.stream_frames_.size());
1925 ASSERT_EQ(1u, visitor_.ack_frames_.size());
1926 const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1927 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash);
1928 EXPECT_EQ(0xBA, frame.received_info.entropy_hash);
1929 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed);
1930 ASSERT_EQ(1u, frame.received_info.missing_packets.size());
1931 SequenceNumberSet::const_iterator missing_iter =
1932 frame.received_info.missing_packets.begin();
1933 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter);
1934 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked);
1936 const size_t kSentEntropyOffset = kQuicFrameTypeSize;
1937 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
1938 const size_t kReceivedEntropyOffset = kLeastUnackedOffset +
1939 PACKET_6BYTE_SEQUENCE_NUMBER;
1940 const size_t kLargestObservedOffset = kReceivedEntropyOffset +
1941 kQuicEntropyHashSize;
1942 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset +
1943 PACKET_6BYTE_SEQUENCE_NUMBER;
1944 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset +
1945 kQuicDeltaTimeLargestObservedSize;
1946 const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
1947 kNumberOfMissingPacketsSize;
1948 const size_t kMissingPacketsRange = kMissingPacketsOffset +
1949 PACKET_1BYTE_SEQUENCE_NUMBER;
1950 const size_t kRevivedPacketsLength = kMissingPacketsRange +
1951 PACKET_1BYTE_SEQUENCE_NUMBER;
1952 const size_t kRevivedPacketSequenceNumberLength = kRevivedPacketsLength +
1953 PACKET_1BYTE_SEQUENCE_NUMBER;
1954 // Now test framing boundaries
1955 const size_t ack_frame_size = kRevivedPacketSequenceNumberLength +
1956 PACKET_6BYTE_SEQUENCE_NUMBER;
1957 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1958 string expected_error;
1959 if (i < kLeastUnackedOffset) {
1960 expected_error = "Unable to read entropy hash for sent packets.";
1961 } else if (i < kReceivedEntropyOffset) {
1962 expected_error = "Unable to read least unacked delta.";
1963 } else if (i < kLargestObservedOffset) {
1964 expected_error = "Unable to read entropy hash for received packets.";
1965 } else if (i < kMissingDeltaTimeOffset) {
1966 expected_error = "Unable to read largest observed.";
1967 } else if (i < kNumMissingPacketOffset) {
1968 expected_error = "Unable to read delta time largest observed.";
1969 } else if (i < kMissingPacketsOffset) {
1970 expected_error = "Unable to read num missing packet ranges.";
1971 } else if (i < kMissingPacketsRange) {
1972 expected_error = "Unable to read missing sequence number delta.";
1973 } else if (i < kRevivedPacketsLength) {
1974 expected_error = "Unable to read missing sequence number range.";
1975 } else if (i < kRevivedPacketSequenceNumberLength) {
1976 expected_error = "Unable to read num revived packets.";
1978 expected_error = "Unable to read revived packet.";
1980 CheckProcessingFails(
1982 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
1983 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
1984 expected_error, QUIC_INVALID_ACK_DATA);
1988 TEST_P(QuicFramerTest, AckFrameNoNacks) {
1989 unsigned char packet[] = {
1990 // public flags (8 byte guid)
1993 0x10, 0x32, 0x54, 0x76,
1994 0x98, 0xBA, 0xDC, 0xFE,
1995 // packet sequence number
1996 0xA8, 0x9A, 0x78, 0x56,
1998 // private flags (entropy)
2001 // frame type (ack frame)
2002 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta)
2004 // entropy hash of sent packets till least awaiting - 1.
2006 // least packet sequence number awaiting an ack, delta from sequence number.
2007 0x08, 0x00, 0x00, 0x00,
2009 // entropy hash of all received packets.
2011 // largest observed packet sequence number
2012 0xBF, 0x9A, 0x78, 0x56,
2018 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2019 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2021 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2022 ASSERT_TRUE(visitor_.header_.get());
2023 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2025 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2026 ASSERT_EQ(1u, visitor_.ack_frames_.size());
2027 QuicAckFrame* frame = visitor_.ack_frames_[0];
2028 EXPECT_EQ(0xAB, frame->sent_info.entropy_hash);
2029 EXPECT_EQ(0xBA, frame->received_info.entropy_hash);
2030 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF),
2031 frame->received_info.largest_observed);
2032 ASSERT_EQ(0u, frame->received_info.missing_packets.size());
2033 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame->sent_info.least_unacked);
2035 // Verify that the packet re-serializes identically.
2037 frames.push_back(QuicFrame(frame));
2038 scoped_ptr<QuicPacket> data(
2039 framer_.BuildUnsizedDataPacket(*visitor_.header_, frames).packet);
2040 ASSERT_TRUE(data != NULL);
2042 test::CompareCharArraysWithHexError("constructed packet",
2043 data->data(), data->length(),
2044 AsChars(packet), arraysize(packet));
2047 TEST_P(QuicFramerTest, AckFrame500Nacks) {
2048 if (framer_.version() <= QUIC_VERSION_14) {
2051 unsigned char packet[] = {
2052 // public flags (8 byte guid)
2055 0x10, 0x32, 0x54, 0x76,
2056 0x98, 0xBA, 0xDC, 0xFE,
2057 // packet sequence number
2058 0xA8, 0x9A, 0x78, 0x56,
2060 // private flags (entropy)
2063 // frame type (ack frame)
2064 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
2066 // entropy hash of sent packets till least awaiting - 1.
2068 // least packet sequence number awaiting an ack, delta from sequence number.
2069 0x08, 0x00, 0x00, 0x00,
2071 // entropy hash of all received packets.
2073 // largest observed packet sequence number
2074 0xBF, 0x9A, 0x78, 0x56,
2078 // num missing packet ranges
2080 // missing packet delta
2082 // 243 more missing packets in range.
2083 // The ranges are listed in this order so the re-constructed packet matches.
2085 // No gap between ranges
2087 // 255 more missing packets in range.
2089 // No revived packets.
2093 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2094 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2096 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2097 ASSERT_TRUE(visitor_.header_.get());
2098 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2100 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2101 ASSERT_EQ(1u, visitor_.ack_frames_.size());
2102 QuicAckFrame* frame = visitor_.ack_frames_[0];
2103 EXPECT_EQ(0xAB, frame->sent_info.entropy_hash);
2104 EXPECT_EQ(0xBA, frame->received_info.entropy_hash);
2105 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF),
2106 frame->received_info.largest_observed);
2107 EXPECT_EQ(0u, frame->received_info.revived_packets.size());
2108 ASSERT_EQ(500u, frame->received_info.missing_packets.size());
2109 SequenceNumberSet::const_iterator first_missing_iter =
2110 frame->received_info.missing_packets.begin();
2111 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter);
2112 SequenceNumberSet::const_reverse_iterator last_missing_iter =
2113 frame->received_info.missing_packets.rbegin();
2114 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter);
2115 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame->sent_info.least_unacked);
2117 // Verify that the packet re-serializes identically.
2119 frames.push_back(QuicFrame(frame));
2120 scoped_ptr<QuicPacket> data(
2121 framer_.BuildUnsizedDataPacket(*visitor_.header_, frames).packet);
2122 ASSERT_TRUE(data != NULL);
2124 test::CompareCharArraysWithHexError("constructed packet",
2125 data->data(), data->length(),
2126 AsChars(packet), arraysize(packet));
2129 TEST_P(QuicFramerTest, AckFrame500NacksV14) {
2130 if (framer_.version() > QUIC_VERSION_14) {
2133 unsigned char packet[] = {
2134 // public flags (8 byte guid)
2137 0x10, 0x32, 0x54, 0x76,
2138 0x98, 0xBA, 0xDC, 0xFE,
2139 // packet sequence number
2140 0xA8, 0x9A, 0x78, 0x56,
2142 // private flags (entropy)
2145 // frame type (ack frame)
2146 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
2148 // entropy hash of sent packets till least awaiting - 1.
2150 // least packet sequence number awaiting an ack, delta from sequence number.
2151 0x08, 0x00, 0x00, 0x00,
2153 // entropy hash of all received packets.
2155 // largest observed packet sequence number
2156 0xBF, 0x9A, 0x78, 0x56,
2160 // num missing packet ranges
2162 // missing packet delta
2164 // 243 more missing packets in range.
2165 // The ranges are listed in this order so the re-constructed packet matches.
2167 // No gap between ranges
2169 // 255 more missing packets in range.
2173 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2174 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2176 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2177 ASSERT_TRUE(visitor_.header_.get());
2178 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2180 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2181 ASSERT_EQ(1u, visitor_.ack_frames_.size());
2182 QuicAckFrame* frame = visitor_.ack_frames_[0];
2183 EXPECT_EQ(0xAB, frame->sent_info.entropy_hash);
2184 EXPECT_EQ(0xBA, frame->received_info.entropy_hash);
2185 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF),
2186 frame->received_info.largest_observed);
2187 ASSERT_EQ(500u, frame->received_info.missing_packets.size());
2188 SequenceNumberSet::const_iterator first_missing_iter =
2189 frame->received_info.missing_packets.begin();
2190 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter);
2191 SequenceNumberSet::const_reverse_iterator last_missing_iter =
2192 frame->received_info.missing_packets.rbegin();
2193 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter);
2194 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame->sent_info.least_unacked);
2196 // Verify that the packet re-serializes identically.
2198 frames.push_back(QuicFrame(frame));
2199 scoped_ptr<QuicPacket> data(
2200 framer_.BuildUnsizedDataPacket(*visitor_.header_, frames).packet);
2201 ASSERT_TRUE(data != NULL);
2203 test::CompareCharArraysWithHexError("constructed packet",
2204 data->data(), data->length(),
2205 AsChars(packet), arraysize(packet));
2208 TEST_P(QuicFramerTest, CongestionFeedbackFrameTCP) {
2209 if (framer_.version() <= QUIC_VERSION_14) {
2212 unsigned char packet[] = {
2213 // public flags (8 byte guid)
2216 0x10, 0x32, 0x54, 0x76,
2217 0x98, 0xBA, 0xDC, 0xFE,
2218 // packet sequence number
2219 0xBC, 0x9A, 0x78, 0x56,
2224 // frame type (congestion feedback frame)
2226 // congestion feedback type (tcp)
2228 // ack_frame.feedback.tcp.receive_window
2232 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2233 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2235 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2236 ASSERT_TRUE(visitor_.header_.get());
2237 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2239 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2240 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size());
2241 const QuicCongestionFeedbackFrame& frame =
2242 *visitor_.congestion_feedback_frames_[0];
2243 ASSERT_EQ(kTCP, frame.type);
2244 EXPECT_EQ(0x4030u, frame.tcp.receive_window);
2246 // Now test framing boundaries
2247 for (size_t i = kQuicFrameTypeSize; i < 4; ++i) {
2248 string expected_error;
2250 expected_error = "Unable to read congestion feedback type.";
2252 expected_error = "Unable to read receive window.";
2254 CheckProcessingFails(
2256 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2257 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2258 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
2262 TEST_P(QuicFramerTest, CongestionFeedbackFrameTCPV14) {
2263 if (framer_.version() > QUIC_VERSION_14) {
2266 unsigned char packet[] = {
2267 // public flags (8 byte guid)
2270 0x10, 0x32, 0x54, 0x76,
2271 0x98, 0xBA, 0xDC, 0xFE,
2272 // packet sequence number
2273 0xBC, 0x9A, 0x78, 0x56,
2278 // frame type (congestion feedback frame)
2280 // congestion feedback type (tcp)
2282 // ack_frame.feedback.tcp.accumulated_number_of_lost_packets
2284 // ack_frame.feedback.tcp.receive_window
2288 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2289 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2291 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2292 ASSERT_TRUE(visitor_.header_.get());
2293 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2295 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2296 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size());
2297 const QuicCongestionFeedbackFrame& frame =
2298 *visitor_.congestion_feedback_frames_[0];
2299 ASSERT_EQ(kTCP, frame.type);
2300 EXPECT_EQ(0x4030u, frame.tcp.receive_window);
2302 // Now test framing boundaries
2303 for (size_t i = kQuicFrameTypeSize; i < 6; ++i) {
2304 string expected_error;
2306 expected_error = "Unable to read congestion feedback type.";
2308 expected_error = "Unable to read accumulated number of lost packets.";
2310 expected_error = "Unable to read receive window.";
2312 CheckProcessingFails(
2314 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2315 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2316 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
2320 TEST_P(QuicFramerTest, CongestionFeedbackFrameInterArrival) {
2321 if (framer_.version() <= QUIC_VERSION_14) {
2324 unsigned char packet[] = {
2325 // public flags (8 byte guid)
2328 0x10, 0x32, 0x54, 0x76,
2329 0x98, 0xBA, 0xDC, 0xFE,
2330 // packet sequence number
2331 0xBC, 0x9A, 0x78, 0x56,
2336 // frame type (congestion feedback frame)
2338 // congestion feedback type (inter arrival)
2340 // num received packets
2342 // lowest sequence number
2343 0xBA, 0x9A, 0x78, 0x56,
2346 0x87, 0x96, 0xA5, 0xB4,
2347 0xC3, 0xD2, 0xE1, 0x07,
2351 0x01, 0x00, 0x00, 0x00,
2352 // sequence delta (skip one packet)
2355 0x02, 0x00, 0x00, 0x00,
2358 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2359 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2361 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2362 ASSERT_TRUE(visitor_.header_.get());
2363 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2365 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2366 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size());
2367 const QuicCongestionFeedbackFrame& frame =
2368 *visitor_.congestion_feedback_frames_[0];
2369 ASSERT_EQ(kInterArrival, frame.type);
2370 ASSERT_EQ(3u, frame.inter_arrival.received_packet_times.size());
2371 TimeMap::const_iterator iter =
2372 frame.inter_arrival.received_packet_times.begin();
2373 EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
2374 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59687),
2375 iter->second.Subtract(start_).ToMicroseconds());
2377 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
2378 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59688),
2379 iter->second.Subtract(start_).ToMicroseconds());
2381 EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
2382 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59689),
2383 iter->second.Subtract(start_).ToMicroseconds());
2385 // Now test framing boundaries
2386 for (size_t i = kQuicFrameTypeSize; i < 29; ++i) {
2387 string expected_error;
2389 expected_error = "Unable to read congestion feedback type.";
2391 expected_error = "Unable to read num received packets.";
2393 expected_error = "Unable to read smallest received.";
2394 } else if (i < 17) {
2395 expected_error = "Unable to read time received.";
2396 } else if (i < 19) {
2397 expected_error = "Unable to read sequence delta in received packets.";
2398 } else if (i < 23) {
2399 expected_error = "Unable to read time delta in received packets.";
2400 } else if (i < 25) {
2401 expected_error = "Unable to read sequence delta in received packets.";
2402 } else if (i < 29) {
2403 expected_error = "Unable to read time delta in received packets.";
2405 CheckProcessingFails(
2407 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2408 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2409 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
2413 TEST_P(QuicFramerTest, CongestionFeedbackFrameInterArrivalV14) {
2414 if (framer_.version() > QUIC_VERSION_14) {
2417 unsigned char packet[] = {
2418 // public flags (8 byte guid)
2421 0x10, 0x32, 0x54, 0x76,
2422 0x98, 0xBA, 0xDC, 0xFE,
2423 // packet sequence number
2424 0xBC, 0x9A, 0x78, 0x56,
2429 // frame type (congestion feedback frame)
2431 // congestion feedback type (inter arrival)
2433 // accumulated_number_of_lost_packets
2435 // num received packets
2437 // lowest sequence number
2438 0xBA, 0x9A, 0x78, 0x56,
2441 0x87, 0x96, 0xA5, 0xB4,
2442 0xC3, 0xD2, 0xE1, 0x07,
2446 0x01, 0x00, 0x00, 0x00,
2447 // sequence delta (skip one packet)
2450 0x02, 0x00, 0x00, 0x00,
2453 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2454 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2456 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2457 ASSERT_TRUE(visitor_.header_.get());
2458 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2460 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2461 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size());
2462 const QuicCongestionFeedbackFrame& frame =
2463 *visitor_.congestion_feedback_frames_[0];
2464 ASSERT_EQ(kInterArrival, frame.type);
2465 ASSERT_EQ(3u, frame.inter_arrival.received_packet_times.size());
2466 TimeMap::const_iterator iter =
2467 frame.inter_arrival.received_packet_times.begin();
2468 EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first);
2469 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59687),
2470 iter->second.Subtract(start_).ToMicroseconds());
2472 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first);
2473 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59688),
2474 iter->second.Subtract(start_).ToMicroseconds());
2476 EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first);
2477 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59689),
2478 iter->second.Subtract(start_).ToMicroseconds());
2480 // Now test framing boundaries
2481 for (size_t i = kQuicFrameTypeSize; i < 31; ++i) {
2482 string expected_error;
2484 expected_error = "Unable to read congestion feedback type.";
2486 expected_error = "Unable to read accumulated number of lost packets.";
2488 expected_error = "Unable to read num received packets.";
2489 } else if (i < 11) {
2490 expected_error = "Unable to read smallest received.";
2491 } else if (i < 19) {
2492 expected_error = "Unable to read time received.";
2493 } else if (i < 21) {
2494 expected_error = "Unable to read sequence delta in received packets.";
2495 } else if (i < 25) {
2496 expected_error = "Unable to read time delta in received packets.";
2497 } else if (i < 27) {
2498 expected_error = "Unable to read sequence delta in received packets.";
2499 } else if (i < 31) {
2500 expected_error = "Unable to read time delta in received packets.";
2502 CheckProcessingFails(
2504 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2505 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2506 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
2510 TEST_P(QuicFramerTest, CongestionFeedbackFrameFixRate) {
2511 unsigned char packet[] = {
2512 // public flags (8 byte guid)
2515 0x10, 0x32, 0x54, 0x76,
2516 0x98, 0xBA, 0xDC, 0xFE,
2517 // packet sequence number
2518 0xBC, 0x9A, 0x78, 0x56,
2523 // frame type (congestion feedback frame)
2525 // congestion feedback type (fix rate)
2527 // bitrate_in_bytes_per_second;
2528 0x01, 0x02, 0x03, 0x04,
2531 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2532 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2534 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2535 ASSERT_TRUE(visitor_.header_.get());
2536 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2538 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2539 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size());
2540 const QuicCongestionFeedbackFrame& frame =
2541 *visitor_.congestion_feedback_frames_[0];
2542 ASSERT_EQ(kFixRate, frame.type);
2543 EXPECT_EQ(static_cast<uint32>(0x04030201),
2544 frame.fix_rate.bitrate.ToBytesPerSecond());
2546 // Now test framing boundaries
2547 for (size_t i = kQuicFrameTypeSize; i < 6; ++i) {
2548 string expected_error;
2550 expected_error = "Unable to read congestion feedback type.";
2552 expected_error = "Unable to read bitrate.";
2554 CheckProcessingFails(
2556 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2557 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2558 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA);
2562 TEST_P(QuicFramerTest, CongestionFeedbackFrameInvalidFeedback) {
2563 unsigned char packet[] = {
2564 // public flags (8 byte guid)
2567 0x10, 0x32, 0x54, 0x76,
2568 0x98, 0xBA, 0xDC, 0xFE,
2569 // packet sequence number
2570 0xBC, 0x9A, 0x78, 0x56,
2575 // frame type (congestion feedback frame)
2577 // congestion feedback type (invalid)
2581 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2582 EXPECT_FALSE(framer_.ProcessPacket(encrypted));
2583 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2584 EXPECT_EQ(QUIC_INVALID_CONGESTION_FEEDBACK_DATA, framer_.error());
2587 TEST_P(QuicFramerTest, RstStreamFrameVersion13) {
2588 if (version_ > QUIC_VERSION_13) {
2592 unsigned char packet[] = {
2593 // public flags (8 byte guid)
2596 0x10, 0x32, 0x54, 0x76,
2597 0x98, 0xBA, 0xDC, 0xFE,
2598 // packet sequence number
2599 0xBC, 0x9A, 0x78, 0x56,
2604 // frame type (rst stream frame)
2607 0x04, 0x03, 0x02, 0x01,
2609 0x01, 0x00, 0x00, 0x00,
2611 // error details length
2620 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2621 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2623 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2624 ASSERT_TRUE(visitor_.header_.get());
2625 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2627 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id);
2628 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
2629 EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details);
2631 // Now test framing boundaries
2632 for (size_t i = kQuicFrameTypeSize;
2633 i < QuicFramer::GetMinRstStreamFrameSize(version_); ++i) {
2634 string expected_error;
2635 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2636 expected_error = "Unable to read stream_id.";
2637 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2638 kQuicErrorCodeSize) {
2639 expected_error = "Unable to read rst stream error code.";
2641 expected_error = "Unable to read rst stream error details.";
2643 CheckProcessingFails(
2645 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2646 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2647 expected_error, QUIC_INVALID_RST_STREAM_DATA);
2651 TEST_P(QuicFramerTest, RstStreamFrameQuic) {
2652 if (version_ <= QUIC_VERSION_13) {
2656 unsigned char packet[] = {
2657 // public flags (8 byte guid)
2660 0x10, 0x32, 0x54, 0x76,
2661 0x98, 0xBA, 0xDC, 0xFE,
2662 // packet sequence number
2663 0xBC, 0x9A, 0x78, 0x56,
2668 // frame type (rst stream frame)
2671 0x04, 0x03, 0x02, 0x01,
2674 0x01, 0x02, 0x03, 0x04,
2675 0x05, 0x06, 0x07, 0x08,
2678 0x01, 0x00, 0x00, 0x00,
2680 // error details length
2689 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2690 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2692 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2693 ASSERT_TRUE(visitor_.header_.get());
2694 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2696 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id);
2697 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
2698 EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details);
2699 EXPECT_EQ(GG_UINT64_C(0x0807060504030201),
2700 visitor_.rst_stream_frame_.byte_offset);
2702 // Now test framing boundaries
2703 for (size_t i = kQuicFrameTypeSize;
2704 i < QuicFramer::GetMinRstStreamFrameSize(version_); ++i) {
2705 string expected_error;
2706 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2707 expected_error = "Unable to read stream_id.";
2708 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2709 + kQuicMaxStreamOffsetSize) {
2710 expected_error = "Unable to read rst stream sent byte offset.";
2711 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2712 + kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) {
2713 expected_error = "Unable to read rst stream error code.";
2715 expected_error = "Unable to read rst stream error details.";
2717 CheckProcessingFails(
2719 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2720 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2721 expected_error, QUIC_INVALID_RST_STREAM_DATA);
2725 TEST_P(QuicFramerTest, ConnectionCloseFrame) {
2726 unsigned char packet[] = {
2727 // public flags (8 byte guid)
2730 0x10, 0x32, 0x54, 0x76,
2731 0x98, 0xBA, 0xDC, 0xFE,
2732 // packet sequence number
2733 0xBC, 0x9A, 0x78, 0x56,
2738 // frame type (connection close frame)
2741 0x11, 0x00, 0x00, 0x00,
2743 // error details length
2752 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2753 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2755 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2756 ASSERT_TRUE(visitor_.header_.get());
2757 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2759 EXPECT_EQ(0u, visitor_.stream_frames_.size());
2761 EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code);
2762 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
2764 ASSERT_EQ(0u, visitor_.ack_frames_.size());
2766 // Now test framing boundaries
2767 for (size_t i = kQuicFrameTypeSize;
2768 i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) {
2769 string expected_error;
2770 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
2771 expected_error = "Unable to read connection close error code.";
2773 expected_error = "Unable to read connection close error details.";
2775 CheckProcessingFails(
2777 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2778 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2779 expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA);
2783 TEST_P(QuicFramerTest, GoAwayFrame) {
2784 unsigned char packet[] = {
2785 // public flags (8 byte guid)
2788 0x10, 0x32, 0x54, 0x76,
2789 0x98, 0xBA, 0xDC, 0xFE,
2790 // packet sequence number
2791 0xBC, 0x9A, 0x78, 0x56,
2796 // frame type (go away frame)
2799 0x09, 0x00, 0x00, 0x00,
2801 0x04, 0x03, 0x02, 0x01,
2802 // error details length
2811 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2812 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2814 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2815 ASSERT_TRUE(visitor_.header_.get());
2816 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2818 EXPECT_EQ(GG_UINT64_C(0x01020304),
2819 visitor_.goaway_frame_.last_good_stream_id);
2820 EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code);
2821 EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
2823 const size_t reason_size = arraysize("because I can") - 1;
2824 // Now test framing boundaries
2825 for (size_t i = kQuicFrameTypeSize;
2826 i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) {
2827 string expected_error;
2828 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
2829 expected_error = "Unable to read go away error code.";
2830 } else if (i < kQuicFrameTypeSize + kQuicErrorCodeSize +
2831 kQuicMaxStreamIdSize) {
2832 expected_error = "Unable to read last good stream id.";
2834 expected_error = "Unable to read goaway reason.";
2836 CheckProcessingFails(
2838 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2839 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2840 expected_error, QUIC_INVALID_GOAWAY_DATA);
2844 TEST_P(QuicFramerTest, WindowUpdateFrame) {
2845 unsigned char packet[] = {
2846 // public flags (8 byte guid)
2849 0x10, 0x32, 0x54, 0x76,
2850 0x98, 0xBA, 0xDC, 0xFE,
2851 // packet sequence number
2852 0xBC, 0x9A, 0x78, 0x56,
2857 // frame type (window update frame)
2860 0x04, 0x03, 0x02, 0x01,
2862 0x05, 0x06, 0x07, 0x08,
2863 0x09, 0x0a, 0x0b, 0x0c,
2866 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2868 // WINDOW_UPDATE frame introduced in QUIC_VERSION_14.
2869 if (version_ <= QUIC_VERSION_13) {
2870 string expected_error = "Trying to read a WindowUpdateFrame in " +
2871 QuicVersionToString(version_);
2872 EXPECT_DFATAL(framer_.ProcessPacket(encrypted), expected_error);
2876 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2878 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2879 ASSERT_TRUE(visitor_.header_.get());
2880 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2882 EXPECT_EQ(GG_UINT64_C(0x01020304),
2883 visitor_.window_update_frame_.stream_id);
2884 EXPECT_EQ(GG_UINT64_C(0x0c0b0a0908070605),
2885 visitor_.window_update_frame_.byte_offset);
2887 // Now test framing boundaries
2888 for (size_t i = kQuicFrameTypeSize;
2889 i < QuicFramer::GetWindowUpdateFrameSize(); ++i) {
2890 string expected_error;
2891 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2892 expected_error = "Unable to read stream_id.";
2894 expected_error = "Unable to read window byte_offset.";
2896 CheckProcessingFails(
2898 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2899 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2900 expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA);
2904 TEST_P(QuicFramerTest, BlockedFrame) {
2905 unsigned char packet[] = {
2906 // public flags (8 byte guid)
2909 0x10, 0x32, 0x54, 0x76,
2910 0x98, 0xBA, 0xDC, 0xFE,
2911 // packet sequence number
2912 0xBC, 0x9A, 0x78, 0x56,
2917 // frame type (blocked frame)
2920 0x04, 0x03, 0x02, 0x01,
2923 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2925 // BLOCKED frame introduced in QUIC_VERSION_14.
2926 if (version_ <= QUIC_VERSION_13) {
2927 string expected_error =
2928 "Trying to read a BlockedFrame in " + QuicVersionToString(version_);
2929 EXPECT_DFATAL(framer_.ProcessPacket(encrypted), expected_error);
2933 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2935 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2936 ASSERT_TRUE(visitor_.header_.get());
2937 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2939 EXPECT_EQ(GG_UINT64_C(0x01020304),
2940 visitor_.blocked_frame_.stream_id);
2942 // Now test framing boundaries
2943 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize();
2945 string expected_error = "Unable to read stream_id.";
2946 CheckProcessingFails(
2948 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
2949 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
2950 expected_error, QUIC_INVALID_BLOCKED_DATA);
2954 TEST_P(QuicFramerTest, PublicResetPacket) {
2955 unsigned char packet[] = {
2956 // public flags (public reset, 8 byte guid)
2959 0x10, 0x32, 0x54, 0x76,
2960 0x98, 0xBA, 0xDC, 0xFE,
2961 // message tag (kPRST)
2963 // num_entries (2) + padding
2964 0x02, 0x00, 0x00, 0x00,
2968 0x08, 0x00, 0x00, 0x00,
2972 0x10, 0x00, 0x00, 0x00,
2974 0x89, 0x67, 0x45, 0x23,
2975 0x01, 0xEF, 0xCD, 0xAB,
2976 // rejected sequence number
2977 0xBC, 0x9A, 0x78, 0x56,
2978 0x34, 0x12, 0x00, 0x00,
2981 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2982 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2983 ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
2984 ASSERT_TRUE(visitor_.public_reset_packet_.get());
2985 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
2986 visitor_.public_reset_packet_->public_header.guid);
2987 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
2988 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
2989 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789),
2990 visitor_.public_reset_packet_->nonce_proof);
2991 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
2992 visitor_.public_reset_packet_->rejected_sequence_number);
2994 visitor_.public_reset_packet_->client_address.address().empty());
2996 // Now test framing boundaries
2997 for (size_t i = 0; i < arraysize(packet); ++i) {
2998 string expected_error;
2999 DVLOG(1) << "iteration: " << i;
3000 if (i < kGuidOffset) {
3001 expected_error = "Unable to read public flags.";
3002 CheckProcessingFails(packet, i, expected_error,
3003 QUIC_INVALID_PACKET_HEADER);
3004 } else if (i < kPublicResetPacketMessageTagOffset) {
3005 expected_error = "Unable to read GUID.";
3006 CheckProcessingFails(packet, i, expected_error,
3007 QUIC_INVALID_PACKET_HEADER);
3009 expected_error = "Unable to read reset message.";
3010 CheckProcessingFails(packet, i, expected_error,
3011 QUIC_INVALID_PUBLIC_RST_PACKET);
3016 TEST_P(QuicFramerTest, PublicResetPacketWithTrailingJunk) {
3017 unsigned char packet[] = {
3018 // public flags (public reset, 8 byte guid)
3021 0x10, 0x32, 0x54, 0x76,
3022 0x98, 0xBA, 0xDC, 0xFE,
3023 // message tag (kPRST)
3025 // num_entries (2) + padding
3026 0x02, 0x00, 0x00, 0x00,
3030 0x08, 0x00, 0x00, 0x00,
3034 0x10, 0x00, 0x00, 0x00,
3036 0x89, 0x67, 0x45, 0x23,
3037 0x01, 0xEF, 0xCD, 0xAB,
3038 // rejected sequence number
3039 0xBC, 0x9A, 0x78, 0x56,
3040 0x34, 0x12, 0x00, 0x00,
3045 string expected_error = "Unable to read reset message.";
3046 CheckProcessingFails(packet, arraysize(packet), expected_error,
3047 QUIC_INVALID_PUBLIC_RST_PACKET);
3050 TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) {
3051 unsigned char packet[] = {
3052 // public flags (public reset, 8 byte guid)
3055 0x10, 0x32, 0x54, 0x76,
3056 0x98, 0xBA, 0xDC, 0xFE,
3057 // message tag (kPRST)
3059 // num_entries (3) + padding
3060 0x03, 0x00, 0x00, 0x00,
3064 0x08, 0x00, 0x00, 0x00,
3068 0x10, 0x00, 0x00, 0x00,
3072 0x18, 0x00, 0x00, 0x00,
3074 0x89, 0x67, 0x45, 0x23,
3075 0x01, 0xEF, 0xCD, 0xAB,
3076 // rejected sequence number
3077 0xBC, 0x9A, 0x78, 0x56,
3078 0x34, 0x12, 0x00, 0x00,
3079 // client address: 4.31.198.44:443
3081 0x04, 0x1F, 0xC6, 0x2C,
3085 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
3086 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
3087 ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
3088 ASSERT_TRUE(visitor_.public_reset_packet_.get());
3089 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
3090 visitor_.public_reset_packet_->public_header.guid);
3091 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
3092 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
3093 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789),
3094 visitor_.public_reset_packet_->nonce_proof);
3095 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
3096 visitor_.public_reset_packet_->rejected_sequence_number);
3097 EXPECT_EQ("4.31.198.44",
3098 IPAddressToString(visitor_.public_reset_packet_->
3099 client_address.address()));
3100 EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
3102 // Now test framing boundaries
3103 for (size_t i = 0; i < arraysize(packet); ++i) {
3104 string expected_error;
3105 DVLOG(1) << "iteration: " << i;
3106 if (i < kGuidOffset) {
3107 expected_error = "Unable to read public flags.";
3108 CheckProcessingFails(packet, i, expected_error,
3109 QUIC_INVALID_PACKET_HEADER);
3110 } else if (i < kPublicResetPacketMessageTagOffset) {
3111 expected_error = "Unable to read GUID.";
3112 CheckProcessingFails(packet, i, expected_error,
3113 QUIC_INVALID_PACKET_HEADER);
3115 expected_error = "Unable to read reset message.";
3116 CheckProcessingFails(packet, i, expected_error,
3117 QUIC_INVALID_PUBLIC_RST_PACKET);
3122 // TODO(wtc): remove this test when we drop support for QUIC_VERSION_13.
3123 TEST_P(QuicFramerTest, PublicResetPacketOld) {
3124 unsigned char packet[] = {
3125 // public flags (public reset, 8 byte guid)
3128 0x10, 0x32, 0x54, 0x76,
3129 0x98, 0xBA, 0xDC, 0xFE,
3131 0x89, 0x67, 0x45, 0x23,
3132 0x01, 0xEF, 0xCD, 0xAB,
3133 // rejected sequence number
3134 0xBC, 0x9A, 0x78, 0x56,
3138 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
3139 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
3140 ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
3141 ASSERT_TRUE(visitor_.public_reset_packet_.get());
3142 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210),
3143 visitor_.public_reset_packet_->public_header.guid);
3144 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
3145 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
3146 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789),
3147 visitor_.public_reset_packet_->nonce_proof);
3148 EXPECT_EQ(GG_UINT64_C(0x123456789ABC),
3149 visitor_.public_reset_packet_->rejected_sequence_number);
3151 visitor_.public_reset_packet_->client_address.address().empty());
3153 // Now test framing boundaries
3154 for (size_t i = 0; i < arraysize(packet); ++i) {
3155 string expected_error;
3156 DVLOG(1) << "iteration: " << i;
3157 if (i < kGuidOffset) {
3158 expected_error = "Unable to read public flags.";
3159 CheckProcessingFails(packet, i, expected_error,
3160 QUIC_INVALID_PACKET_HEADER);
3161 } else if (i < kPublicResetPacketNonceProofOffset) {
3162 expected_error = "Unable to read GUID.";
3163 CheckProcessingFails(packet, i, expected_error,
3164 QUIC_INVALID_PACKET_HEADER);
3165 } else if (i < kPublicResetPacketRejectedSequenceNumberOffset) {
3166 expected_error = "Unable to read nonce proof.";
3167 CheckProcessingFails(packet, i, expected_error,
3168 QUIC_INVALID_PUBLIC_RST_PACKET);
3170 expected_error = "Unable to read rejected sequence number.";
3171 CheckProcessingFails(packet, i, expected_error,
3172 QUIC_INVALID_PUBLIC_RST_PACKET);
3177 TEST_P(QuicFramerTest, VersionNegotiationPacket) {
3178 unsigned char packet[] = {
3179 // public flags (version, 8 byte guid)
3182 0x10, 0x32, 0x54, 0x76,
3183 0x98, 0xBA, 0xDC, 0xFE,
3185 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
3189 QuicFramerPeer::SetIsServer(&framer_, false);
3191 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
3192 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
3193 ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
3194 ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
3195 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
3196 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
3198 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_GUID; ++i) {
3199 string expected_error;
3200 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER;
3201 if (i < kGuidOffset) {
3202 expected_error = "Unable to read public flags.";
3203 } else if (i < kVersionOffset) {
3204 expected_error = "Unable to read GUID.";
3206 expected_error = "Unable to read supported version in negotiation.";
3207 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
3209 CheckProcessingFails(packet, i, expected_error, error_code);
3213 TEST_P(QuicFramerTest, FecPacket) {
3214 unsigned char packet[] = {
3215 // public flags (8 byte guid)
3218 0x10, 0x32, 0x54, 0x76,
3219 0x98, 0xBA, 0xDC, 0xFE,
3220 // packet sequence number
3221 0xBC, 0x9A, 0x78, 0x56,
3223 // private flags (fec group & FEC)
3225 // first fec protected packet offset
3235 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
3236 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
3238 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
3239 ASSERT_TRUE(visitor_.header_.get());
3240 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
3242 EXPECT_EQ(0u, visitor_.stream_frames_.size());
3243 EXPECT_EQ(0u, visitor_.ack_frames_.size());
3244 ASSERT_EQ(1, visitor_.fec_count_);
3245 const QuicFecData& fec_data = *visitor_.fec_data_[0];
3246 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), fec_data.fec_group);
3247 EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy);
3250 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
3251 QuicPacketHeader header;
3252 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3253 header.public_header.reset_flag = false;
3254 header.public_header.version_flag = false;
3255 header.fec_flag = false;
3256 header.entropy_flag = false;
3257 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3258 header.fec_group = 0;
3260 QuicPaddingFrame padding_frame;
3263 frames.push_back(QuicFrame(&padding_frame));
3265 unsigned char packet[kMaxPacketSize] = {
3266 // public flags (8 byte guid)
3269 0x10, 0x32, 0x54, 0x76,
3270 0x98, 0xBA, 0xDC, 0xFE,
3271 // packet sequence number
3272 0xBC, 0x9A, 0x78, 0x56,
3277 // frame type (padding frame)
3279 0x00, 0x00, 0x00, 0x00
3282 uint64 header_size =
3283 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
3284 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
3285 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3287 scoped_ptr<QuicPacket> data(
3288 framer_.BuildUnsizedDataPacket(header, frames).packet);
3289 ASSERT_TRUE(data != NULL);
3291 test::CompareCharArraysWithHexError("constructed packet",
3292 data->data(), data->length(),
3297 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) {
3298 QuicPacketHeader header;
3299 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3300 header.public_header.reset_flag = false;
3301 header.public_header.version_flag = false;
3302 header.fec_flag = false;
3303 header.entropy_flag = false;
3304 header.public_header.sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER;
3305 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3306 header.fec_group = 0;
3308 QuicPaddingFrame padding_frame;
3311 frames.push_back(QuicFrame(&padding_frame));
3313 unsigned char packet[kMaxPacketSize] = {
3314 // public flags (8 byte guid and 4 byte sequence number)
3317 0x10, 0x32, 0x54, 0x76,
3318 0x98, 0xBA, 0xDC, 0xFE,
3319 // packet sequence number
3320 0xBC, 0x9A, 0x78, 0x56,
3324 // frame type (padding frame)
3326 0x00, 0x00, 0x00, 0x00
3329 uint64 header_size =
3330 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
3331 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
3332 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3334 scoped_ptr<QuicPacket> data(
3335 framer_.BuildUnsizedDataPacket(header, frames).packet);
3336 ASSERT_TRUE(data != NULL);
3338 test::CompareCharArraysWithHexError("constructed packet",
3339 data->data(), data->length(),
3344 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
3345 QuicPacketHeader header;
3346 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3347 header.public_header.reset_flag = false;
3348 header.public_header.version_flag = false;
3349 header.fec_flag = false;
3350 header.entropy_flag = false;
3351 header.public_header.sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER;
3352 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3353 header.fec_group = 0;
3355 QuicPaddingFrame padding_frame;
3358 frames.push_back(QuicFrame(&padding_frame));
3360 unsigned char packet[kMaxPacketSize] = {
3361 // public flags (8 byte guid and 2 byte sequence number)
3364 0x10, 0x32, 0x54, 0x76,
3365 0x98, 0xBA, 0xDC, 0xFE,
3366 // packet sequence number
3371 // frame type (padding frame)
3373 0x00, 0x00, 0x00, 0x00
3376 uint64 header_size =
3377 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
3378 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
3379 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3381 scoped_ptr<QuicPacket> data(
3382 framer_.BuildUnsizedDataPacket(header, frames).packet);
3383 ASSERT_TRUE(data != NULL);
3385 test::CompareCharArraysWithHexError("constructed packet",
3386 data->data(), data->length(),
3391 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
3392 QuicPacketHeader header;
3393 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3394 header.public_header.reset_flag = false;
3395 header.public_header.version_flag = false;
3396 header.fec_flag = false;
3397 header.entropy_flag = false;
3398 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER;
3399 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3400 header.fec_group = 0;
3402 QuicPaddingFrame padding_frame;
3405 frames.push_back(QuicFrame(&padding_frame));
3407 unsigned char packet[kMaxPacketSize] = {
3408 // public flags (8 byte guid and 1 byte sequence number)
3411 0x10, 0x32, 0x54, 0x76,
3412 0x98, 0xBA, 0xDC, 0xFE,
3413 // packet sequence number
3418 // frame type (padding frame)
3420 0x00, 0x00, 0x00, 0x00
3423 uint64 header_size =
3424 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion,
3425 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
3426 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3428 scoped_ptr<QuicPacket> data(
3429 framer_.BuildUnsizedDataPacket(header, frames).packet);
3430 ASSERT_TRUE(data != NULL);
3432 test::CompareCharArraysWithHexError("constructed packet",
3433 data->data(), data->length(),
3438 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
3439 QuicPacketHeader header;
3440 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3441 header.public_header.reset_flag = false;
3442 header.public_header.version_flag = false;
3443 header.fec_flag = false;
3444 header.entropy_flag = true;
3445 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC);
3446 header.fec_group = 0;
3448 QuicStreamFrame stream_frame;
3449 stream_frame.stream_id = 0x01020304;
3450 stream_frame.fin = true;
3451 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
3452 stream_frame.data = MakeIOVector("hello world!");
3455 frames.push_back(QuicFrame(&stream_frame));
3457 unsigned char packet[] = {
3458 // public flags (8 byte guid)
3461 0x10, 0x32, 0x54, 0x76,
3462 0x98, 0xBA, 0xDC, 0xFE,
3463 // packet sequence number
3464 0xBC, 0x9A, 0x78, 0x56,
3466 // private flags (entropy)
3469 // frame type (stream frame with fin and no length)
3472 0x04, 0x03, 0x02, 0x01,
3474 0x54, 0x76, 0x10, 0x32,
3475 0xDC, 0xFE, 0x98, 0xBA,
3482 scoped_ptr<QuicPacket> data(
3483 framer_.BuildUnsizedDataPacket(header, frames).packet);
3484 ASSERT_TRUE(data != NULL);
3486 test::CompareCharArraysWithHexError("constructed packet",
3487 data->data(), data->length(),
3488 AsChars(packet), arraysize(packet));
3491 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) {
3492 QuicPacketHeader header;
3493 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3494 header.public_header.reset_flag = false;
3495 header.public_header.version_flag = true;
3496 header.fec_flag = false;
3497 header.entropy_flag = true;
3498 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC);
3499 header.fec_group = 0;
3501 QuicStreamFrame stream_frame;
3502 stream_frame.stream_id = 0x01020304;
3503 stream_frame.fin = true;
3504 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654);
3505 stream_frame.data = MakeIOVector("hello world!");
3508 frames.push_back(QuicFrame(&stream_frame));
3510 unsigned char packet[] = {
3511 // public flags (version, 8 byte guid)
3514 0x10, 0x32, 0x54, 0x76,
3515 0x98, 0xBA, 0xDC, 0xFE,
3517 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
3518 // packet sequence number
3519 0xBC, 0x9A, 0x78, 0x56,
3521 // private flags (entropy)
3524 // frame type (stream frame with fin and no length)
3527 0x04, 0x03, 0x02, 0x01,
3529 0x54, 0x76, 0x10, 0x32,
3530 0xDC, 0xFE, 0x98, 0xBA,
3537 QuicFramerPeer::SetIsServer(&framer_, false);
3538 scoped_ptr<QuicPacket> data(
3539 framer_.BuildUnsizedDataPacket(header, frames).packet);
3540 ASSERT_TRUE(data != NULL);
3542 test::CompareCharArraysWithHexError("constructed packet",
3543 data->data(), data->length(),
3544 AsChars(packet), arraysize(packet));
3547 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
3548 QuicPacketPublicHeader header;
3549 header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3550 header.reset_flag = false;
3551 header.version_flag = true;
3553 unsigned char packet[] = {
3554 // public flags (version, 8 byte guid)
3557 0x10, 0x32, 0x54, 0x76,
3558 0x98, 0xBA, 0xDC, 0xFE,
3560 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
3563 QuicVersionVector versions;
3564 versions.push_back(GetParam());
3565 scoped_ptr<QuicEncryptedPacket> data(
3566 framer_.BuildVersionNegotiationPacket(header, versions));
3568 test::CompareCharArraysWithHexError("constructed packet",
3569 data->data(), data->length(),
3570 AsChars(packet), arraysize(packet));
3573 TEST_P(QuicFramerTest, BuildAckFramePacket) {
3574 if (version_ <= QUIC_VERSION_14) {
3577 QuicPacketHeader header;
3578 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3579 header.public_header.reset_flag = false;
3580 header.public_header.version_flag = false;
3581 header.fec_flag = false;
3582 header.entropy_flag = true;
3583 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8);
3584 header.fec_group = 0;
3586 QuicAckFrame ack_frame;
3587 ack_frame.received_info.entropy_hash = 0x43;
3588 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF);
3589 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
3590 ack_frame.received_info.missing_packets.insert(
3591 GG_UINT64_C(0x770123456789ABE));
3592 ack_frame.sent_info.entropy_hash = 0x14;
3593 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x770123456789AA0);
3596 frames.push_back(QuicFrame(&ack_frame));
3598 unsigned char packet[] = {
3599 // public flags (8 byte guid)
3602 0x10, 0x32, 0x54, 0x76,
3603 0x98, 0xBA, 0xDC, 0xFE,
3604 // packet sequence number
3605 0xA8, 0x9A, 0x78, 0x56,
3607 // private flags (entropy)
3610 // frame type (ack frame)
3611 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
3613 // entropy hash of sent packets till least awaiting - 1.
3615 // least packet sequence number awaiting an ack, delta from sequence number.
3616 0x08, 0x00, 0x00, 0x00,
3618 // entropy hash of all received packets.
3620 // largest observed packet sequence number
3621 0xBF, 0x9A, 0x78, 0x56,
3625 // num missing packet ranges
3627 // missing packet delta
3629 // 0 more missing packets in range.
3631 // 0 revived packets.
3635 scoped_ptr<QuicPacket> data(
3636 framer_.BuildUnsizedDataPacket(header, frames).packet);
3637 ASSERT_TRUE(data != NULL);
3639 test::CompareCharArraysWithHexError("constructed packet",
3640 data->data(), data->length(),
3641 AsChars(packet), arraysize(packet));
3644 TEST_P(QuicFramerTest, BuildAckFramePacketV14) {
3645 if (version_ > QUIC_VERSION_14) {
3648 QuicPacketHeader header;
3649 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3650 header.public_header.reset_flag = false;
3651 header.public_header.version_flag = false;
3652 header.fec_flag = false;
3653 header.entropy_flag = true;
3654 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8);
3655 header.fec_group = 0;
3657 QuicAckFrame ack_frame;
3658 ack_frame.received_info.entropy_hash = 0x43;
3659 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF);
3660 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
3661 ack_frame.received_info.missing_packets.insert(
3662 GG_UINT64_C(0x770123456789ABE));
3663 ack_frame.sent_info.entropy_hash = 0x14;
3664 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x770123456789AA0);
3667 frames.push_back(QuicFrame(&ack_frame));
3669 unsigned char packet[] = {
3670 // public flags (8 byte guid)
3673 0x10, 0x32, 0x54, 0x76,
3674 0x98, 0xBA, 0xDC, 0xFE,
3675 // packet sequence number
3676 0xA8, 0x9A, 0x78, 0x56,
3678 // private flags (entropy)
3681 // frame type (ack frame)
3682 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
3684 // entropy hash of sent packets till least awaiting - 1.
3686 // least packet sequence number awaiting an ack, delta from sequence number.
3687 0x08, 0x00, 0x00, 0x00,
3689 // entropy hash of all received packets.
3691 // largest observed packet sequence number
3692 0xBF, 0x9A, 0x78, 0x56,
3696 // num missing packet ranges
3698 // missing packet delta
3700 // 0 more missing packets in range.
3704 scoped_ptr<QuicPacket> data(
3705 framer_.BuildUnsizedDataPacket(header, frames).packet);
3706 ASSERT_TRUE(data != NULL);
3708 test::CompareCharArraysWithHexError("constructed packet",
3709 data->data(), data->length(),
3710 AsChars(packet), arraysize(packet));
3713 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketTCP) {
3714 if (version_ <= QUIC_VERSION_14) {
3717 QuicPacketHeader header;
3718 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3719 header.public_header.reset_flag = false;
3720 header.public_header.version_flag = false;
3721 header.fec_flag = false;
3722 header.entropy_flag = false;
3723 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3724 header.fec_group = 0;
3726 QuicCongestionFeedbackFrame congestion_feedback_frame;
3727 congestion_feedback_frame.type = kTCP;
3728 congestion_feedback_frame.tcp.receive_window = 0x4030;
3731 frames.push_back(QuicFrame(&congestion_feedback_frame));
3733 unsigned char packet[] = {
3734 // public flags (8 byte guid)
3737 0x10, 0x32, 0x54, 0x76,
3738 0x98, 0xBA, 0xDC, 0xFE,
3739 // packet sequence number
3740 0xBC, 0x9A, 0x78, 0x56,
3745 // frame type (congestion feedback frame)
3747 // congestion feedback type (TCP)
3749 // TCP receive window
3753 scoped_ptr<QuicPacket> data(
3754 framer_.BuildUnsizedDataPacket(header, frames).packet);
3755 ASSERT_TRUE(data != NULL);
3757 test::CompareCharArraysWithHexError("constructed packet",
3758 data->data(), data->length(),
3759 AsChars(packet), arraysize(packet));
3762 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketTCPV14) {
3763 if (version_ > QUIC_VERSION_14) {
3766 QuicPacketHeader header;
3767 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3768 header.public_header.reset_flag = false;
3769 header.public_header.version_flag = false;
3770 header.fec_flag = false;
3771 header.entropy_flag = false;
3772 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3773 header.fec_group = 0;
3775 QuicCongestionFeedbackFrame congestion_feedback_frame;
3776 congestion_feedback_frame.type = kTCP;
3777 congestion_feedback_frame.tcp.receive_window = 0x4030;
3780 frames.push_back(QuicFrame(&congestion_feedback_frame));
3782 unsigned char packet[] = {
3783 // public flags (8 byte guid)
3786 0x10, 0x32, 0x54, 0x76,
3787 0x98, 0xBA, 0xDC, 0xFE,
3788 // packet sequence number
3789 0xBC, 0x9A, 0x78, 0x56,
3794 // frame type (congestion feedback frame)
3796 // congestion feedback type (TCP)
3798 // accumulated number of lost packets
3800 // TCP receive window
3804 scoped_ptr<QuicPacket> data(
3805 framer_.BuildUnsizedDataPacket(header, frames).packet);
3806 ASSERT_TRUE(data != NULL);
3808 test::CompareCharArraysWithHexError("constructed packet",
3809 data->data(), data->length(),
3810 AsChars(packet), arraysize(packet));
3813 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInterArrival) {
3814 if (version_ <= QUIC_VERSION_14) {
3817 QuicPacketHeader header;
3818 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3819 header.public_header.reset_flag = false;
3820 header.public_header.version_flag = false;
3821 header.fec_flag = false;
3822 header.entropy_flag = false;
3823 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3824 header.fec_group = 0;
3826 QuicCongestionFeedbackFrame frame;
3827 frame.type = kInterArrival;
3828 frame.inter_arrival.received_packet_times.insert(
3829 make_pair(GG_UINT64_C(0x0123456789ABA),
3830 start_.Add(QuicTime::Delta::FromMicroseconds(
3831 GG_UINT64_C(0x07E1D2C3B4A59687)))));
3832 frame.inter_arrival.received_packet_times.insert(
3833 make_pair(GG_UINT64_C(0x0123456789ABB),
3834 start_.Add(QuicTime::Delta::FromMicroseconds(
3835 GG_UINT64_C(0x07E1D2C3B4A59688)))));
3836 frame.inter_arrival.received_packet_times.insert(
3837 make_pair(GG_UINT64_C(0x0123456789ABD),
3838 start_.Add(QuicTime::Delta::FromMicroseconds(
3839 GG_UINT64_C(0x07E1D2C3B4A59689)))));
3841 frames.push_back(QuicFrame(&frame));
3843 unsigned char packet[] = {
3844 // public flags (8 byte guid)
3847 0x10, 0x32, 0x54, 0x76,
3848 0x98, 0xBA, 0xDC, 0xFE,
3849 // packet sequence number
3850 0xBC, 0x9A, 0x78, 0x56,
3855 // frame type (congestion feedback frame)
3857 // congestion feedback type (inter arrival)
3859 // num received packets
3861 // lowest sequence number
3862 0xBA, 0x9A, 0x78, 0x56,
3865 0x87, 0x96, 0xA5, 0xB4,
3866 0xC3, 0xD2, 0xE1, 0x07,
3870 0x01, 0x00, 0x00, 0x00,
3871 // sequence delta (skip one packet)
3874 0x02, 0x00, 0x00, 0x00,
3877 scoped_ptr<QuicPacket> data(
3878 framer_.BuildUnsizedDataPacket(header, frames).packet);
3879 ASSERT_TRUE(data != NULL);
3881 test::CompareCharArraysWithHexError("constructed packet",
3882 data->data(), data->length(),
3883 AsChars(packet), arraysize(packet));
3886 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInterArrivalV14) {
3887 if (version_ > QUIC_VERSION_14) {
3890 QuicPacketHeader header;
3891 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3892 header.public_header.reset_flag = false;
3893 header.public_header.version_flag = false;
3894 header.fec_flag = false;
3895 header.entropy_flag = false;
3896 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3897 header.fec_group = 0;
3899 QuicCongestionFeedbackFrame frame;
3900 frame.type = kInterArrival;
3901 frame.inter_arrival.received_packet_times.insert(
3902 make_pair(GG_UINT64_C(0x0123456789ABA),
3903 start_.Add(QuicTime::Delta::FromMicroseconds(
3904 GG_UINT64_C(0x07E1D2C3B4A59687)))));
3905 frame.inter_arrival.received_packet_times.insert(
3906 make_pair(GG_UINT64_C(0x0123456789ABB),
3907 start_.Add(QuicTime::Delta::FromMicroseconds(
3908 GG_UINT64_C(0x07E1D2C3B4A59688)))));
3909 frame.inter_arrival.received_packet_times.insert(
3910 make_pair(GG_UINT64_C(0x0123456789ABD),
3911 start_.Add(QuicTime::Delta::FromMicroseconds(
3912 GG_UINT64_C(0x07E1D2C3B4A59689)))));
3914 frames.push_back(QuicFrame(&frame));
3916 unsigned char packet[] = {
3917 // public flags (8 byte guid)
3920 0x10, 0x32, 0x54, 0x76,
3921 0x98, 0xBA, 0xDC, 0xFE,
3922 // packet sequence number
3923 0xBC, 0x9A, 0x78, 0x56,
3928 // frame type (congestion feedback frame)
3930 // congestion feedback type (inter arrival)
3932 // accumulated_number_of_lost_packets
3934 // num received packets
3936 // lowest sequence number
3937 0xBA, 0x9A, 0x78, 0x56,
3940 0x87, 0x96, 0xA5, 0xB4,
3941 0xC3, 0xD2, 0xE1, 0x07,
3945 0x01, 0x00, 0x00, 0x00,
3946 // sequence delta (skip one packet)
3949 0x02, 0x00, 0x00, 0x00,
3952 scoped_ptr<QuicPacket> data(
3953 framer_.BuildUnsizedDataPacket(header, frames).packet);
3954 ASSERT_TRUE(data != NULL);
3956 test::CompareCharArraysWithHexError("constructed packet",
3957 data->data(), data->length(),
3958 AsChars(packet), arraysize(packet));
3961 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketFixRate) {
3962 QuicPacketHeader header;
3963 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
3964 header.public_header.reset_flag = false;
3965 header.public_header.version_flag = false;
3966 header.fec_flag = false;
3967 header.entropy_flag = false;
3968 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
3969 header.fec_group = 0;
3971 QuicCongestionFeedbackFrame congestion_feedback_frame;
3972 congestion_feedback_frame.type = kFixRate;
3973 congestion_feedback_frame.fix_rate.bitrate
3974 = QuicBandwidth::FromBytesPerSecond(0x04030201);
3977 frames.push_back(QuicFrame(&congestion_feedback_frame));
3979 unsigned char packet[] = {
3980 // public flags (8 byte guid)
3983 0x10, 0x32, 0x54, 0x76,
3984 0x98, 0xBA, 0xDC, 0xFE,
3985 // packet sequence number
3986 0xBC, 0x9A, 0x78, 0x56,
3991 // frame type (congestion feedback frame)
3993 // congestion feedback type (fix rate)
3995 // bitrate_in_bytes_per_second;
3996 0x01, 0x02, 0x03, 0x04,
3999 scoped_ptr<QuicPacket> data(
4000 framer_.BuildUnsizedDataPacket(header, frames).packet);
4001 ASSERT_TRUE(data != NULL);
4003 test::CompareCharArraysWithHexError("constructed packet",
4004 data->data(), data->length(),
4005 AsChars(packet), arraysize(packet));
4008 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInvalidFeedback) {
4009 QuicPacketHeader header;
4010 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4011 header.public_header.reset_flag = false;
4012 header.public_header.version_flag = false;
4013 header.fec_flag = false;
4014 header.entropy_flag = false;
4015 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4016 header.fec_group = 0;
4018 QuicCongestionFeedbackFrame congestion_feedback_frame;
4019 congestion_feedback_frame.type =
4020 static_cast<CongestionFeedbackType>(kFixRate + 1);
4023 frames.push_back(QuicFrame(&congestion_feedback_frame));
4025 scoped_ptr<QuicPacket> data;
4027 data.reset(framer_.BuildUnsizedDataPacket(header, frames).packet),
4028 "AppendQuicCongestionFeedbackFrame failed");
4029 ASSERT_TRUE(data == NULL);
4032 TEST_P(QuicFramerTest, BuildRstFramePacketVersion13) {
4033 if (version_ > QUIC_VERSION_13) {
4037 QuicPacketHeader header;
4038 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4039 header.public_header.reset_flag = false;
4040 header.public_header.version_flag = false;
4041 header.fec_flag = false;
4042 header.entropy_flag = false;
4043 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4044 header.fec_group = 0;
4046 QuicRstStreamFrame rst_frame;
4047 rst_frame.stream_id = 0x01020304;
4048 rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
4049 rst_frame.error_details = "because I can";
4051 unsigned char packet[] = {
4052 // public flags (8 byte guid)
4055 0x10, 0x32, 0x54, 0x76,
4056 0x98, 0xBA, 0xDC, 0xFE,
4057 // packet sequence number
4058 0xBC, 0x9A, 0x78, 0x56,
4063 // frame type (rst stream frame)
4066 0x04, 0x03, 0x02, 0x01,
4068 0x08, 0x07, 0x06, 0x05,
4069 // error details length
4079 frames.push_back(QuicFrame(&rst_frame));
4081 scoped_ptr<QuicPacket> data(
4082 framer_.BuildUnsizedDataPacket(header, frames).packet);
4083 ASSERT_TRUE(data != NULL);
4085 test::CompareCharArraysWithHexError("constructed packet",
4086 data->data(), data->length(),
4087 AsChars(packet), arraysize(packet));
4090 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
4091 if (version_ <= QUIC_VERSION_13) {
4095 QuicPacketHeader header;
4096 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4097 header.public_header.reset_flag = false;
4098 header.public_header.version_flag = false;
4099 header.fec_flag = false;
4100 header.entropy_flag = false;
4101 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4102 header.fec_group = 0;
4104 QuicRstStreamFrame rst_frame;
4105 rst_frame.stream_id = 0x01020304;
4106 rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
4107 rst_frame.error_details = "because I can";
4108 rst_frame.byte_offset = 0x0807060504030201;
4110 unsigned char packet[] = {
4111 // public flags (8 byte guid)
4114 0x10, 0x32, 0x54, 0x76,
4115 0x98, 0xBA, 0xDC, 0xFE,
4116 // packet sequence number
4117 0xBC, 0x9A, 0x78, 0x56,
4122 // frame type (rst stream frame)
4125 0x04, 0x03, 0x02, 0x01,
4127 0x01, 0x02, 0x03, 0x04,
4128 0x05, 0x06, 0x07, 0x08,
4130 0x08, 0x07, 0x06, 0x05,
4131 // error details length
4141 frames.push_back(QuicFrame(&rst_frame));
4143 scoped_ptr<QuicPacket> data(
4144 framer_.BuildUnsizedDataPacket(header, frames).packet);
4145 ASSERT_TRUE(data != NULL);
4147 test::CompareCharArraysWithHexError("constructed packet",
4148 data->data(), data->length(),
4149 AsChars(packet), arraysize(packet));
4152 TEST_P(QuicFramerTest, BuildCloseFramePacket) {
4153 QuicPacketHeader header;
4154 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4155 header.public_header.reset_flag = false;
4156 header.public_header.version_flag = false;
4157 header.fec_flag = false;
4158 header.entropy_flag = true;
4159 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4160 header.fec_group = 0;
4162 QuicConnectionCloseFrame close_frame;
4163 close_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
4164 close_frame.error_details = "because I can";
4167 frames.push_back(QuicFrame(&close_frame));
4169 unsigned char packet[] = {
4170 // public flags (8 byte guid)
4173 0x10, 0x32, 0x54, 0x76,
4174 0x98, 0xBA, 0xDC, 0xFE,
4175 // packet sequence number
4176 0xBC, 0x9A, 0x78, 0x56,
4178 // private flags (entropy)
4181 // frame type (connection close frame)
4184 0x08, 0x07, 0x06, 0x05,
4185 // error details length
4194 scoped_ptr<QuicPacket> data(
4195 framer_.BuildUnsizedDataPacket(header, frames).packet);
4196 ASSERT_TRUE(data != NULL);
4198 test::CompareCharArraysWithHexError("constructed packet",
4199 data->data(), data->length(),
4200 AsChars(packet), arraysize(packet));
4203 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
4204 QuicPacketHeader header;
4205 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4206 header.public_header.reset_flag = false;
4207 header.public_header.version_flag = false;
4208 header.fec_flag = false;
4209 header.entropy_flag = true;
4210 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4211 header.fec_group = 0;
4213 QuicGoAwayFrame goaway_frame;
4214 goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
4215 goaway_frame.last_good_stream_id = 0x01020304;
4216 goaway_frame.reason_phrase = "because I can";
4219 frames.push_back(QuicFrame(&goaway_frame));
4221 unsigned char packet[] = {
4222 // public flags (8 byte guid)
4225 0x10, 0x32, 0x54, 0x76,
4226 0x98, 0xBA, 0xDC, 0xFE,
4227 // packet sequence number
4228 0xBC, 0x9A, 0x78, 0x56,
4230 // private flags(entropy)
4233 // frame type (go away frame)
4236 0x08, 0x07, 0x06, 0x05,
4238 0x04, 0x03, 0x02, 0x01,
4239 // error details length
4248 scoped_ptr<QuicPacket> data(
4249 framer_.BuildUnsizedDataPacket(header, frames).packet);
4250 ASSERT_TRUE(data != NULL);
4252 test::CompareCharArraysWithHexError("constructed packet",
4253 data->data(), data->length(),
4254 AsChars(packet), arraysize(packet));
4257 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
4258 QuicPacketHeader header;
4259 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4260 header.public_header.reset_flag = false;
4261 header.public_header.version_flag = false;
4262 header.fec_flag = false;
4263 header.entropy_flag = true;
4264 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4265 header.fec_group = 0;
4267 QuicWindowUpdateFrame window_update_frame;
4268 window_update_frame.stream_id = 0x01020304;
4269 window_update_frame.byte_offset = 0x1122334455667788;
4272 frames.push_back(QuicFrame(&window_update_frame));
4274 unsigned char packet[] = {
4275 // public flags (8 byte guid)
4278 0x10, 0x32, 0x54, 0x76,
4279 0x98, 0xBA, 0xDC, 0xFE,
4280 // packet sequence number
4281 0xBC, 0x9A, 0x78, 0x56,
4283 // private flags(entropy)
4286 // frame type (window update frame)
4289 0x04, 0x03, 0x02, 0x01,
4291 0x88, 0x77, 0x66, 0x55,
4292 0x44, 0x33, 0x22, 0x11,
4295 if (version_ > QUIC_VERSION_13) {
4296 scoped_ptr<QuicPacket> data(
4297 framer_.BuildUnsizedDataPacket(header, frames).packet);
4298 ASSERT_TRUE(data != NULL);
4300 test::CompareCharArraysWithHexError("constructed packet", data->data(),
4301 data->length(), AsChars(packet),
4304 string expected_error = "Attempt to add a WindowUpdateFrame in " +
4305 QuicVersionToString(version_);
4306 EXPECT_DFATAL(framer_.BuildUnsizedDataPacket(header, frames),
4312 TEST_P(QuicFramerTest, BuildBlockedPacket) {
4313 QuicPacketHeader header;
4314 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4315 header.public_header.reset_flag = false;
4316 header.public_header.version_flag = false;
4317 header.fec_flag = false;
4318 header.entropy_flag = true;
4319 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4320 header.fec_group = 0;
4322 QuicBlockedFrame blocked_frame;
4323 blocked_frame.stream_id = 0x01020304;
4326 frames.push_back(QuicFrame(&blocked_frame));
4328 unsigned char packet[] = {
4329 // public flags (8 byte guid)
4332 0x10, 0x32, 0x54, 0x76,
4333 0x98, 0xBA, 0xDC, 0xFE,
4334 // packet sequence number
4335 0xBC, 0x9A, 0x78, 0x56,
4337 // private flags(entropy)
4340 // frame type (blocked frame)
4343 0x04, 0x03, 0x02, 0x01,
4346 if (version_ > QUIC_VERSION_13) {
4347 scoped_ptr<QuicPacket> data(
4348 framer_.BuildUnsizedDataPacket(header, frames).packet);
4349 ASSERT_TRUE(data != NULL);
4351 test::CompareCharArraysWithHexError("constructed packet", data->data(),
4352 data->length(), AsChars(packet),
4355 string expected_error =
4356 "Attempt to add a BlockedFrame in " + QuicVersionToString(version_);
4357 EXPECT_DFATAL(framer_.BuildUnsizedDataPacket(header, frames),
4363 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
4364 QuicPublicResetPacket reset_packet;
4365 reset_packet.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4366 reset_packet.public_header.reset_flag = true;
4367 reset_packet.public_header.version_flag = false;
4368 reset_packet.rejected_sequence_number = GG_UINT64_C(0x123456789ABC);
4369 reset_packet.nonce_proof = GG_UINT64_C(0xABCDEF0123456789);
4371 unsigned char packet[] = {
4372 // public flags (public reset, 8 byte GUID)
4375 0x10, 0x32, 0x54, 0x76,
4376 0x98, 0xBA, 0xDC, 0xFE,
4377 // message tag (kPRST)
4379 // num_entries (2) + padding
4380 0x02, 0x00, 0x00, 0x00,
4384 0x08, 0x00, 0x00, 0x00,
4388 0x10, 0x00, 0x00, 0x00,
4390 0x89, 0x67, 0x45, 0x23,
4391 0x01, 0xEF, 0xCD, 0xAB,
4392 // rejected sequence number
4393 0xBC, 0x9A, 0x78, 0x56,
4394 0x34, 0x12, 0x00, 0x00,
4397 scoped_ptr<QuicEncryptedPacket> data(
4398 framer_.BuildPublicResetPacket(reset_packet));
4399 ASSERT_TRUE(data != NULL);
4401 test::CompareCharArraysWithHexError("constructed packet",
4402 data->data(), data->length(),
4403 AsChars(packet), arraysize(packet));
4406 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
4407 QuicPublicResetPacket reset_packet;
4408 reset_packet.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4409 reset_packet.public_header.reset_flag = true;
4410 reset_packet.public_header.version_flag = false;
4411 reset_packet.rejected_sequence_number = GG_UINT64_C(0x123456789ABC);
4412 reset_packet.nonce_proof = GG_UINT64_C(0xABCDEF0123456789);
4413 reset_packet.client_address = IPEndPoint(Loopback4(), 0x1234);
4415 unsigned char packet[] = {
4416 // public flags (public reset, 8 byte GUID)
4419 0x10, 0x32, 0x54, 0x76,
4420 0x98, 0xBA, 0xDC, 0xFE,
4421 // message tag (kPRST)
4423 // num_entries (3) + padding
4424 0x03, 0x00, 0x00, 0x00,
4428 0x08, 0x00, 0x00, 0x00,
4432 0x10, 0x00, 0x00, 0x00,
4436 0x18, 0x00, 0x00, 0x00,
4438 0x89, 0x67, 0x45, 0x23,
4439 0x01, 0xEF, 0xCD, 0xAB,
4440 // rejected sequence number
4441 0xBC, 0x9A, 0x78, 0x56,
4442 0x34, 0x12, 0x00, 0x00,
4445 0x7F, 0x00, 0x00, 0x01,
4449 scoped_ptr<QuicEncryptedPacket> data(
4450 framer_.BuildPublicResetPacket(reset_packet));
4451 ASSERT_TRUE(data != NULL);
4453 test::CompareCharArraysWithHexError("constructed packet",
4454 data->data(), data->length(),
4455 AsChars(packet), arraysize(packet));
4458 TEST_P(QuicFramerTest, BuildFecPacket) {
4459 QuicPacketHeader header;
4460 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4461 header.public_header.reset_flag = false;
4462 header.public_header.version_flag = false;
4463 header.fec_flag = true;
4464 header.entropy_flag = true;
4465 header.packet_sequence_number = (GG_UINT64_C(0x123456789ABC));
4466 header.is_in_fec_group = IN_FEC_GROUP;
4467 header.fec_group = GG_UINT64_C(0x123456789ABB);;
4469 QuicFecData fec_data;
4470 fec_data.fec_group = 1;
4471 fec_data.redundancy = "abcdefghijklmnop";
4473 unsigned char packet[] = {
4474 // public flags (8 byte guid)
4477 0x10, 0x32, 0x54, 0x76,
4478 0x98, 0xBA, 0xDC, 0xFE,
4479 // packet sequence number
4480 0xBC, 0x9A, 0x78, 0x56,
4482 // private flags (entropy & fec group & fec packet)
4484 // first fec protected packet offset
4494 scoped_ptr<QuicPacket> data(
4495 framer_.BuildFecPacket(header, fec_data).packet);
4496 ASSERT_TRUE(data != NULL);
4498 test::CompareCharArraysWithHexError("constructed packet",
4499 data->data(), data->length(),
4500 AsChars(packet), arraysize(packet));
4503 TEST_P(QuicFramerTest, EncryptPacket) {
4504 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC);
4505 unsigned char packet[] = {
4506 // public flags (8 byte guid)
4509 0x10, 0x32, 0x54, 0x76,
4510 0x98, 0xBA, 0xDC, 0xFE,
4511 // packet sequence number
4512 0xBC, 0x9A, 0x78, 0x56,
4514 // private flags (fec group & fec packet)
4516 // first fec protected packet offset
4526 scoped_ptr<QuicPacket> raw(
4527 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false,
4528 PACKET_8BYTE_GUID, !kIncludeVersion,
4529 PACKET_6BYTE_SEQUENCE_NUMBER));
4530 scoped_ptr<QuicEncryptedPacket> encrypted(
4531 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw));
4533 ASSERT_TRUE(encrypted.get() != NULL);
4534 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get()));
4537 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {
4538 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC);
4539 unsigned char packet[] = {
4540 // public flags (version, 8 byte guid)
4543 0x10, 0x32, 0x54, 0x76,
4544 0x98, 0xBA, 0xDC, 0xFE,
4547 // packet sequence number
4548 0xBC, 0x9A, 0x78, 0x56,
4550 // private flags (fec group & fec flags)
4552 // first fec protected packet offset
4562 scoped_ptr<QuicPacket> raw(
4563 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false,
4564 PACKET_8BYTE_GUID, kIncludeVersion,
4565 PACKET_6BYTE_SEQUENCE_NUMBER));
4566 scoped_ptr<QuicEncryptedPacket> encrypted(
4567 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw));
4569 ASSERT_TRUE(encrypted.get() != NULL);
4570 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get()));
4573 TEST_P(QuicFramerTest, Truncation) {
4574 QuicPacketHeader header;
4575 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4576 header.public_header.reset_flag = false;
4577 header.public_header.version_flag = false;
4578 header.fec_flag = false;
4579 header.entropy_flag = false;
4580 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4581 header.fec_group = 0;
4583 QuicAckFrame ack_frame;
4584 ack_frame.received_info.largest_observed = 601;
4585 ack_frame.sent_info.least_unacked = header.packet_sequence_number - 1;
4586 for (uint64 i = 1; i < ack_frame.received_info.largest_observed; i += 2) {
4587 ack_frame.received_info.missing_packets.insert(i);
4590 // Create a packet with just the ack
4592 frame.type = ACK_FRAME;
4593 frame.ack_frame = &ack_frame;
4595 frames.push_back(frame);
4597 scoped_ptr<QuicPacket> raw_ack_packet(
4598 framer_.BuildUnsizedDataPacket(header, frames).packet);
4599 ASSERT_TRUE(raw_ack_packet != NULL);
4601 scoped_ptr<QuicEncryptedPacket> ack_packet(
4602 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number,
4605 // Now make sure we can turn our ack packet back into an ack frame
4606 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet));
4607 ASSERT_EQ(1u, visitor_.ack_frames_.size());
4608 const QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
4609 EXPECT_EQ(header.packet_sequence_number - 1,
4610 processed_ack_frame.sent_info.least_unacked);
4611 EXPECT_TRUE(processed_ack_frame.received_info.is_truncated);
4612 EXPECT_EQ(510u, processed_ack_frame.received_info.largest_observed);
4613 ASSERT_EQ(255u, processed_ack_frame.received_info.missing_packets.size());
4614 SequenceNumberSet::const_iterator missing_iter =
4615 processed_ack_frame.received_info.missing_packets.begin();
4616 EXPECT_EQ(1u, *missing_iter);
4617 SequenceNumberSet::const_reverse_iterator last_missing_iter =
4618 processed_ack_frame.received_info.missing_packets.rbegin();
4619 EXPECT_EQ(509u, *last_missing_iter);
4622 TEST_P(QuicFramerTest, CleanTruncation) {
4623 QuicPacketHeader header;
4624 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210);
4625 header.public_header.reset_flag = false;
4626 header.public_header.version_flag = false;
4627 header.fec_flag = false;
4628 header.entropy_flag = true;
4629 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC);
4630 header.fec_group = 0;
4632 QuicAckFrame ack_frame;
4633 ack_frame.received_info.largest_observed = 201;
4634 ack_frame.sent_info.least_unacked = header.packet_sequence_number - 2;
4635 for (uint64 i = 1; i < ack_frame.received_info.largest_observed; ++i) {
4636 ack_frame.received_info.missing_packets.insert(i);
4639 // Create a packet with just the ack
4641 frame.type = ACK_FRAME;
4642 frame.ack_frame = &ack_frame;
4644 frames.push_back(frame);
4646 scoped_ptr<QuicPacket> raw_ack_packet(
4647 framer_.BuildUnsizedDataPacket(header, frames).packet);
4648 ASSERT_TRUE(raw_ack_packet != NULL);
4650 scoped_ptr<QuicEncryptedPacket> ack_packet(
4651 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number,
4654 // Now make sure we can turn our ack packet back into an ack frame
4655 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet));
4657 // Test for clean truncation of the ack by comparing the length of the
4658 // original packets to the re-serialized packets.
4660 frame.type = ACK_FRAME;
4661 frame.ack_frame = visitor_.ack_frames_[0];
4662 frames.push_back(frame);
4664 size_t original_raw_length = raw_ack_packet->length();
4665 raw_ack_packet.reset(
4666 framer_.BuildUnsizedDataPacket(header, frames).packet);
4667 ASSERT_TRUE(raw_ack_packet != NULL);
4668 EXPECT_EQ(original_raw_length, raw_ack_packet->length());
4669 ASSERT_TRUE(raw_ack_packet != NULL);
4672 TEST_P(QuicFramerTest, EntropyFlagTest) {
4673 unsigned char packet[] = {
4674 // public flags (8 byte guid)
4677 0x10, 0x32, 0x54, 0x76,
4678 0x98, 0xBA, 0xDC, 0xFE,
4679 // packet sequence number
4680 0xBC, 0x9A, 0x78, 0x56,
4682 // private flags (Entropy)
4685 // frame type (stream frame with fin and no length)
4688 0x04, 0x03, 0x02, 0x01,
4690 0x54, 0x76, 0x10, 0x32,
4691 0xDC, 0xFE, 0x98, 0xBA,
4698 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4699 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4700 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4701 ASSERT_TRUE(visitor_.header_.get());
4702 EXPECT_TRUE(visitor_.header_->entropy_flag);
4703 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
4704 EXPECT_FALSE(visitor_.header_->fec_flag);
4707 TEST_P(QuicFramerTest, FecEntropyTest) {
4708 unsigned char packet[] = {
4709 // public flags (8 byte guid)
4712 0x10, 0x32, 0x54, 0x76,
4713 0x98, 0xBA, 0xDC, 0xFE,
4714 // packet sequence number
4715 0xBC, 0x9A, 0x78, 0x56,
4717 // private flags (Entropy & fec group & FEC)
4719 // first fec protected packet offset
4722 // frame type (stream frame with fin and no length)
4725 0x04, 0x03, 0x02, 0x01,
4727 0x54, 0x76, 0x10, 0x32,
4728 0xDC, 0xFE, 0x98, 0xBA,
4735 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4736 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4737 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4738 ASSERT_TRUE(visitor_.header_.get());
4739 EXPECT_TRUE(visitor_.header_->fec_flag);
4740 EXPECT_TRUE(visitor_.header_->entropy_flag);
4741 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
4744 TEST_P(QuicFramerTest, StopPacketProcessing) {
4745 unsigned char packet[] = {
4746 // public flags (8 byte guid)
4749 0x10, 0x32, 0x54, 0x76,
4750 0x98, 0xBA, 0xDC, 0xFE,
4751 // packet sequence number
4752 0xBC, 0x9A, 0x78, 0x56,
4757 // frame type (stream frame with fin)
4760 0x04, 0x03, 0x02, 0x01,
4762 0x54, 0x76, 0x10, 0x32,
4763 0xDC, 0xFE, 0x98, 0xBA,
4771 // frame type (ack frame)
4773 // entropy hash of sent packets till least awaiting - 1.
4775 // least packet sequence number awaiting an ack
4776 0xA0, 0x9A, 0x78, 0x56,
4778 // entropy hash of all received packets.
4780 // largest observed packet sequence number
4781 0xBF, 0x9A, 0x78, 0x56,
4783 // num missing packets
4786 0xBE, 0x9A, 0x78, 0x56,
4790 MockFramerVisitor visitor;
4791 framer_.set_visitor(&visitor);
4792 EXPECT_CALL(visitor, OnPacket());
4793 EXPECT_CALL(visitor, OnPacketHeader(_));
4794 EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false));
4795 EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
4796 EXPECT_CALL(visitor, OnPacketComplete());
4797 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true));
4799 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4800 EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4801 EXPECT_EQ(QUIC_NO_ERROR, framer_.error());