1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include <algorithm> 6 #include <map> 7 #include <string> 8 #include <vector> 9 10 #include "base/containers/hash_tables.h" 11 #include "base/logging.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/port.h" 14 #include "base/stl_util.h" 15 #include "net/quic/crypto/quic_decrypter.h" 16 #include "net/quic/crypto/quic_encrypter.h" 17 #include "net/quic/quic_framer.h" 18 #include "net/quic/quic_protocol.h" 19 #include "net/quic/quic_utils.h" 20 #include "net/quic/test_tools/quic_framer_peer.h" 21 #include "net/quic/test_tools/quic_test_utils.h" 22 23 using base::hash_set; 24 using base::StringPiece; 25 using std::make_pair; 26 using std::map; 27 using std::numeric_limits; 28 using std::string; 29 using std::vector; 30 using testing::Return; 31 using testing::_; 32 33 namespace net { 34 namespace test { 35 36 const QuicPacketSequenceNumber kEpoch = GG_UINT64_C(1) << 48; 37 const QuicPacketSequenceNumber kMask = kEpoch - 1; 38 39 // Index into the flags offset in the header. 40 const size_t kPublicFlagsOffset = 0; 41 // Index into the guid offset in the header. 42 const size_t kGuidOffset = kPublicFlagsSize; 43 // Index into the version string in the header. (if present). 44 const size_t kVersionOffset = kGuidOffset + PACKET_8BYTE_GUID; 45 46 // Index into the sequence number offset in the header. 47 size_t GetSequenceNumberOffset(QuicGuidLength guid_length, 48 bool include_version) { 49 return kGuidOffset + guid_length + 50 (include_version ? kQuicVersionSize : 0); 51 } 52 53 size_t GetSequenceNumberOffset(bool include_version) { 54 return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version); 55 } 56 57 // Index into the private flags offset in the data packet header. 58 size_t GetPrivateFlagsOffset(QuicGuidLength guid_length, bool include_version) { 59 return GetSequenceNumberOffset(guid_length, include_version) + 60 PACKET_6BYTE_SEQUENCE_NUMBER; 61 } 62 63 size_t GetPrivateFlagsOffset(bool include_version) { 64 return GetPrivateFlagsOffset(PACKET_8BYTE_GUID, include_version); 65 } 66 67 size_t GetPrivateFlagsOffset(bool include_version, 68 QuicSequenceNumberLength sequence_number_length) { 69 return GetSequenceNumberOffset(PACKET_8BYTE_GUID, include_version) + 70 sequence_number_length; 71 } 72 73 // Index into the fec group offset in the header. 74 size_t GetFecGroupOffset(QuicGuidLength guid_length, bool include_version) { 75 return GetPrivateFlagsOffset(guid_length, include_version) + 76 kPrivateFlagsSize; 77 } 78 79 size_t GetFecGroupOffset(bool include_version) { 80 return GetPrivateFlagsOffset(PACKET_8BYTE_GUID, include_version) + 81 kPrivateFlagsSize; 82 } 83 84 size_t GetFecGroupOffset(bool include_version, 85 QuicSequenceNumberLength sequence_number_length) { 86 return GetPrivateFlagsOffset(include_version, sequence_number_length) + 87 kPrivateFlagsSize; 88 } 89 90 // Index into the nonce proof of the public reset packet. 91 // Public resets always have full guids. 92 const size_t kPublicResetPacketNonceProofOffset = 93 kGuidOffset + PACKET_8BYTE_GUID; 94 95 // Index into the rejected sequence number of the public reset packet. 96 const size_t kPublicResetPacketRejectedSequenceNumberOffset = 97 kPublicResetPacketNonceProofOffset + kPublicResetNonceSize; 98 99 class TestEncrypter : public QuicEncrypter { 100 public: 101 virtual ~TestEncrypter() {} 102 virtual bool SetKey(StringPiece key) OVERRIDE { 103 return true; 104 } 105 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE { 106 return true; 107 } 108 virtual bool Encrypt(StringPiece nonce, 109 StringPiece associated_data, 110 StringPiece plaintext, 111 unsigned char* output) OVERRIDE { 112 CHECK(false) << "Not implemented"; 113 return false; 114 } 115 virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number, 116 StringPiece associated_data, 117 StringPiece plaintext) OVERRIDE { 118 sequence_number_ = sequence_number; 119 associated_data_ = associated_data.as_string(); 120 plaintext_ = plaintext.as_string(); 121 return new QuicData(plaintext.data(), plaintext.length()); 122 } 123 virtual size_t GetKeySize() const OVERRIDE { 124 return 0; 125 } 126 virtual size_t GetNoncePrefixSize() const OVERRIDE { 127 return 0; 128 } 129 virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE { 130 return ciphertext_size; 131 } 132 virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE { 133 return plaintext_size; 134 } 135 virtual StringPiece GetKey() const OVERRIDE { 136 return StringPiece(); 137 } 138 virtual StringPiece GetNoncePrefix() const OVERRIDE { 139 return StringPiece(); 140 } 141 QuicPacketSequenceNumber sequence_number_; 142 string associated_data_; 143 string plaintext_; 144 }; 145 146 class TestDecrypter : public QuicDecrypter { 147 public: 148 virtual ~TestDecrypter() {} 149 virtual bool SetKey(StringPiece key) OVERRIDE { 150 return true; 151 } 152 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE { 153 return true; 154 } 155 virtual bool Decrypt(StringPiece nonce, 156 StringPiece associated_data, 157 StringPiece ciphertext, 158 unsigned char* output, 159 size_t* output_length) OVERRIDE { 160 CHECK(false) << "Not implemented"; 161 return false; 162 } 163 virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number, 164 StringPiece associated_data, 165 StringPiece ciphertext) OVERRIDE { 166 sequence_number_ = sequence_number; 167 associated_data_ = associated_data.as_string(); 168 ciphertext_ = ciphertext.as_string(); 169 return new QuicData(ciphertext.data(), ciphertext.length()); 170 } 171 virtual StringPiece GetKey() const OVERRIDE { 172 return StringPiece(); 173 } 174 virtual StringPiece GetNoncePrefix() const OVERRIDE { 175 return StringPiece(); 176 } 177 QuicPacketSequenceNumber sequence_number_; 178 string associated_data_; 179 string ciphertext_; 180 }; 181 182 class TestQuicVisitor : public ::net::QuicFramerVisitorInterface { 183 public: 184 TestQuicVisitor() 185 : error_count_(0), 186 version_mismatch_(0), 187 packet_count_(0), 188 frame_count_(0), 189 fec_count_(0), 190 complete_packets_(0), 191 revived_packets_(0), 192 accept_packet_(true) { 193 } 194 195 virtual ~TestQuicVisitor() { 196 STLDeleteElements(&stream_frames_); 197 STLDeleteElements(&ack_frames_); 198 STLDeleteElements(&congestion_feedback_frames_); 199 STLDeleteElements(&fec_data_); 200 } 201 202 virtual void OnError(QuicFramer* f) OVERRIDE { 203 DLOG(INFO) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error()) 204 << " (" << f->error() << ")"; 205 error_count_++; 206 } 207 208 virtual void OnPacket() OVERRIDE {} 209 210 virtual void OnPublicResetPacket( 211 const QuicPublicResetPacket& packet) OVERRIDE { 212 public_reset_packet_.reset(new QuicPublicResetPacket(packet)); 213 } 214 215 virtual void OnVersionNegotiationPacket( 216 const QuicVersionNegotiationPacket& packet) OVERRIDE { 217 version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet)); 218 } 219 220 virtual void OnRevivedPacket() OVERRIDE { 221 revived_packets_++; 222 } 223 224 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE { 225 DLOG(INFO) << "QuicFramer Version Mismatch, version: " << version; 226 version_mismatch_++; 227 return true; 228 } 229 230 virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE { 231 packet_count_++; 232 header_.reset(new QuicPacketHeader(header)); 233 return accept_packet_; 234 } 235 236 virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE { 237 frame_count_++; 238 stream_frames_.push_back(new QuicStreamFrame(frame)); 239 return true; 240 } 241 242 virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE { 243 fec_protected_payload_ = payload.as_string(); 244 } 245 246 virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE { 247 frame_count_++; 248 ack_frames_.push_back(new QuicAckFrame(frame)); 249 return true; 250 } 251 252 virtual bool OnCongestionFeedbackFrame( 253 const QuicCongestionFeedbackFrame& frame) OVERRIDE { 254 frame_count_++; 255 congestion_feedback_frames_.push_back( 256 new QuicCongestionFeedbackFrame(frame)); 257 return true; 258 } 259 260 virtual void OnFecData(const QuicFecData& fec) OVERRIDE { 261 fec_count_++; 262 fec_data_.push_back(new QuicFecData(fec)); 263 } 264 265 virtual void OnPacketComplete() OVERRIDE { 266 complete_packets_++; 267 } 268 269 virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE { 270 rst_stream_frame_ = frame; 271 return true; 272 } 273 274 virtual bool OnConnectionCloseFrame( 275 const QuicConnectionCloseFrame& frame) OVERRIDE { 276 connection_close_frame_ = frame; 277 return true; 278 } 279 280 virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE { 281 goaway_frame_ = frame; 282 return true; 283 } 284 285 // Counters from the visitor_ callbacks. 286 int error_count_; 287 int version_mismatch_; 288 int packet_count_; 289 int frame_count_; 290 int fec_count_; 291 int complete_packets_; 292 int revived_packets_; 293 bool accept_packet_; 294 295 scoped_ptr<QuicPacketHeader> header_; 296 scoped_ptr<QuicPublicResetPacket> public_reset_packet_; 297 scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_; 298 vector<QuicStreamFrame*> stream_frames_; 299 vector<QuicAckFrame*> ack_frames_; 300 vector<QuicCongestionFeedbackFrame*> congestion_feedback_frames_; 301 vector<QuicFecData*> fec_data_; 302 string fec_protected_payload_; 303 QuicRstStreamFrame rst_stream_frame_; 304 QuicConnectionCloseFrame connection_close_frame_; 305 QuicGoAwayFrame goaway_frame_; 306 }; 307 308 class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> { 309 public: 310 QuicFramerTest() 311 : encrypter_(new test::TestEncrypter()), 312 decrypter_(new test::TestDecrypter()), 313 start_(QuicTime::Zero().Add(QuicTime::Delta::FromMicroseconds(0x10))), 314 framer_(QuicVersionMax(), start_, true) { 315 framer_.SetDecrypter(decrypter_); 316 framer_.SetEncrypter(ENCRYPTION_NONE, encrypter_); 317 framer_.set_visitor(&visitor_); 318 framer_.set_received_entropy_calculator(&entropy_calculator_); 319 320 version_ = GetParam(); 321 framer_.set_version(version_); 322 } 323 324 bool CheckEncryption(QuicPacketSequenceNumber sequence_number, 325 QuicPacket* packet) { 326 if (sequence_number != encrypter_->sequence_number_) { 327 LOG(ERROR) << "Encrypted incorrect packet sequence number. expected " 328 << sequence_number << " actual: " 329 << encrypter_->sequence_number_; 330 return false; 331 } 332 if (packet->AssociatedData() != encrypter_->associated_data_) { 333 LOG(ERROR) << "Encrypted incorrect associated data. expected " 334 << packet->AssociatedData() << " actual: " 335 << encrypter_->associated_data_; 336 return false; 337 } 338 if (packet->Plaintext() != encrypter_->plaintext_) { 339 LOG(ERROR) << "Encrypted incorrect plaintext data. expected " 340 << packet->Plaintext() << " actual: " 341 << encrypter_->plaintext_; 342 return false; 343 } 344 return true; 345 } 346 347 bool CheckDecryption(const QuicEncryptedPacket& encrypted, 348 bool includes_version) { 349 if (visitor_.header_->packet_sequence_number != 350 decrypter_->sequence_number_) { 351 LOG(ERROR) << "Decrypted incorrect packet sequence number. expected " 352 << visitor_.header_->packet_sequence_number << " actual: " 353 << decrypter_->sequence_number_; 354 return false; 355 } 356 if (QuicFramer::GetAssociatedDataFromEncryptedPacket( 357 encrypted, PACKET_8BYTE_GUID, 358 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) != 359 decrypter_->associated_data_) { 360 LOG(ERROR) << "Decrypted incorrect associated data. expected " 361 << QuicFramer::GetAssociatedDataFromEncryptedPacket( 362 encrypted, PACKET_8BYTE_GUID, 363 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) 364 << " actual: " << decrypter_->associated_data_; 365 return false; 366 } 367 StringPiece ciphertext(encrypted.AsStringPiece().substr( 368 GetStartOfEncryptedData(PACKET_8BYTE_GUID, includes_version, 369 PACKET_6BYTE_SEQUENCE_NUMBER))); 370 if (ciphertext != decrypter_->ciphertext_) { 371 LOG(ERROR) << "Decrypted incorrect ciphertext data. expected " 372 << ciphertext << " actual: " 373 << decrypter_->ciphertext_; 374 return false; 375 } 376 return true; 377 } 378 379 char* AsChars(unsigned char* data) { 380 return reinterpret_cast<char*>(data); 381 } 382 383 void CheckProcessingFails(unsigned char* packet, 384 size_t len, 385 string expected_error, 386 QuicErrorCode error_code) { 387 QuicEncryptedPacket encrypted(AsChars(packet), len, false); 388 EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len; 389 EXPECT_EQ(expected_error, framer_.detailed_error()) << "len: " << len; 390 EXPECT_EQ(error_code, framer_.error()) << "len: " << len; 391 } 392 393 void ValidateTruncatedAck(const QuicAckFrame* ack, size_t keys) { 394 for (size_t i = 1; i < keys; ++i) { 395 EXPECT_TRUE(ContainsKey(ack->received_info.missing_packets, i)) << i; 396 } 397 EXPECT_EQ(keys, ack->received_info.largest_observed); 398 } 399 400 void CheckCalculatePacketSequenceNumber( 401 QuicPacketSequenceNumber expected_sequence_number, 402 QuicPacketSequenceNumber last_sequence_number) { 403 QuicPacketSequenceNumber wire_sequence_number = 404 expected_sequence_number & kMask; 405 QuicFramerPeer::SetLastSequenceNumber(&framer_, last_sequence_number); 406 EXPECT_EQ(expected_sequence_number, 407 QuicFramerPeer::CalculatePacketSequenceNumberFromWire( 408 &framer_, PACKET_6BYTE_SEQUENCE_NUMBER, wire_sequence_number)) 409 << "last_sequence_number: " << last_sequence_number 410 << " wire_sequence_number: " << wire_sequence_number; 411 } 412 413 test::TestEncrypter* encrypter_; 414 test::TestDecrypter* decrypter_; 415 QuicVersion version_; 416 QuicTime start_; 417 QuicFramer framer_; 418 test::TestQuicVisitor visitor_; 419 test::TestEntropyCalculator entropy_calculator_; 420 }; 421 422 // Run all framer tests with all supported versions of QUIC. 423 INSTANTIATE_TEST_CASE_P(QuicFramerTests, 424 QuicFramerTest, 425 ::testing::ValuesIn(kSupportedQuicVersions)); 426 427 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochStart) { 428 // A few quick manual sanity checks 429 CheckCalculatePacketSequenceNumber(GG_UINT64_C(1), GG_UINT64_C(0)); 430 CheckCalculatePacketSequenceNumber(kEpoch + 1, kMask); 431 CheckCalculatePacketSequenceNumber(kEpoch, kMask); 432 433 // Cases where the last number was close to the start of the range 434 for (uint64 last = 0; last < 10; last++) { 435 // Small numbers should not wrap (even if they're out of order). 436 for (uint64 j = 0; j < 10; j++) { 437 CheckCalculatePacketSequenceNumber(j, last); 438 } 439 440 // Large numbers should not wrap either (because we're near 0 already). 441 for (uint64 j = 0; j < 10; j++) { 442 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last); 443 } 444 } 445 } 446 447 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochEnd) { 448 // Cases where the last number was close to the end of the range 449 for (uint64 i = 0; i < 10; i++) { 450 QuicPacketSequenceNumber last = kEpoch - i; 451 452 // Small numbers should wrap. 453 for (uint64 j = 0; j < 10; j++) { 454 CheckCalculatePacketSequenceNumber(kEpoch + j, last); 455 } 456 457 // Large numbers should not (even if they're out of order). 458 for (uint64 j = 0; j < 10; j++) { 459 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last); 460 } 461 } 462 } 463 464 // Next check where we're in a non-zero epoch to verify we handle 465 // reverse wrapping, too. 466 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearPrevEpoch) { 467 const uint64 prev_epoch = 1 * kEpoch; 468 const uint64 cur_epoch = 2 * kEpoch; 469 // Cases where the last number was close to the start of the range 470 for (uint64 i = 0; i < 10; i++) { 471 uint64 last = cur_epoch + i; 472 // Small number should not wrap (even if they're out of order). 473 for (uint64 j = 0; j < 10; j++) { 474 CheckCalculatePacketSequenceNumber(cur_epoch + j, last); 475 } 476 477 // But large numbers should reverse wrap. 478 for (uint64 j = 0; j < 10; j++) { 479 uint64 num = kEpoch - 1 - j; 480 CheckCalculatePacketSequenceNumber(prev_epoch + num, last); 481 } 482 } 483 } 484 485 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextEpoch) { 486 const uint64 cur_epoch = 2 * kEpoch; 487 const uint64 next_epoch = 3 * kEpoch; 488 // Cases where the last number was close to the end of the range 489 for (uint64 i = 0; i < 10; i++) { 490 QuicPacketSequenceNumber last = next_epoch - 1 - i; 491 492 // Small numbers should wrap. 493 for (uint64 j = 0; j < 10; j++) { 494 CheckCalculatePacketSequenceNumber(next_epoch + j, last); 495 } 496 497 // but large numbers should not (even if they're out of order). 498 for (uint64 j = 0; j < 10; j++) { 499 uint64 num = kEpoch - 1 - j; 500 CheckCalculatePacketSequenceNumber(cur_epoch + num, last); 501 } 502 } 503 } 504 505 TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextMax) { 506 const uint64 max_number = numeric_limits<uint64>::max(); 507 const uint64 max_epoch = max_number & ~kMask; 508 509 // Cases where the last number was close to the end of the range 510 for (uint64 i = 0; i < 10; i++) { 511 // Subtract 1, because the expected next sequence number is 1 more than the 512 // last sequence number. 513 QuicPacketSequenceNumber last = max_number - i - 1; 514 515 // Small numbers should not wrap, because they have nowhere to go. 516 for (uint64 j = 0; j < 10; j++) { 517 CheckCalculatePacketSequenceNumber(max_epoch + j, last); 518 } 519 520 // Large numbers should not wrap either. 521 for (uint64 j = 0; j < 10; j++) { 522 uint64 num = kEpoch - 1 - j; 523 CheckCalculatePacketSequenceNumber(max_epoch + num, last); 524 } 525 } 526 } 527 528 TEST_P(QuicFramerTest, EmptyPacket) { 529 char packet[] = { 0x00 }; 530 QuicEncryptedPacket encrypted(packet, 0, false); 531 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 532 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error()); 533 } 534 535 TEST_P(QuicFramerTest, LargePacket) { 536 unsigned char packet[kMaxPacketSize + 1] = { 537 // public flags (8 byte guid) 538 0x3C, 539 // guid 540 0x10, 0x32, 0x54, 0x76, 541 0x98, 0xBA, 0xDC, 0xFE, 542 // packet sequence number 543 0xBC, 0x9A, 0x78, 0x56, 544 0x34, 0x12, 545 // private flags 546 0x00, 547 }; 548 549 memset(packet + GetPacketHeaderSize( 550 PACKET_8BYTE_GUID, !kIncludeVersion, 551 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 0, 552 kMaxPacketSize - GetPacketHeaderSize( 553 PACKET_8BYTE_GUID, !kIncludeVersion, 554 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) + 1); 555 556 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 557 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 558 559 ASSERT_TRUE(visitor_.header_.get()); 560 // Make sure we've parsed the packet header, so we can send an error. 561 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 562 visitor_.header_->public_header.guid); 563 // Make sure the correct error is propagated. 564 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error()); 565 } 566 567 TEST_P(QuicFramerTest, PacketHeader) { 568 unsigned char packet[] = { 569 // public flags (8 byte guid) 570 0x3C, 571 // guid 572 0x10, 0x32, 0x54, 0x76, 573 0x98, 0xBA, 0xDC, 0xFE, 574 // packet sequence number 575 0xBC, 0x9A, 0x78, 0x56, 576 0x34, 0x12, 577 // private flags 578 0x00, 579 }; 580 581 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 582 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 583 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 584 ASSERT_TRUE(visitor_.header_.get()); 585 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 586 visitor_.header_->public_header.guid); 587 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 588 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 589 EXPECT_FALSE(visitor_.header_->fec_flag); 590 EXPECT_FALSE(visitor_.header_->entropy_flag); 591 EXPECT_EQ(0, visitor_.header_->entropy_hash); 592 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 593 visitor_.header_->packet_sequence_number); 594 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 595 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 596 597 // Now test framing boundaries 598 for (size_t i = 0; 599 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 600 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 601 ++i) { 602 string expected_error; 603 if (i < kGuidOffset) { 604 expected_error = "Unable to read public flags."; 605 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 606 expected_error = "Unable to read GUID."; 607 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion)) { 608 expected_error = "Unable to read sequence number."; 609 } else if (i < GetFecGroupOffset(!kIncludeVersion)) { 610 expected_error = "Unable to read private flags."; 611 } else { 612 expected_error = "Unable to read first fec protected packet offset."; 613 } 614 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 615 } 616 } 617 618 TEST_P(QuicFramerTest, PacketHeaderWith4ByteGuid) { 619 QuicFramerPeer::SetLastSerializedGuid(&framer_, 620 GG_UINT64_C(0xFEDCBA9876543210)); 621 622 unsigned char packet[] = { 623 // public flags (4 byte guid) 624 0x38, 625 // guid 626 0x10, 0x32, 0x54, 0x76, 627 // packet sequence number 628 0xBC, 0x9A, 0x78, 0x56, 629 0x34, 0x12, 630 // private flags 631 0x00, 632 }; 633 634 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 635 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 636 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 637 ASSERT_TRUE(visitor_.header_.get()); 638 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 639 visitor_.header_->public_header.guid); 640 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 641 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 642 EXPECT_FALSE(visitor_.header_->fec_flag); 643 EXPECT_FALSE(visitor_.header_->entropy_flag); 644 EXPECT_EQ(0, visitor_.header_->entropy_hash); 645 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 646 visitor_.header_->packet_sequence_number); 647 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 648 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 649 650 // Now test framing boundaries 651 for (size_t i = 0; 652 i < GetPacketHeaderSize(PACKET_4BYTE_GUID, !kIncludeVersion, 653 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 654 ++i) { 655 string expected_error; 656 if (i < kGuidOffset) { 657 expected_error = "Unable to read public flags."; 658 } else if (i < GetSequenceNumberOffset(PACKET_4BYTE_GUID, 659 !kIncludeVersion)) { 660 expected_error = "Unable to read GUID."; 661 } else if (i < GetPrivateFlagsOffset(PACKET_4BYTE_GUID, 662 !kIncludeVersion)) { 663 expected_error = "Unable to read sequence number."; 664 } else if (i < GetFecGroupOffset(PACKET_4BYTE_GUID, !kIncludeVersion)) { 665 expected_error = "Unable to read private flags."; 666 } else { 667 expected_error = "Unable to read first fec protected packet offset."; 668 } 669 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 670 } 671 } 672 673 TEST_P(QuicFramerTest, PacketHeader1ByteGuid) { 674 QuicFramerPeer::SetLastSerializedGuid(&framer_, 675 GG_UINT64_C(0xFEDCBA9876543210)); 676 677 unsigned char packet[] = { 678 // public flags (1 byte guid) 679 0x34, 680 // guid 681 0x10, 682 // packet sequence number 683 0xBC, 0x9A, 0x78, 0x56, 684 0x34, 0x12, 685 // private flags 686 0x00, 687 }; 688 689 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 690 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 691 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 692 ASSERT_TRUE(visitor_.header_.get()); 693 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 694 visitor_.header_->public_header.guid); 695 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 696 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 697 EXPECT_FALSE(visitor_.header_->fec_flag); 698 EXPECT_FALSE(visitor_.header_->entropy_flag); 699 EXPECT_EQ(0, visitor_.header_->entropy_hash); 700 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 701 visitor_.header_->packet_sequence_number); 702 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 703 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 704 705 // Now test framing boundaries 706 for (size_t i = 0; 707 i < GetPacketHeaderSize(PACKET_1BYTE_GUID, !kIncludeVersion, 708 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 709 ++i) { 710 string expected_error; 711 if (i < kGuidOffset) { 712 expected_error = "Unable to read public flags."; 713 } else if (i < GetSequenceNumberOffset(PACKET_1BYTE_GUID, 714 !kIncludeVersion)) { 715 expected_error = "Unable to read GUID."; 716 } else if (i < GetPrivateFlagsOffset(PACKET_1BYTE_GUID, !kIncludeVersion)) { 717 expected_error = "Unable to read sequence number."; 718 } else if (i < GetFecGroupOffset(PACKET_1BYTE_GUID, !kIncludeVersion)) { 719 expected_error = "Unable to read private flags."; 720 } else { 721 expected_error = "Unable to read first fec protected packet offset."; 722 } 723 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 724 } 725 } 726 727 TEST_P(QuicFramerTest, PacketHeaderWith0ByteGuid) { 728 QuicFramerPeer::SetLastSerializedGuid(&framer_, 729 GG_UINT64_C(0xFEDCBA9876543210)); 730 731 unsigned char packet[] = { 732 // public flags (0 byte guid) 733 0x30, 734 // guid 735 // packet sequence number 736 0xBC, 0x9A, 0x78, 0x56, 737 0x34, 0x12, 738 // private flags 739 0x00, 740 }; 741 742 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 743 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 744 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 745 ASSERT_TRUE(visitor_.header_.get()); 746 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 747 visitor_.header_->public_header.guid); 748 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 749 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 750 EXPECT_FALSE(visitor_.header_->fec_flag); 751 EXPECT_FALSE(visitor_.header_->entropy_flag); 752 EXPECT_EQ(0, visitor_.header_->entropy_hash); 753 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 754 visitor_.header_->packet_sequence_number); 755 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 756 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 757 758 // Now test framing boundaries 759 for (size_t i = 0; 760 i < GetPacketHeaderSize(PACKET_0BYTE_GUID, !kIncludeVersion, 761 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 762 ++i) { 763 string expected_error; 764 if (i < kGuidOffset) { 765 expected_error = "Unable to read public flags."; 766 } else if (i < GetSequenceNumberOffset(PACKET_0BYTE_GUID, 767 !kIncludeVersion)) { 768 expected_error = "Unable to read GUID."; 769 } else if (i < GetPrivateFlagsOffset(PACKET_0BYTE_GUID, !kIncludeVersion)) { 770 expected_error = "Unable to read sequence number."; 771 } else if (i < GetFecGroupOffset(PACKET_0BYTE_GUID, !kIncludeVersion)) { 772 expected_error = "Unable to read private flags."; 773 } else { 774 expected_error = "Unable to read first fec protected packet offset."; 775 } 776 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 777 } 778 } 779 780 TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) { 781 // Set a specific version. 782 framer_.set_version(QUIC_VERSION_7); 783 784 unsigned char packet[] = { 785 // public flags (version) 786 0x3D, 787 // guid 788 0x10, 0x32, 0x54, 0x76, 789 0x98, 0xBA, 0xDC, 0xFE, 790 // version tag 791 'Q', '0', '0', '7', 792 // packet sequence number 793 0xBC, 0x9A, 0x78, 0x56, 794 0x34, 0x12, 795 // private flags 796 0x00, 797 }; 798 799 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 800 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 801 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 802 ASSERT_TRUE(visitor_.header_.get()); 803 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 804 visitor_.header_->public_header.guid); 805 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 806 EXPECT_TRUE(visitor_.header_->public_header.version_flag); 807 EXPECT_EQ(QUIC_VERSION_7, visitor_.header_->public_header.versions[0]); 808 EXPECT_FALSE(visitor_.header_->fec_flag); 809 EXPECT_FALSE(visitor_.header_->entropy_flag); 810 EXPECT_EQ(0, visitor_.header_->entropy_hash); 811 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 812 visitor_.header_->packet_sequence_number); 813 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 814 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 815 816 // Now test framing boundaries 817 for (size_t i = 0; 818 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion, 819 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 820 ++i) { 821 string expected_error; 822 if (i < kGuidOffset) { 823 expected_error = "Unable to read public flags."; 824 } else if (i < kVersionOffset) { 825 expected_error = "Unable to read GUID."; 826 } else if (i < GetSequenceNumberOffset(kIncludeVersion)) { 827 expected_error = "Unable to read protocol version."; 828 } else if (i < GetPrivateFlagsOffset(kIncludeVersion)) { 829 expected_error = "Unable to read sequence number."; 830 } else if (i < GetFecGroupOffset(kIncludeVersion)) { 831 expected_error = "Unable to read private flags."; 832 } else { 833 expected_error = "Unable to read first fec protected packet offset."; 834 } 835 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 836 } 837 } 838 839 TEST_P(QuicFramerTest, PacketHeaderWith4ByteSequenceNumber) { 840 QuicFramerPeer::SetLastSequenceNumber(&framer_, 841 GG_UINT64_C(0x123456789ABA)); 842 843 unsigned char packet[] = { 844 // public flags (8 byte guid and 4 byte sequence number) 845 0x2C, 846 // guid 847 0x10, 0x32, 0x54, 0x76, 848 0x98, 0xBA, 0xDC, 0xFE, 849 // packet sequence number 850 0xBC, 0x9A, 0x78, 0x56, 851 // private flags 852 0x00, 853 }; 854 855 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 856 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 857 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 858 ASSERT_TRUE(visitor_.header_.get()); 859 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 860 visitor_.header_->public_header.guid); 861 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 862 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 863 EXPECT_FALSE(visitor_.header_->fec_flag); 864 EXPECT_FALSE(visitor_.header_->entropy_flag); 865 EXPECT_EQ(0, visitor_.header_->entropy_hash); 866 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 867 visitor_.header_->packet_sequence_number); 868 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 869 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 870 871 // Now test framing boundaries 872 for (size_t i = 0; 873 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 874 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 875 ++i) { 876 string expected_error; 877 if (i < kGuidOffset) { 878 expected_error = "Unable to read public flags."; 879 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 880 expected_error = "Unable to read GUID."; 881 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 882 PACKET_4BYTE_SEQUENCE_NUMBER)) { 883 expected_error = "Unable to read sequence number."; 884 } else if (i < GetFecGroupOffset(!kIncludeVersion, 885 PACKET_4BYTE_SEQUENCE_NUMBER)) { 886 expected_error = "Unable to read private flags."; 887 } else { 888 expected_error = "Unable to read first fec protected packet offset."; 889 } 890 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 891 } 892 } 893 894 TEST_P(QuicFramerTest, PacketHeaderWith2ByteSequenceNumber) { 895 QuicFramerPeer::SetLastSequenceNumber(&framer_, 896 GG_UINT64_C(0x123456789ABA)); 897 898 unsigned char packet[] = { 899 // public flags (8 byte guid and 2 byte sequence number) 900 0x1C, 901 // guid 902 0x10, 0x32, 0x54, 0x76, 903 0x98, 0xBA, 0xDC, 0xFE, 904 // packet sequence number 905 0xBC, 0x9A, 906 // private flags 907 0x00, 908 }; 909 910 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 911 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 912 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 913 ASSERT_TRUE(visitor_.header_.get()); 914 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 915 visitor_.header_->public_header.guid); 916 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 917 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 918 EXPECT_FALSE(visitor_.header_->fec_flag); 919 EXPECT_FALSE(visitor_.header_->entropy_flag); 920 EXPECT_EQ(0, visitor_.header_->entropy_hash); 921 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 922 visitor_.header_->packet_sequence_number); 923 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 924 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 925 926 // Now test framing boundaries 927 for (size_t i = 0; 928 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 929 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 930 ++i) { 931 string expected_error; 932 if (i < kGuidOffset) { 933 expected_error = "Unable to read public flags."; 934 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 935 expected_error = "Unable to read GUID."; 936 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 937 PACKET_2BYTE_SEQUENCE_NUMBER)) { 938 expected_error = "Unable to read sequence number."; 939 } else if (i < GetFecGroupOffset(!kIncludeVersion, 940 PACKET_2BYTE_SEQUENCE_NUMBER)) { 941 expected_error = "Unable to read private flags."; 942 } else { 943 expected_error = "Unable to read first fec protected packet offset."; 944 } 945 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 946 } 947 } 948 949 TEST_P(QuicFramerTest, PacketHeaderWith1ByteSequenceNumber) { 950 QuicFramerPeer::SetLastSequenceNumber(&framer_, 951 GG_UINT64_C(0x123456789ABA)); 952 953 unsigned char packet[] = { 954 // public flags (8 byte guid and 1 byte sequence number) 955 0x0C, 956 // guid 957 0x10, 0x32, 0x54, 0x76, 958 0x98, 0xBA, 0xDC, 0xFE, 959 // packet sequence number 960 0xBC, 961 // private flags 962 0x00, 963 }; 964 965 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 966 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 967 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 968 ASSERT_TRUE(visitor_.header_.get()); 969 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 970 visitor_.header_->public_header.guid); 971 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 972 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 973 EXPECT_FALSE(visitor_.header_->fec_flag); 974 EXPECT_FALSE(visitor_.header_->entropy_flag); 975 EXPECT_EQ(0, visitor_.header_->entropy_hash); 976 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 977 visitor_.header_->packet_sequence_number); 978 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 979 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 980 981 // Now test framing boundaries 982 for (size_t i = 0; 983 i < GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 984 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 985 ++i) { 986 string expected_error; 987 if (i < kGuidOffset) { 988 expected_error = "Unable to read public flags."; 989 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 990 expected_error = "Unable to read GUID."; 991 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 992 PACKET_1BYTE_SEQUENCE_NUMBER)) { 993 expected_error = "Unable to read sequence number."; 994 } else if (i < GetFecGroupOffset(!kIncludeVersion, 995 PACKET_1BYTE_SEQUENCE_NUMBER)) { 996 expected_error = "Unable to read private flags."; 997 } else { 998 expected_error = "Unable to read first fec protected packet offset."; 999 } 1000 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 1001 } 1002 } 1003 1004 TEST_P(QuicFramerTest, InvalidPublicFlag) { 1005 unsigned char packet[] = { 1006 // public flags, unknown flag at bit 6 1007 0x40, 1008 // guid 1009 0x10, 0x32, 0x54, 0x76, 1010 0x98, 0xBA, 0xDC, 0xFE, 1011 // packet sequence number 1012 0xBC, 0x9A, 0x78, 0x56, 1013 0x34, 0x12, 1014 // private flags 1015 0x00, 1016 1017 // frame count 1018 0x01, 1019 // frame type (stream frame) 1020 0x01, 1021 // stream id 1022 0x04, 0x03, 0x02, 0x01, 1023 // fin 1024 0x01, 1025 // offset 1026 0x54, 0x76, 0x10, 0x32, 1027 0xDC, 0xFE, 0x98, 0xBA, 1028 // data length 1029 0x0c, 0x00, 1030 // data 1031 'h', 'e', 'l', 'l', 1032 'o', ' ', 'w', 'o', 1033 'r', 'l', 'd', '!', 1034 }; 1035 CheckProcessingFails(packet, 1036 arraysize(packet), 1037 "Illegal public flags value.", 1038 QUIC_INVALID_PACKET_HEADER); 1039 }; 1040 1041 TEST_P(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) { 1042 // Set a specific version. 1043 framer_.set_version(QUIC_VERSION_7); 1044 1045 unsigned char packet[] = { 1046 // public flags (8 byte guid and version flag and an unknown flag) 1047 0x4D, 1048 // guid 1049 0x10, 0x32, 0x54, 0x76, 1050 0x98, 0xBA, 0xDC, 0xFE, 1051 // version tag 1052 'Q', '0', '0', '7', 1053 // packet sequence number 1054 0xBC, 0x9A, 0x78, 0x56, 1055 0x34, 0x12, 1056 // private flags 1057 0x00, 1058 1059 // frame count 1060 0x01, 1061 // frame type (stream frame) 1062 0x01, 1063 // stream id 1064 0x04, 0x03, 0x02, 0x01, 1065 // fin 1066 0x01, 1067 // offset 1068 0x54, 0x76, 0x10, 0x32, 1069 0xDC, 0xFE, 0x98, 0xBA, 1070 // data length 1071 0x0c, 0x00, 1072 // data 1073 'h', 'e', 'l', 'l', 1074 'o', ' ', 'w', 'o', 1075 'r', 'l', 'd', '!', 1076 }; 1077 CheckProcessingFails(packet, 1078 arraysize(packet), 1079 "Illegal public flags value.", 1080 QUIC_INVALID_PACKET_HEADER); 1081 }; 1082 1083 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) { 1084 unsigned char packet[] = { 1085 // public flags (8 byte guid, version flag and an unknown flag) 1086 0x7D, 1087 // guid 1088 0x10, 0x32, 0x54, 0x76, 1089 0x98, 0xBA, 0xDC, 0xFE, 1090 // version tag 1091 'Q', '0', '0', '0', 1092 // packet sequence number 1093 0xBC, 0x9A, 0x78, 0x56, 1094 0x34, 0x12, 1095 // private flags 1096 0x00, 1097 1098 // frame type (padding frame) 1099 0x07, 1100 }; 1101 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1102 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1103 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1104 ASSERT_TRUE(visitor_.header_.get()); 1105 EXPECT_EQ(0, visitor_.frame_count_); 1106 EXPECT_EQ(1, visitor_.version_mismatch_); 1107 }; 1108 1109 TEST_P(QuicFramerTest, InvalidPrivateFlag) { 1110 unsigned char packet[] = { 1111 // public flags (8 byte guid) 1112 0x3C, 1113 // guid 1114 0x10, 0x32, 0x54, 0x76, 1115 0x98, 0xBA, 0xDC, 0xFE, 1116 // packet sequence number 1117 0xBC, 0x9A, 0x78, 0x56, 1118 0x34, 0x12, 1119 // private flags 1120 0x10, 1121 1122 // frame count 1123 0x01, 1124 // frame type (stream frame) 1125 0x01, 1126 // stream id 1127 0x04, 0x03, 0x02, 0x01, 1128 // fin 1129 0x01, 1130 // offset 1131 0x54, 0x76, 0x10, 0x32, 1132 0xDC, 0xFE, 0x98, 0xBA, 1133 // data length 1134 0x0c, 0x00, 1135 // data 1136 'h', 'e', 'l', 'l', 1137 'o', ' ', 'w', 'o', 1138 'r', 'l', 'd', '!', 1139 }; 1140 CheckProcessingFails(packet, 1141 arraysize(packet), 1142 "Illegal private flags value.", 1143 QUIC_INVALID_PACKET_HEADER); 1144 }; 1145 1146 TEST_P(QuicFramerTest, InvalidFECGroupOffset) { 1147 unsigned char packet[] = { 1148 // public flags (8 byte guid) 1149 0x3C, 1150 // guid 1151 0x10, 0x32, 0x54, 0x76, 1152 0x98, 0xBA, 0xDC, 0xFE, 1153 // packet sequence number 1154 0x01, 0x00, 0x00, 0x00, 1155 0x00, 0x00, 1156 // private flags (fec group) 1157 0x02, 1158 // first fec protected packet offset 1159 0x10 1160 }; 1161 CheckProcessingFails(packet, 1162 arraysize(packet), 1163 "First fec protected packet offset must be less " 1164 "than the sequence number.", 1165 QUIC_INVALID_PACKET_HEADER); 1166 }; 1167 1168 TEST_P(QuicFramerTest, PaddingFrame) { 1169 unsigned char packet[] = { 1170 // public flags (8 byte guid) 1171 0x3C, 1172 // guid 1173 0x10, 0x32, 0x54, 0x76, 1174 0x98, 0xBA, 0xDC, 0xFE, 1175 // packet sequence number 1176 0xBC, 0x9A, 0x78, 0x56, 1177 0x34, 0x12, 1178 // private flags 1179 0x00, 1180 1181 // frame type (padding frame) 1182 0x07, 1183 // Ignored data (which in this case is a stream frame) 1184 0x01, 1185 0x04, 0x03, 0x02, 0x01, 1186 0x01, 1187 0x54, 0x76, 0x10, 0x32, 1188 0xDC, 0xFE, 0x98, 0xBA, 1189 0x0c, 0x00, 1190 'h', 'e', 'l', 'l', 1191 'o', ' ', 'w', 'o', 1192 'r', 'l', 'd', '!', 1193 }; 1194 1195 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1196 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1197 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1198 ASSERT_TRUE(visitor_.header_.get()); 1199 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1200 1201 ASSERT_EQ(0u, visitor_.stream_frames_.size()); 1202 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1203 // A packet with no frames is not acceptable. 1204 CheckProcessingFails( 1205 packet, 1206 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1207 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1208 "Unable to read frame type.", QUIC_INVALID_FRAME_DATA); 1209 } 1210 1211 TEST_P(QuicFramerTest, StreamFrame) { 1212 unsigned char packet[] = { 1213 // public flags (8 byte guid) 1214 0x3C, 1215 // guid 1216 0x10, 0x32, 0x54, 0x76, 1217 0x98, 0xBA, 0xDC, 0xFE, 1218 // packet sequence number 1219 0xBC, 0x9A, 0x78, 0x56, 1220 0x34, 0x12, 1221 // private flags 1222 0x00, 1223 1224 // frame type (stream frame with fin) 1225 0xFE, 1226 // stream id 1227 0x04, 0x03, 0x02, 0x01, 1228 // offset 1229 0x54, 0x76, 0x10, 0x32, 1230 0xDC, 0xFE, 0x98, 0xBA, 1231 // data length 1232 0x0c, 0x00, 1233 // data 1234 'h', 'e', 'l', 'l', 1235 'o', ' ', 'w', 'o', 1236 'r', 'l', 'd', '!', 1237 }; 1238 1239 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1240 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1241 1242 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1243 ASSERT_TRUE(visitor_.header_.get()); 1244 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1245 1246 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1247 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1248 EXPECT_EQ(static_cast<uint64>(0x01020304), 1249 visitor_.stream_frames_[0]->stream_id); 1250 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1251 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1252 visitor_.stream_frames_[0]->offset); 1253 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1254 1255 // Now test framing boundaries 1256 for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) { 1257 string expected_error; 1258 if (i < kQuicFrameTypeSize) { 1259 expected_error = "Unable to read frame type."; 1260 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 1261 expected_error = "Unable to read stream_id."; 1262 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 1263 expected_error = "Unable to read fin."; 1264 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + 1265 kQuicMaxStreamOffsetSize) { 1266 expected_error = "Unable to read offset."; 1267 } else { 1268 expected_error = "Unable to read frame data."; 1269 } 1270 CheckProcessingFails( 1271 packet, 1272 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1273 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1274 expected_error, QUIC_INVALID_FRAME_DATA); 1275 } 1276 } 1277 1278 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) { 1279 unsigned char packet[] = { 1280 // public flags (8 byte guid) 1281 0x3C, 1282 // guid 1283 0x10, 0x32, 0x54, 0x76, 1284 0x98, 0xBA, 0xDC, 0xFE, 1285 // packet sequence number 1286 0xBC, 0x9A, 0x78, 0x56, 1287 0x34, 0x12, 1288 // private flags 1289 0x00, 1290 1291 // frame type (stream frame with fin) 1292 0xFC, 1293 // stream id 1294 0x04, 0x03, 0x02, 1295 // offset 1296 0x54, 0x76, 0x10, 0x32, 1297 0xDC, 0xFE, 0x98, 0xBA, 1298 // data length 1299 0x0c, 0x00, 1300 // data 1301 'h', 'e', 'l', 'l', 1302 'o', ' ', 'w', 'o', 1303 'r', 'l', 'd', '!', 1304 }; 1305 1306 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1307 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1308 1309 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1310 ASSERT_TRUE(visitor_.header_.get()); 1311 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1312 1313 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1314 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1315 EXPECT_EQ(static_cast<uint64>(0x00020304), 1316 visitor_.stream_frames_[0]->stream_id); 1317 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1318 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1319 visitor_.stream_frames_[0]->offset); 1320 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1321 1322 // Now test framing boundaries 1323 const size_t stream_id_size = 3; 1324 for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) { 1325 string expected_error; 1326 if (i < kQuicFrameTypeSize) { 1327 expected_error = "Unable to read frame type."; 1328 } else if (i < kQuicFrameTypeSize + stream_id_size) { 1329 expected_error = "Unable to read stream_id."; 1330 } else if (i < kQuicFrameTypeSize + stream_id_size - 1) { 1331 expected_error = "Unable to read fin."; 1332 } else if (i < kQuicFrameTypeSize + stream_id_size + 1333 kQuicMaxStreamOffsetSize) { 1334 expected_error = "Unable to read offset."; 1335 } else { 1336 expected_error = "Unable to read frame data."; 1337 } 1338 CheckProcessingFails( 1339 packet, 1340 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1341 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1342 expected_error, QUIC_INVALID_FRAME_DATA); 1343 } 1344 } 1345 1346 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) { 1347 unsigned char packet[] = { 1348 // public flags (8 byte guid) 1349 0x3C, 1350 // guid 1351 0x10, 0x32, 0x54, 0x76, 1352 0x98, 0xBA, 0xDC, 0xFE, 1353 // packet sequence number 1354 0xBC, 0x9A, 0x78, 0x56, 1355 0x34, 0x12, 1356 // private flags 1357 0x00, 1358 1359 // frame type (stream frame with fin) 1360 0xFA, 1361 // stream id 1362 0x04, 0x03, 1363 // offset 1364 0x54, 0x76, 0x10, 0x32, 1365 0xDC, 0xFE, 0x98, 0xBA, 1366 // data length 1367 0x0c, 0x00, 1368 // data 1369 'h', 'e', 'l', 'l', 1370 'o', ' ', 'w', 'o', 1371 'r', 'l', 'd', '!', 1372 }; 1373 1374 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1375 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1376 1377 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1378 ASSERT_TRUE(visitor_.header_.get()); 1379 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1380 1381 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1382 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1383 EXPECT_EQ(static_cast<uint64>(0x00000304), 1384 visitor_.stream_frames_[0]->stream_id); 1385 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1386 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1387 visitor_.stream_frames_[0]->offset); 1388 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1389 1390 // Now test framing boundaries 1391 const size_t stream_id_size = 2; 1392 for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) { 1393 string expected_error; 1394 if (i < kQuicFrameTypeSize) { 1395 expected_error = "Unable to read frame type."; 1396 } else if (i < kQuicFrameTypeSize + stream_id_size) { 1397 expected_error = "Unable to read stream_id."; 1398 } else if (i < kQuicFrameTypeSize + stream_id_size - 1) { 1399 expected_error = "Unable to read fin."; 1400 } else if (i < kQuicFrameTypeSize + stream_id_size + 1401 kQuicMaxStreamOffsetSize) { 1402 expected_error = "Unable to read offset."; 1403 } else { 1404 expected_error = "Unable to read frame data."; 1405 } 1406 CheckProcessingFails( 1407 packet, 1408 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1409 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1410 expected_error, QUIC_INVALID_FRAME_DATA); 1411 } 1412 } 1413 1414 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) { 1415 unsigned char packet[] = { 1416 // public flags (8 byte guid) 1417 0x3C, 1418 // guid 1419 0x10, 0x32, 0x54, 0x76, 1420 0x98, 0xBA, 0xDC, 0xFE, 1421 // packet sequence number 1422 0xBC, 0x9A, 0x78, 0x56, 1423 0x34, 0x12, 1424 // private flags 1425 0x00, 1426 1427 // frame type (stream frame with fin) 1428 0xF8, 1429 // stream id 1430 0x04, 1431 // offset 1432 0x54, 0x76, 0x10, 0x32, 1433 0xDC, 0xFE, 0x98, 0xBA, 1434 // data length 1435 0x0c, 0x00, 1436 // data 1437 'h', 'e', 'l', 'l', 1438 'o', ' ', 'w', 'o', 1439 'r', 'l', 'd', '!', 1440 }; 1441 1442 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1443 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1444 1445 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1446 ASSERT_TRUE(visitor_.header_.get()); 1447 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1448 1449 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1450 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1451 EXPECT_EQ(static_cast<uint64>(0x00000004), 1452 visitor_.stream_frames_[0]->stream_id); 1453 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1454 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1455 visitor_.stream_frames_[0]->offset); 1456 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1457 1458 // Now test framing boundaries 1459 const size_t stream_id_size = 1; 1460 for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) { 1461 string expected_error; 1462 if (i < kQuicFrameTypeSize) { 1463 expected_error = "Unable to read frame type."; 1464 } else if (i < kQuicFrameTypeSize + stream_id_size) { 1465 expected_error = "Unable to read stream_id."; 1466 } else if (i < kQuicFrameTypeSize + stream_id_size - 1) { 1467 expected_error = "Unable to read fin."; 1468 } else if (i < kQuicFrameTypeSize + stream_id_size + 1469 kQuicMaxStreamOffsetSize) { 1470 expected_error = "Unable to read offset."; 1471 } else { 1472 expected_error = "Unable to read frame data."; 1473 } 1474 CheckProcessingFails( 1475 packet, 1476 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1477 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1478 expected_error, QUIC_INVALID_FRAME_DATA); 1479 } 1480 } 1481 1482 TEST_P(QuicFramerTest, StreamFrameWithVersion) { 1483 // Set a specific version. 1484 framer_.set_version(QUIC_VERSION_7); 1485 1486 unsigned char packet[] = { 1487 // public flags (version, 8 byte guid) 1488 0x3D, 1489 // guid 1490 0x10, 0x32, 0x54, 0x76, 1491 0x98, 0xBA, 0xDC, 0xFE, 1492 // version tag 1493 'Q', '0', '0', '7', 1494 // packet sequence number 1495 0xBC, 0x9A, 0x78, 0x56, 1496 0x34, 0x12, 1497 // private flags 1498 0x00, 1499 1500 // frame type (stream frame with fin) 1501 0xFE, 1502 // stream id 1503 0x04, 0x03, 0x02, 0x01, 1504 // offset 1505 0x54, 0x76, 0x10, 0x32, 1506 0xDC, 0xFE, 0x98, 0xBA, 1507 // data length 1508 0x0c, 0x00, 1509 // data 1510 'h', 'e', 'l', 'l', 1511 'o', ' ', 'w', 'o', 1512 'r', 'l', 'd', '!', 1513 }; 1514 1515 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1516 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1517 1518 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1519 ASSERT_TRUE(visitor_.header_.get()); 1520 EXPECT_TRUE(visitor_.header_.get()->public_header.version_flag); 1521 EXPECT_EQ(QUIC_VERSION_7, visitor_.header_.get()->public_header.versions[0]); 1522 EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion)); 1523 1524 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1525 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1526 EXPECT_EQ(static_cast<uint64>(0x01020304), 1527 visitor_.stream_frames_[0]->stream_id); 1528 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1529 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1530 visitor_.stream_frames_[0]->offset); 1531 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1532 1533 // Now test framing boundaries 1534 for (size_t i = 0; i < GetMinStreamFrameSize(framer_.version()); ++i) { 1535 string expected_error; 1536 if (i < kQuicFrameTypeSize) { 1537 expected_error = "Unable to read frame type."; 1538 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 1539 expected_error = "Unable to read stream_id."; 1540 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + 1541 kQuicMaxStreamOffsetSize) { 1542 expected_error = "Unable to read offset."; 1543 } else { 1544 expected_error = "Unable to read frame data."; 1545 } 1546 CheckProcessingFails( 1547 packet, 1548 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, kIncludeVersion, 1549 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1550 expected_error, QUIC_INVALID_FRAME_DATA); 1551 } 1552 } 1553 1554 TEST_P(QuicFramerTest, RejectPacket) { 1555 visitor_.accept_packet_ = false; 1556 1557 unsigned char packet[] = { 1558 // public flags (8 byte guid) 1559 0x3C, 1560 // guid 1561 0x10, 0x32, 0x54, 0x76, 1562 0x98, 0xBA, 0xDC, 0xFE, 1563 // packet sequence number 1564 0xBC, 0x9A, 0x78, 0x56, 1565 0x34, 0x12, 1566 // private flags 1567 0x00, 1568 1569 // frame type (stream frame with fin) 1570 0xFE, 1571 // stream id 1572 0x04, 0x03, 0x02, 0x01, 1573 // offset 1574 0x54, 0x76, 0x10, 0x32, 1575 0xDC, 0xFE, 0x98, 0xBA, 1576 // data length 1577 0x0c, 0x00, 1578 // data 1579 'h', 'e', 'l', 'l', 1580 'o', ' ', 'w', 'o', 1581 'r', 'l', 'd', '!', 1582 }; 1583 1584 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1585 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1586 1587 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1588 ASSERT_TRUE(visitor_.header_.get()); 1589 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1590 1591 ASSERT_EQ(0u, visitor_.stream_frames_.size()); 1592 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1593 } 1594 1595 TEST_P(QuicFramerTest, RevivedStreamFrame) { 1596 unsigned char payload[] = { 1597 // frame type (stream frame with fin) 1598 0xFE, 1599 // stream id 1600 0x04, 0x03, 0x02, 0x01, 1601 // offset 1602 0x54, 0x76, 0x10, 0x32, 1603 0xDC, 0xFE, 0x98, 0xBA, 1604 // data length 1605 0x0c, 0x00, 1606 // data 1607 'h', 'e', 'l', 'l', 1608 'o', ' ', 'w', 'o', 1609 'r', 'l', 'd', '!', 1610 }; 1611 1612 QuicPacketHeader header; 1613 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1614 header.public_header.reset_flag = false; 1615 header.public_header.version_flag = false; 1616 header.fec_flag = true; 1617 header.entropy_flag = true; 1618 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1619 header.fec_group = 0; 1620 1621 // Do not encrypt the payload because the revived payload is post-encryption. 1622 EXPECT_TRUE(framer_.ProcessRevivedPacket(&header, 1623 StringPiece(AsChars(payload), 1624 arraysize(payload)))); 1625 1626 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1627 ASSERT_EQ(1, visitor_.revived_packets_); 1628 ASSERT_TRUE(visitor_.header_.get()); 1629 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 1630 visitor_.header_->public_header.guid); 1631 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 1632 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 1633 EXPECT_TRUE(visitor_.header_->fec_flag); 1634 EXPECT_TRUE(visitor_.header_->entropy_flag); 1635 EXPECT_EQ(1 << (header.packet_sequence_number % 8), 1636 visitor_.header_->entropy_hash); 1637 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 1638 visitor_.header_->packet_sequence_number); 1639 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1640 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 1641 1642 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1643 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1644 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 1645 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1646 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1647 visitor_.stream_frames_[0]->offset); 1648 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1649 } 1650 1651 TEST_P(QuicFramerTest, StreamFrameInFecGroup) { 1652 // Set a specific version. 1653 framer_.set_version(QUIC_VERSION_7); 1654 1655 unsigned char packet[] = { 1656 // public flags (8 byte guid) 1657 0x3C, 1658 // guid 1659 0x10, 0x32, 0x54, 0x76, 1660 0x98, 0xBA, 0xDC, 0xFE, 1661 // packet sequence number 1662 0xBC, 0x9A, 0x78, 0x56, 1663 0x12, 0x34, 1664 // private flags (fec group) 1665 0x02, 1666 // first fec protected packet offset 1667 0x02, 1668 1669 // frame type (stream frame with fin) 1670 0xFE, 1671 // stream id 1672 0x04, 0x03, 0x02, 0x01, 1673 // offset 1674 0x54, 0x76, 0x10, 0x32, 1675 0xDC, 0xFE, 0x98, 0xBA, 1676 // data length 1677 0x0c, 0x00, 1678 // data 1679 'h', 'e', 'l', 'l', 1680 'o', ' ', 'w', 'o', 1681 'r', 'l', 'd', '!', 1682 }; 1683 1684 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1685 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1686 1687 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1688 ASSERT_TRUE(visitor_.header_.get()); 1689 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1690 EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1691 EXPECT_EQ(GG_UINT64_C(0x341256789ABA), 1692 visitor_.header_->fec_group); 1693 const size_t fec_offset = GetStartOfFecProtectedData( 1694 PACKET_8BYTE_GUID, !kIncludeVersion, PACKET_6BYTE_SEQUENCE_NUMBER); 1695 EXPECT_EQ( 1696 string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset), 1697 visitor_.fec_protected_payload_); 1698 1699 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1700 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1701 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 1702 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1703 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1704 visitor_.stream_frames_[0]->offset); 1705 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 1706 } 1707 1708 TEST_P(QuicFramerTest, AckFrame) { 1709 unsigned char packet[] = { 1710 // public flags (8 byte guid) 1711 0x3C, 1712 // guid 1713 0x10, 0x32, 0x54, 0x76, 1714 0x98, 0xBA, 0xDC, 0xFE, 1715 // packet sequence number 1716 0xBC, 0x9A, 0x78, 0x56, 1717 0x34, 0x12, 1718 // private flags 1719 0x00, 1720 1721 // frame type (ack frame) 1722 static_cast<unsigned char>(0x01), 1723 // entropy hash of sent packets till least awaiting - 1. 1724 0xAB, 1725 // least packet sequence number awaiting an ack 1726 0xA0, 0x9A, 0x78, 0x56, 1727 0x34, 0x12, 1728 // entropy hash of all received packets. 1729 0xBA, 1730 // largest observed packet sequence number 1731 0xBF, 0x9A, 0x78, 0x56, 1732 0x34, 0x12, 1733 // Infinite delta time. 1734 0xFF, 0xFF, 0xFF, 0xFF, 1735 // num missing packets 1736 0x01, 1737 // missing packet 1738 0xBE, 0x9A, 0x78, 0x56, 1739 0x34, 0x12, 1740 }; 1741 1742 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1743 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1744 1745 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1746 ASSERT_TRUE(visitor_.header_.get()); 1747 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1748 1749 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1750 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 1751 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 1752 EXPECT_EQ(0xAB, frame.sent_info.entropy_hash); 1753 EXPECT_EQ(0xBA, frame.received_info.entropy_hash); 1754 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed); 1755 ASSERT_EQ(1u, frame.received_info.missing_packets.size()); 1756 SequenceNumberSet::const_iterator missing_iter = 1757 frame.received_info.missing_packets.begin(); 1758 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 1759 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 1760 1761 const size_t kSentEntropyOffset = kQuicFrameTypeSize; 1762 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize; 1763 const size_t kReceivedEntropyOffset = kLeastUnackedOffset + 1764 PACKET_6BYTE_SEQUENCE_NUMBER; 1765 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 1766 kQuicEntropyHashSize; 1767 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 1768 PACKET_6BYTE_SEQUENCE_NUMBER; 1769 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset + 1770 kQuicDeltaTimeLargestObservedSize; 1771 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 1772 kNumberOfMissingPacketsSize; 1773 // Now test framing boundaries 1774 const size_t missing_packets_size = 1 * PACKET_6BYTE_SEQUENCE_NUMBER; 1775 for (size_t i = 0; 1776 i < QuicFramer::GetMinAckFrameSize() + missing_packets_size; ++i) { 1777 string expected_error; 1778 if (i < kSentEntropyOffset) { 1779 expected_error = "Unable to read frame type."; 1780 } else if (i < kLeastUnackedOffset) { 1781 expected_error = "Unable to read entropy hash for sent packets."; 1782 } else if (i < kReceivedEntropyOffset) { 1783 expected_error = "Unable to read least unacked."; 1784 } else if (i < kLargestObservedOffset) { 1785 expected_error = "Unable to read entropy hash for received packets."; 1786 } else if (i < kMissingDeltaTimeOffset) { 1787 expected_error = "Unable to read largest observed."; 1788 } else if (i < kNumMissingPacketOffset) { 1789 expected_error = "Unable to read delta time largest observed."; 1790 } else if (i < kMissingPacketsOffset) { 1791 expected_error = "Unable to read num missing packets."; 1792 } else { 1793 expected_error = "Unable to read sequence number in missing packets."; 1794 } 1795 CheckProcessingFails( 1796 packet, 1797 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1798 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1799 expected_error, QUIC_INVALID_FRAME_DATA); 1800 } 1801 } 1802 1803 TEST_P(QuicFramerTest, CongestionFeedbackFrameTCP) { 1804 unsigned char packet[] = { 1805 // public flags (8 byte guid) 1806 0x3C, 1807 // guid 1808 0x10, 0x32, 0x54, 0x76, 1809 0x98, 0xBA, 0xDC, 0xFE, 1810 // packet sequence number 1811 0xBC, 0x9A, 0x78, 0x56, 1812 0x34, 0x12, 1813 // private flags 1814 0x00, 1815 1816 // frame type (congestion feedback frame) 1817 0x03, 1818 // congestion feedback type (tcp) 1819 0x00, 1820 // ack_frame.feedback.tcp.accumulated_number_of_lost_packets 1821 0x01, 0x02, 1822 // ack_frame.feedback.tcp.receive_window 1823 0x03, 0x04, 1824 }; 1825 1826 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1827 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1828 1829 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1830 ASSERT_TRUE(visitor_.header_.get()); 1831 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1832 1833 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1834 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size()); 1835 const QuicCongestionFeedbackFrame& frame = 1836 *visitor_.congestion_feedback_frames_[0]; 1837 ASSERT_EQ(kTCP, frame.type); 1838 EXPECT_EQ(0x0201, 1839 frame.tcp.accumulated_number_of_lost_packets); 1840 EXPECT_EQ(0x4030u, frame.tcp.receive_window); 1841 1842 // Now test framing boundaries 1843 for (size_t i = 0; i < 6; ++i) { 1844 string expected_error; 1845 if (i < 1) { 1846 expected_error = "Unable to read frame type."; 1847 } else if (i < 2) { 1848 expected_error = "Unable to read congestion feedback type."; 1849 } else if (i < 4) { 1850 expected_error = "Unable to read accumulated number of lost packets."; 1851 } else if (i < 6) { 1852 expected_error = "Unable to read receive window."; 1853 } 1854 CheckProcessingFails( 1855 packet, 1856 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1857 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1858 expected_error, QUIC_INVALID_FRAME_DATA); 1859 } 1860 } 1861 1862 TEST_P(QuicFramerTest, CongestionFeedbackFrameInterArrival) { 1863 unsigned char packet[] = { 1864 // public flags (8 byte guid) 1865 0x3C, 1866 // guid 1867 0x10, 0x32, 0x54, 0x76, 1868 0x98, 0xBA, 0xDC, 0xFE, 1869 // packet sequence number 1870 0xBC, 0x9A, 0x78, 0x56, 1871 0x34, 0x12, 1872 // private flags 1873 0x00, 1874 1875 // frame type (congestion feedback frame) 1876 0x03, 1877 // congestion feedback type (inter arrival) 1878 0x01, 1879 // accumulated_number_of_lost_packets 1880 0x02, 0x03, 1881 // num received packets 1882 0x03, 1883 // lowest sequence number 1884 0xBA, 0x9A, 0x78, 0x56, 1885 0x34, 0x12, 1886 // receive time 1887 0x87, 0x96, 0xA5, 0xB4, 1888 0xC3, 0xD2, 0xE1, 0x07, 1889 // sequence delta 1890 0x01, 0x00, 1891 // time delta 1892 0x01, 0x00, 0x00, 0x00, 1893 // sequence delta (skip one packet) 1894 0x03, 0x00, 1895 // time delta 1896 0x02, 0x00, 0x00, 0x00, 1897 }; 1898 1899 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1900 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1901 1902 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1903 ASSERT_TRUE(visitor_.header_.get()); 1904 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1905 1906 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1907 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size()); 1908 const QuicCongestionFeedbackFrame& frame = 1909 *visitor_.congestion_feedback_frames_[0]; 1910 ASSERT_EQ(kInterArrival, frame.type); 1911 EXPECT_EQ(0x0302, frame.inter_arrival. 1912 accumulated_number_of_lost_packets); 1913 ASSERT_EQ(3u, frame.inter_arrival.received_packet_times.size()); 1914 TimeMap::const_iterator iter = 1915 frame.inter_arrival.received_packet_times.begin(); 1916 EXPECT_EQ(GG_UINT64_C(0x0123456789ABA), iter->first); 1917 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59687), 1918 iter->second.Subtract(start_).ToMicroseconds()); 1919 ++iter; 1920 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), iter->first); 1921 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59688), 1922 iter->second.Subtract(start_).ToMicroseconds()); 1923 ++iter; 1924 EXPECT_EQ(GG_UINT64_C(0x0123456789ABD), iter->first); 1925 EXPECT_EQ(GG_INT64_C(0x07E1D2C3B4A59689), 1926 iter->second.Subtract(start_).ToMicroseconds()); 1927 1928 // Now test framing boundaries 1929 for (size_t i = 0; i < 31; ++i) { 1930 string expected_error; 1931 if (i < 1) { 1932 expected_error = "Unable to read frame type."; 1933 } else if (i < 2) { 1934 expected_error = "Unable to read congestion feedback type."; 1935 } else if (i < 4) { 1936 expected_error = "Unable to read accumulated number of lost packets."; 1937 } else if (i < 5) { 1938 expected_error = "Unable to read num received packets."; 1939 } else if (i < 11) { 1940 expected_error = "Unable to read smallest received."; 1941 } else if (i < 19) { 1942 expected_error = "Unable to read time received."; 1943 } else if (i < 21) { 1944 expected_error = "Unable to read sequence delta in received packets."; 1945 } else if (i < 25) { 1946 expected_error = "Unable to read time delta in received packets."; 1947 } else if (i < 27) { 1948 expected_error = "Unable to read sequence delta in received packets."; 1949 } else if (i < 31) { 1950 expected_error = "Unable to read time delta in received packets."; 1951 } 1952 CheckProcessingFails( 1953 packet, 1954 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 1955 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1956 expected_error, QUIC_INVALID_FRAME_DATA); 1957 } 1958 } 1959 1960 TEST_P(QuicFramerTest, CongestionFeedbackFrameFixRate) { 1961 unsigned char packet[] = { 1962 // public flags (8 byte guid) 1963 0x3C, 1964 // guid 1965 0x10, 0x32, 0x54, 0x76, 1966 0x98, 0xBA, 0xDC, 0xFE, 1967 // packet sequence number 1968 0xBC, 0x9A, 0x78, 0x56, 1969 0x34, 0x12, 1970 // private flags 1971 0x00, 1972 1973 // frame type (congestion feedback frame) 1974 0x03, 1975 // congestion feedback type (fix rate) 1976 0x02, 1977 // bitrate_in_bytes_per_second; 1978 0x01, 0x02, 0x03, 0x04, 1979 }; 1980 1981 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1982 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1983 1984 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1985 ASSERT_TRUE(visitor_.header_.get()); 1986 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1987 1988 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1989 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size()); 1990 const QuicCongestionFeedbackFrame& frame = 1991 *visitor_.congestion_feedback_frames_[0]; 1992 ASSERT_EQ(kFixRate, frame.type); 1993 EXPECT_EQ(static_cast<uint32>(0x04030201), 1994 frame.fix_rate.bitrate.ToBytesPerSecond()); 1995 1996 // Now test framing boundaries 1997 for (size_t i = 0; i < 6; ++i) { 1998 string expected_error; 1999 if (i < 1) { 2000 expected_error = "Unable to read frame type."; 2001 } else if (i < 2) { 2002 expected_error = "Unable to read congestion feedback type."; 2003 } else if (i < 6) { 2004 expected_error = "Unable to read bitrate."; 2005 } 2006 CheckProcessingFails( 2007 packet, 2008 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2009 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2010 expected_error, QUIC_INVALID_FRAME_DATA); 2011 } 2012 } 2013 2014 2015 TEST_P(QuicFramerTest, CongestionFeedbackFrameInvalidFeedback) { 2016 unsigned char packet[] = { 2017 // public flags (8 byte guid) 2018 0x3C, 2019 // guid 2020 0x10, 0x32, 0x54, 0x76, 2021 0x98, 0xBA, 0xDC, 0xFE, 2022 // packet sequence number 2023 0xBC, 0x9A, 0x78, 0x56, 2024 0x34, 0x12, 2025 // private flags 2026 0x00, 2027 2028 // frame type (congestion feedback frame) 2029 0x03, 2030 // congestion feedback type (invalid) 2031 0x03, 2032 }; 2033 2034 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2035 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 2036 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2037 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 2038 } 2039 2040 TEST_P(QuicFramerTest, RstStreamFrame) { 2041 unsigned char packet[] = { 2042 // public flags (8 byte guid) 2043 0x3C, 2044 // guid 2045 0x10, 0x32, 0x54, 0x76, 2046 0x98, 0xBA, 0xDC, 0xFE, 2047 // packet sequence number 2048 0xBC, 0x9A, 0x78, 0x56, 2049 0x34, 0x12, 2050 // private flags 2051 0x00, 2052 2053 // frame type (rst stream frame) 2054 static_cast<unsigned char>(0x27), 2055 // stream id 2056 0x04, 0x03, 0x02, 0x01, 2057 // error code 2058 0x01, 0x00, 0x00, 0x00, 2059 2060 // error details length 2061 0x0d, 0x00, 2062 // error details 2063 'b', 'e', 'c', 'a', 2064 'u', 's', 'e', ' ', 2065 'I', ' ', 'c', 'a', 2066 'n', 2067 }; 2068 2069 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2070 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2071 2072 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2073 ASSERT_TRUE(visitor_.header_.get()); 2074 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2075 2076 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id); 2077 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code); 2078 EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details); 2079 2080 // Now test framing boundaries 2081 for (size_t i = 2; i < 24; ++i) { 2082 string expected_error; 2083 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 2084 expected_error = "Unable to read stream_id."; 2085 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + 2086 kQuicErrorCodeSize) { 2087 expected_error = "Unable to read rst stream error code."; 2088 } else { 2089 expected_error = "Unable to read rst stream error details."; 2090 } 2091 CheckProcessingFails( 2092 packet, 2093 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2094 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2095 expected_error, QUIC_INVALID_RST_STREAM_DATA); 2096 } 2097 } 2098 2099 TEST_P(QuicFramerTest, ConnectionCloseFrame) { 2100 unsigned char packet[] = { 2101 // public flags (8 byte guid) 2102 0x3C, 2103 // guid 2104 0x10, 0x32, 0x54, 0x76, 2105 0x98, 0xBA, 0xDC, 0xFE, 2106 // packet sequence number 2107 0xBC, 0x9A, 0x78, 0x56, 2108 0x34, 0x12, 2109 // private flags 2110 0x00, 2111 2112 // frame type (connection close frame) 2113 static_cast<unsigned char>(0x2F), 2114 // error code 2115 0x11, 0x00, 0x00, 0x00, 2116 2117 // error details length 2118 0x0d, 0x00, 2119 // error details 2120 'b', 'e', 'c', 'a', 2121 'u', 's', 'e', ' ', 2122 'I', ' ', 'c', 'a', 2123 'n', 2124 2125 // Ack frame. 2126 // entropy hash of sent packets till least awaiting - 1. 2127 0xBF, 2128 // least packet sequence number awaiting an ack 2129 0xA0, 0x9A, 0x78, 0x56, 2130 0x34, 0x12, 2131 // entropy hash of all received packets. 2132 0xEB, 2133 // largest observed packet sequence number 2134 0xBF, 0x9A, 0x78, 0x56, 2135 0x34, 0x12, 2136 // Infinite delta time. 2137 0xFF, 0xFF, 0xFF, 0xFF, 2138 // num missing packets 2139 0x01, 2140 // missing packet 2141 0xBE, 0x9A, 0x78, 0x56, 2142 0x34, 0x12, 2143 }; 2144 2145 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2146 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2147 2148 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2149 ASSERT_TRUE(visitor_.header_.get()); 2150 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2151 2152 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2153 2154 EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code); 2155 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details); 2156 2157 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2158 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 2159 EXPECT_EQ(0xBF, frame.sent_info.entropy_hash); 2160 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 2161 EXPECT_EQ(0xEB, frame.received_info.entropy_hash); 2162 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.received_info.largest_observed); 2163 ASSERT_EQ(1u, frame.received_info.missing_packets.size()); 2164 SequenceNumberSet::const_iterator missing_iter = 2165 frame.received_info.missing_packets.begin(); 2166 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 2167 2168 // Now test framing boundaries 2169 for (size_t i = kQuicFrameTypeSize; 2170 i < QuicFramer::GetMinConnectionCloseFrameSize() - 2171 QuicFramer::GetMinAckFrameSize(); ++i) { 2172 string expected_error; 2173 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { 2174 expected_error = "Unable to read connection close error code."; 2175 } else { 2176 expected_error = "Unable to read connection close error details."; 2177 } 2178 CheckProcessingFails( 2179 packet, 2180 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2181 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2182 expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA); 2183 } 2184 } 2185 2186 TEST_P(QuicFramerTest, GoAwayFrame) { 2187 unsigned char packet[] = { 2188 // public flags (8 byte guid) 2189 0x3C, 2190 // guid 2191 0x10, 0x32, 0x54, 0x76, 2192 0x98, 0xBA, 0xDC, 0xFE, 2193 // packet sequence number 2194 0xBC, 0x9A, 0x78, 0x56, 2195 0x34, 0x12, 2196 // private flags 2197 0x00, 2198 2199 // frame type (go away frame) 2200 static_cast<unsigned char>(0x37), 2201 // error code 2202 0x09, 0x00, 0x00, 0x00, 2203 // stream id 2204 0x04, 0x03, 0x02, 0x01, 2205 // error details length 2206 0x0d, 0x00, 2207 // error details 2208 'b', 'e', 'c', 'a', 2209 'u', 's', 'e', ' ', 2210 'I', ' ', 'c', 'a', 2211 'n', 2212 }; 2213 2214 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2215 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2216 2217 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2218 ASSERT_TRUE(visitor_.header_.get()); 2219 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2220 2221 EXPECT_EQ(GG_UINT64_C(0x01020304), 2222 visitor_.goaway_frame_.last_good_stream_id); 2223 EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code); 2224 EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase); 2225 2226 const size_t reason_size = arraysize("because I can") - 1; 2227 // Now test framing boundaries 2228 for (size_t i = kQuicFrameTypeSize; 2229 i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) { 2230 string expected_error; 2231 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { 2232 expected_error = "Unable to read go away error code."; 2233 } else if (i < kQuicFrameTypeSize + kQuicErrorCodeSize + 2234 kQuicMaxStreamIdSize) { 2235 expected_error = "Unable to read last good stream id."; 2236 } else { 2237 expected_error = "Unable to read goaway reason."; 2238 } 2239 CheckProcessingFails( 2240 packet, 2241 i + GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2242 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2243 expected_error, QUIC_INVALID_GOAWAY_DATA); 2244 } 2245 } 2246 2247 TEST_P(QuicFramerTest, PublicResetPacket) { 2248 unsigned char packet[] = { 2249 // public flags (public reset, 8 byte guid) 2250 0x3E, 2251 // guid 2252 0x10, 0x32, 0x54, 0x76, 2253 0x98, 0xBA, 0xDC, 0xFE, 2254 // nonce proof 2255 0x89, 0x67, 0x45, 0x23, 2256 0x01, 0xEF, 0xCD, 0xAB, 2257 // rejected sequence number 2258 0xBC, 0x9A, 0x78, 0x56, 2259 0x34, 0x12, 2260 }; 2261 2262 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2263 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2264 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); 2265 ASSERT_TRUE(visitor_.public_reset_packet_.get()); 2266 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 2267 visitor_.public_reset_packet_->public_header.guid); 2268 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); 2269 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); 2270 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789), 2271 visitor_.public_reset_packet_->nonce_proof); 2272 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 2273 visitor_.public_reset_packet_->rejected_sequence_number); 2274 2275 // Now test framing boundaries 2276 for (size_t i = 0; i < GetPublicResetPacketSize(); ++i) { 2277 string expected_error; 2278 DLOG(INFO) << "iteration: " << i; 2279 if (i < kGuidOffset) { 2280 expected_error = "Unable to read public flags."; 2281 CheckProcessingFails(packet, i, expected_error, 2282 QUIC_INVALID_PACKET_HEADER); 2283 } else if (i < kPublicResetPacketNonceProofOffset) { 2284 expected_error = "Unable to read GUID."; 2285 CheckProcessingFails(packet, i, expected_error, 2286 QUIC_INVALID_PACKET_HEADER); 2287 } else if (i < kPublicResetPacketRejectedSequenceNumberOffset) { 2288 expected_error = "Unable to read nonce proof."; 2289 CheckProcessingFails(packet, i, expected_error, 2290 QUIC_INVALID_PUBLIC_RST_PACKET); 2291 } else { 2292 expected_error = "Unable to read rejected sequence number."; 2293 CheckProcessingFails(packet, i, expected_error, 2294 QUIC_INVALID_PUBLIC_RST_PACKET); 2295 } 2296 } 2297 } 2298 2299 TEST_P(QuicFramerTest, VersionNegotiationPacket) { 2300 // Set a specific version. 2301 framer_.set_version(QUIC_VERSION_7); 2302 2303 unsigned char packet[] = { 2304 // public flags (version, 8 byte guid) 2305 0x3D, 2306 // guid 2307 0x10, 0x32, 0x54, 0x76, 2308 0x98, 0xBA, 0xDC, 0xFE, 2309 // version tag 2310 'Q', '0', '0', '7', 2311 'Q', '2', '.', '0', 2312 }; 2313 2314 QuicFramerPeer::SetIsServer(&framer_, false); 2315 2316 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2317 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2318 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); 2319 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); 2320 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); 2321 EXPECT_EQ(QUIC_VERSION_7, 2322 visitor_.version_negotiation_packet_->versions[0]); 2323 2324 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_GUID; ++i) { 2325 string expected_error; 2326 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; 2327 if (i < kGuidOffset) { 2328 expected_error = "Unable to read public flags."; 2329 } else if (i < kVersionOffset) { 2330 expected_error = "Unable to read GUID."; 2331 } else { 2332 expected_error = "Unable to read supported version in negotiation."; 2333 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; 2334 } 2335 CheckProcessingFails(packet, i, expected_error, error_code); 2336 } 2337 } 2338 2339 TEST_P(QuicFramerTest, FecPacket) { 2340 unsigned char packet[] = { 2341 // public flags (8 byte guid) 2342 0x3C, 2343 // guid 2344 0x10, 0x32, 0x54, 0x76, 2345 0x98, 0xBA, 0xDC, 0xFE, 2346 // packet sequence number 2347 0xBC, 0x9A, 0x78, 0x56, 2348 0x34, 0x12, 2349 // private flags (fec group & FEC) 2350 0x06, 2351 // first fec protected packet offset 2352 0x01, 2353 2354 // redundancy 2355 'a', 'b', 'c', 'd', 2356 'e', 'f', 'g', 'h', 2357 'i', 'j', 'k', 'l', 2358 'm', 'n', 'o', 'p', 2359 }; 2360 2361 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2362 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2363 2364 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2365 ASSERT_TRUE(visitor_.header_.get()); 2366 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2367 2368 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2369 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 2370 ASSERT_EQ(1, visitor_.fec_count_); 2371 const QuicFecData& fec_data = *visitor_.fec_data_[0]; 2372 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), fec_data.fec_group); 2373 EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy); 2374 } 2375 2376 TEST_P(QuicFramerTest, BuildPaddingFramePacket) { 2377 QuicPacketHeader header; 2378 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2379 header.public_header.reset_flag = false; 2380 header.public_header.version_flag = false; 2381 header.fec_flag = false; 2382 header.entropy_flag = false; 2383 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2384 header.fec_group = 0; 2385 2386 QuicPaddingFrame padding_frame; 2387 2388 QuicFrames frames; 2389 frames.push_back(QuicFrame(&padding_frame)); 2390 2391 unsigned char packet[kMaxPacketSize] = { 2392 // public flags (8 byte guid) 2393 0x3C, 2394 // guid 2395 0x10, 0x32, 0x54, 0x76, 2396 0x98, 0xBA, 0xDC, 0xFE, 2397 // packet sequence number 2398 0xBC, 0x9A, 0x78, 0x56, 2399 0x34, 0x12, 2400 // private flags 2401 0x00, 2402 2403 // frame type (padding frame) 2404 static_cast<unsigned char>(0x07), 2405 }; 2406 2407 uint64 header_size = 2408 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2409 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 2410 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 2411 2412 scoped_ptr<QuicPacket> data( 2413 framer_.BuildUnsizedDataPacket(header, frames).packet); 2414 ASSERT_TRUE(data != NULL); 2415 2416 test::CompareCharArraysWithHexError("constructed packet", 2417 data->data(), data->length(), 2418 AsChars(packet), arraysize(packet)); 2419 } 2420 2421 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { 2422 QuicPacketHeader header; 2423 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2424 header.public_header.reset_flag = false; 2425 header.public_header.version_flag = false; 2426 header.fec_flag = false; 2427 header.entropy_flag = false; 2428 header.public_header.sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER; 2429 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2430 header.fec_group = 0; 2431 2432 QuicPaddingFrame padding_frame; 2433 2434 QuicFrames frames; 2435 frames.push_back(QuicFrame(&padding_frame)); 2436 2437 unsigned char packet[kMaxPacketSize] = { 2438 // public flags (8 byte guid and 4 byte sequence number) 2439 0x2C, 2440 // guid 2441 0x10, 0x32, 0x54, 0x76, 2442 0x98, 0xBA, 0xDC, 0xFE, 2443 // packet sequence number 2444 0xBC, 0x9A, 0x78, 0x56, 2445 // private flags 2446 0x00, 2447 2448 // frame type (padding frame) 2449 static_cast<unsigned char>(0x07), 2450 }; 2451 2452 uint64 header_size = 2453 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2454 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 2455 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 2456 2457 scoped_ptr<QuicPacket> data( 2458 framer_.BuildUnsizedDataPacket(header, frames).packet); 2459 ASSERT_TRUE(data != NULL); 2460 2461 test::CompareCharArraysWithHexError("constructed packet", 2462 data->data(), data->length(), 2463 AsChars(packet), arraysize(packet)); 2464 } 2465 2466 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) { 2467 QuicPacketHeader header; 2468 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2469 header.public_header.reset_flag = false; 2470 header.public_header.version_flag = false; 2471 header.fec_flag = false; 2472 header.entropy_flag = false; 2473 header.public_header.sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER; 2474 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2475 header.fec_group = 0; 2476 2477 QuicPaddingFrame padding_frame; 2478 2479 QuicFrames frames; 2480 frames.push_back(QuicFrame(&padding_frame)); 2481 2482 unsigned char packet[kMaxPacketSize] = { 2483 // public flags (8 byte guid and 2 byte sequence number) 2484 0x1C, 2485 // guid 2486 0x10, 0x32, 0x54, 0x76, 2487 0x98, 0xBA, 0xDC, 0xFE, 2488 // packet sequence number 2489 0xBC, 0x9A, 2490 // private flags 2491 0x00, 2492 2493 // frame type (padding frame) 2494 static_cast<unsigned char>(0x07), 2495 }; 2496 2497 uint64 header_size = 2498 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2499 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 2500 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 2501 2502 scoped_ptr<QuicPacket> data( 2503 framer_.BuildUnsizedDataPacket(header, frames).packet); 2504 ASSERT_TRUE(data != NULL); 2505 2506 test::CompareCharArraysWithHexError("constructed packet", 2507 data->data(), data->length(), 2508 AsChars(packet), arraysize(packet)); 2509 } 2510 2511 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) { 2512 QuicPacketHeader header; 2513 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2514 header.public_header.reset_flag = false; 2515 header.public_header.version_flag = false; 2516 header.fec_flag = false; 2517 header.entropy_flag = false; 2518 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 2519 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2520 header.fec_group = 0; 2521 2522 QuicPaddingFrame padding_frame; 2523 2524 QuicFrames frames; 2525 frames.push_back(QuicFrame(&padding_frame)); 2526 2527 unsigned char packet[kMaxPacketSize] = { 2528 // public flags (8 byte guid and 1 byte sequence number) 2529 0x0C, 2530 // guid 2531 0x10, 0x32, 0x54, 0x76, 2532 0x98, 0xBA, 0xDC, 0xFE, 2533 // packet sequence number 2534 0xBC, 2535 // private flags 2536 0x00, 2537 2538 // frame type (padding frame) 2539 static_cast<unsigned char>(0x07), 2540 }; 2541 2542 uint64 header_size = 2543 GetPacketHeaderSize(PACKET_8BYTE_GUID, !kIncludeVersion, 2544 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 2545 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 2546 2547 scoped_ptr<QuicPacket> data( 2548 framer_.BuildUnsizedDataPacket(header, frames).packet); 2549 ASSERT_TRUE(data != NULL); 2550 2551 test::CompareCharArraysWithHexError("constructed packet", 2552 data->data(), data->length(), 2553 AsChars(packet), arraysize(packet)); 2554 } 2555 2556 TEST_P(QuicFramerTest, BuildStreamFramePacket) { 2557 // Set a specific version. 2558 framer_.set_version(QUIC_VERSION_7); 2559 2560 QuicPacketHeader header; 2561 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2562 header.public_header.reset_flag = false; 2563 header.public_header.version_flag = false; 2564 header.fec_flag = false; 2565 header.entropy_flag = true; 2566 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC); 2567 header.fec_group = 0; 2568 2569 QuicStreamFrame stream_frame; 2570 stream_frame.stream_id = 0x01020304; 2571 stream_frame.fin = true; 2572 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 2573 stream_frame.data = "hello world!"; 2574 2575 QuicFrames frames; 2576 frames.push_back(QuicFrame(&stream_frame)); 2577 2578 unsigned char packet[] = { 2579 // public flags (8 byte guid) 2580 0x3C, 2581 // guid 2582 0x10, 0x32, 0x54, 0x76, 2583 0x98, 0xBA, 0xDC, 0xFE, 2584 // packet sequence number 2585 0xBC, 0x9A, 0x78, 0x56, 2586 0x34, 0x12, 2587 // private flags (entropy) 2588 0x01, 2589 2590 // frame type (stream frame with fin and no length) 2591 0xBE, 2592 // stream id 2593 0x04, 0x03, 0x02, 0x01, 2594 // offset 2595 0x54, 0x76, 0x10, 0x32, 2596 0xDC, 0xFE, 0x98, 0xBA, 2597 // data 2598 'h', 'e', 'l', 'l', 2599 'o', ' ', 'w', 'o', 2600 'r', 'l', 'd', '!', 2601 }; 2602 2603 scoped_ptr<QuicPacket> data( 2604 framer_.BuildUnsizedDataPacket(header, frames).packet); 2605 ASSERT_TRUE(data != NULL); 2606 2607 test::CompareCharArraysWithHexError("constructed packet", 2608 data->data(), data->length(), 2609 AsChars(packet), arraysize(packet)); 2610 } 2611 2612 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { 2613 QuicPacketHeader header; 2614 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2615 header.public_header.reset_flag = false; 2616 header.public_header.version_flag = true; 2617 header.fec_flag = false; 2618 header.entropy_flag = true; 2619 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC); 2620 header.fec_group = 0; 2621 2622 QuicStreamFrame stream_frame; 2623 stream_frame.stream_id = 0x01020304; 2624 stream_frame.fin = true; 2625 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 2626 stream_frame.data = "hello world!"; 2627 2628 QuicFrames frames; 2629 frames.push_back(QuicFrame(&stream_frame)); 2630 2631 // Set a specific version. 2632 framer_.set_version(QUIC_VERSION_7); 2633 unsigned char packet[] = { 2634 // public flags (version, 8 byte guid) 2635 0x3D, 2636 // guid 2637 0x10, 0x32, 0x54, 0x76, 2638 0x98, 0xBA, 0xDC, 0xFE, 2639 // version tag 2640 'Q', '0', '0', '7', 2641 // packet sequence number 2642 0xBC, 0x9A, 0x78, 0x56, 2643 0x34, 0x12, 2644 // private flags (entropy) 2645 0x01, 2646 2647 // frame type (stream frame with fin and no length) 2648 0xBE, 2649 // stream id 2650 0x04, 0x03, 0x02, 0x01, 2651 // offset 2652 0x54, 0x76, 0x10, 0x32, 2653 0xDC, 0xFE, 0x98, 0xBA, 2654 // data 2655 'h', 'e', 'l', 'l', 2656 'o', ' ', 'w', 'o', 2657 'r', 'l', 'd', '!', 2658 }; 2659 2660 QuicFramerPeer::SetIsServer(&framer_, false); 2661 scoped_ptr<QuicPacket> data( 2662 framer_.BuildUnsizedDataPacket(header, frames).packet); 2663 ASSERT_TRUE(data != NULL); 2664 2665 test::CompareCharArraysWithHexError("constructed packet", 2666 data->data(), data->length(), 2667 AsChars(packet), arraysize(packet)); 2668 } 2669 2670 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) { 2671 QuicPacketPublicHeader header; 2672 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2673 header.reset_flag = false; 2674 header.version_flag = true; 2675 2676 unsigned char packet[] = { 2677 // public flags (version, 8 byte guid) 2678 0x3D, 2679 // guid 2680 0x10, 0x32, 0x54, 0x76, 2681 0x98, 0xBA, 0xDC, 0xFE, 2682 // version tag 2683 'Q', '0', '0', '7', 2684 }; 2685 2686 QuicVersionVector versions; 2687 versions.push_back(QUIC_VERSION_7); 2688 scoped_ptr<QuicEncryptedPacket> data( 2689 framer_.BuildVersionNegotiationPacket(header, versions)); 2690 2691 test::CompareCharArraysWithHexError("constructed packet", 2692 data->data(), data->length(), 2693 AsChars(packet), arraysize(packet)); 2694 } 2695 2696 TEST_P(QuicFramerTest, BuildAckFramePacket) { 2697 QuicPacketHeader header; 2698 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2699 header.public_header.reset_flag = false; 2700 header.public_header.version_flag = false; 2701 header.fec_flag = false; 2702 header.entropy_flag = true; 2703 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2704 header.fec_group = 0; 2705 2706 QuicAckFrame ack_frame; 2707 ack_frame.received_info.entropy_hash = 0x43; 2708 ack_frame.received_info.largest_observed = GG_UINT64_C(0x770123456789ABF); 2709 ack_frame.received_info.delta_time_largest_observed = QuicTime::Delta::Zero(); 2710 ack_frame.received_info.missing_packets.insert( 2711 GG_UINT64_C(0x770123456789ABE)); 2712 ack_frame.sent_info.entropy_hash = 0x14; 2713 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x770123456789AA0); 2714 2715 QuicFrames frames; 2716 frames.push_back(QuicFrame(&ack_frame)); 2717 2718 unsigned char packet[] = { 2719 // public flags (8 byte guid) 2720 0x3C, 2721 // guid 2722 0x10, 0x32, 0x54, 0x76, 2723 0x98, 0xBA, 0xDC, 0xFE, 2724 // packet sequence number 2725 0xBC, 0x9A, 0x78, 0x56, 2726 0x34, 0x12, 2727 // private flags (entropy) 2728 0x01, 2729 2730 // frame type (ack frame) 2731 static_cast<unsigned char>(0x01), 2732 // entropy hash of sent packets till least awaiting - 1. 2733 0x14, 2734 // least packet sequence number awaiting an ack 2735 0xA0, 0x9A, 0x78, 0x56, 2736 0x34, 0x12, 2737 // entropy hash of all received packets. 2738 0x43, 2739 // largest observed packet sequence number 2740 0xBF, 0x9A, 0x78, 0x56, 2741 0x34, 0x12, 2742 // Zero delta time. 2743 0x0, 0x0, 0x0, 0x0, 2744 // num missing packets 2745 0x01, 2746 // missing packet 2747 0xBE, 0x9A, 0x78, 0x56, 2748 0x34, 0x12, 2749 }; 2750 2751 scoped_ptr<QuicPacket> data( 2752 framer_.BuildUnsizedDataPacket(header, frames).packet); 2753 ASSERT_TRUE(data != NULL); 2754 2755 test::CompareCharArraysWithHexError("constructed packet", 2756 data->data(), data->length(), 2757 AsChars(packet), arraysize(packet)); 2758 } 2759 2760 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketTCP) { 2761 QuicPacketHeader header; 2762 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2763 header.public_header.reset_flag = false; 2764 header.public_header.version_flag = false; 2765 header.fec_flag = false; 2766 header.entropy_flag = false; 2767 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2768 header.fec_group = 0; 2769 2770 QuicCongestionFeedbackFrame congestion_feedback_frame; 2771 congestion_feedback_frame.type = kTCP; 2772 congestion_feedback_frame.tcp.accumulated_number_of_lost_packets = 0x0201; 2773 congestion_feedback_frame.tcp.receive_window = 0x4030; 2774 2775 QuicFrames frames; 2776 frames.push_back(QuicFrame(&congestion_feedback_frame)); 2777 2778 unsigned char packet[] = { 2779 // public flags (8 byte guid) 2780 0x3C, 2781 // guid 2782 0x10, 0x32, 0x54, 0x76, 2783 0x98, 0xBA, 0xDC, 0xFE, 2784 // packet sequence number 2785 0xBC, 0x9A, 0x78, 0x56, 2786 0x34, 0x12, 2787 // private flags 2788 0x00, 2789 2790 // frame type (congestion feedback frame) 2791 0x03, 2792 // congestion feedback type (TCP) 2793 0x00, 2794 // accumulated number of lost packets 2795 0x01, 0x02, 2796 // TCP receive window 2797 0x03, 0x04, 2798 }; 2799 2800 scoped_ptr<QuicPacket> data( 2801 framer_.BuildUnsizedDataPacket(header, frames).packet); 2802 ASSERT_TRUE(data != NULL); 2803 2804 test::CompareCharArraysWithHexError("constructed packet", 2805 data->data(), data->length(), 2806 AsChars(packet), arraysize(packet)); 2807 } 2808 2809 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInterArrival) { 2810 QuicPacketHeader header; 2811 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2812 header.public_header.reset_flag = false; 2813 header.public_header.version_flag = false; 2814 header.fec_flag = false; 2815 header.entropy_flag = false; 2816 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2817 header.fec_group = 0; 2818 2819 QuicCongestionFeedbackFrame frame; 2820 frame.type = kInterArrival; 2821 frame.inter_arrival.accumulated_number_of_lost_packets = 0x0302; 2822 frame.inter_arrival.received_packet_times.insert( 2823 make_pair(GG_UINT64_C(0x0123456789ABA), 2824 start_.Add(QuicTime::Delta::FromMicroseconds( 2825 GG_UINT64_C(0x07E1D2C3B4A59687))))); 2826 frame.inter_arrival.received_packet_times.insert( 2827 make_pair(GG_UINT64_C(0x0123456789ABB), 2828 start_.Add(QuicTime::Delta::FromMicroseconds( 2829 GG_UINT64_C(0x07E1D2C3B4A59688))))); 2830 frame.inter_arrival.received_packet_times.insert( 2831 make_pair(GG_UINT64_C(0x0123456789ABD), 2832 start_.Add(QuicTime::Delta::FromMicroseconds( 2833 GG_UINT64_C(0x07E1D2C3B4A59689))))); 2834 QuicFrames frames; 2835 frames.push_back(QuicFrame(&frame)); 2836 2837 unsigned char packet[] = { 2838 // public flags (8 byte guid) 2839 0x3C, 2840 // guid 2841 0x10, 0x32, 0x54, 0x76, 2842 0x98, 0xBA, 0xDC, 0xFE, 2843 // packet sequence number 2844 0xBC, 0x9A, 0x78, 0x56, 2845 0x34, 0x12, 2846 // private flags 2847 0x00, 2848 2849 // frame type (congestion feedback frame) 2850 0x03, 2851 // congestion feedback type (inter arrival) 2852 0x01, 2853 // accumulated_number_of_lost_packets 2854 0x02, 0x03, 2855 // num received packets 2856 0x03, 2857 // lowest sequence number 2858 0xBA, 0x9A, 0x78, 0x56, 2859 0x34, 0x12, 2860 // receive time 2861 0x87, 0x96, 0xA5, 0xB4, 2862 0xC3, 0xD2, 0xE1, 0x07, 2863 // sequence delta 2864 0x01, 0x00, 2865 // time delta 2866 0x01, 0x00, 0x00, 0x00, 2867 // sequence delta (skip one packet) 2868 0x03, 0x00, 2869 // time delta 2870 0x02, 0x00, 0x00, 0x00, 2871 }; 2872 2873 scoped_ptr<QuicPacket> data( 2874 framer_.BuildUnsizedDataPacket(header, frames).packet); 2875 ASSERT_TRUE(data != NULL); 2876 2877 test::CompareCharArraysWithHexError("constructed packet", 2878 data->data(), data->length(), 2879 AsChars(packet), arraysize(packet)); 2880 } 2881 2882 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketFixRate) { 2883 QuicPacketHeader header; 2884 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2885 header.public_header.reset_flag = false; 2886 header.public_header.version_flag = false; 2887 header.fec_flag = false; 2888 header.entropy_flag = false; 2889 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2890 header.fec_group = 0; 2891 2892 QuicCongestionFeedbackFrame congestion_feedback_frame; 2893 congestion_feedback_frame.type = kFixRate; 2894 congestion_feedback_frame.fix_rate.bitrate 2895 = QuicBandwidth::FromBytesPerSecond(0x04030201); 2896 2897 QuicFrames frames; 2898 frames.push_back(QuicFrame(&congestion_feedback_frame)); 2899 2900 unsigned char packet[] = { 2901 // public flags (8 byte guid) 2902 0x3C, 2903 // guid 2904 0x10, 0x32, 0x54, 0x76, 2905 0x98, 0xBA, 0xDC, 0xFE, 2906 // packet sequence number 2907 0xBC, 0x9A, 0x78, 0x56, 2908 0x34, 0x12, 2909 // private flags 2910 0x00, 2911 2912 // frame type (congestion feedback frame) 2913 0x03, 2914 // congestion feedback type (fix rate) 2915 0x02, 2916 // bitrate_in_bytes_per_second; 2917 0x01, 0x02, 0x03, 0x04, 2918 }; 2919 2920 scoped_ptr<QuicPacket> data( 2921 framer_.BuildUnsizedDataPacket(header, frames).packet); 2922 ASSERT_TRUE(data != NULL); 2923 2924 test::CompareCharArraysWithHexError("constructed packet", 2925 data->data(), data->length(), 2926 AsChars(packet), arraysize(packet)); 2927 } 2928 2929 TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInvalidFeedback) { 2930 QuicPacketHeader header; 2931 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2932 header.public_header.reset_flag = false; 2933 header.public_header.version_flag = false; 2934 header.fec_flag = false; 2935 header.entropy_flag = false; 2936 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2937 header.fec_group = 0; 2938 2939 QuicCongestionFeedbackFrame congestion_feedback_frame; 2940 congestion_feedback_frame.type = 2941 static_cast<CongestionFeedbackType>(kFixRate + 1); 2942 2943 QuicFrames frames; 2944 frames.push_back(QuicFrame(&congestion_feedback_frame)); 2945 2946 scoped_ptr<QuicPacket> data( 2947 framer_.BuildUnsizedDataPacket(header, frames).packet); 2948 ASSERT_TRUE(data == NULL); 2949 } 2950 2951 TEST_P(QuicFramerTest, BuildRstFramePacket) { 2952 QuicPacketHeader header; 2953 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 2954 header.public_header.reset_flag = false; 2955 header.public_header.version_flag = false; 2956 header.fec_flag = false; 2957 header.entropy_flag = false; 2958 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 2959 header.fec_group = 0; 2960 2961 QuicRstStreamFrame rst_frame; 2962 rst_frame.stream_id = 0x01020304; 2963 rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708); 2964 rst_frame.error_details = "because I can"; 2965 2966 unsigned char packet[] = { 2967 // public flags (8 byte guid) 2968 0x3C, 2969 // guid 2970 0x10, 0x32, 0x54, 0x76, 2971 0x98, 0xBA, 0xDC, 0xFE, 2972 // packet sequence number 2973 0xBC, 0x9A, 0x78, 0x56, 2974 0x34, 0x12, 2975 // private flags 2976 0x00, 2977 2978 // frame type (rst stream frame) 2979 static_cast<unsigned char>(0x27), 2980 // stream id 2981 0x04, 0x03, 0x02, 0x01, 2982 // error code 2983 0x08, 0x07, 0x06, 0x05, 2984 // error details length 2985 0x0d, 0x00, 2986 // error details 2987 'b', 'e', 'c', 'a', 2988 'u', 's', 'e', ' ', 2989 'I', ' ', 'c', 'a', 2990 'n', 2991 }; 2992 2993 QuicFrames frames; 2994 frames.push_back(QuicFrame(&rst_frame)); 2995 2996 scoped_ptr<QuicPacket> data( 2997 framer_.BuildUnsizedDataPacket(header, frames).packet); 2998 ASSERT_TRUE(data != NULL); 2999 3000 test::CompareCharArraysWithHexError("constructed packet", 3001 data->data(), data->length(), 3002 AsChars(packet), arraysize(packet)); 3003 } 3004 3005 TEST_P(QuicFramerTest, BuildCloseFramePacket) { 3006 QuicPacketHeader header; 3007 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3008 header.public_header.reset_flag = false; 3009 header.public_header.version_flag = false; 3010 header.fec_flag = false; 3011 header.entropy_flag = true; 3012 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3013 header.fec_group = 0; 3014 3015 QuicConnectionCloseFrame close_frame; 3016 close_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 3017 close_frame.error_details = "because I can"; 3018 3019 QuicAckFrame* ack_frame = &close_frame.ack_frame; 3020 ack_frame->received_info.entropy_hash = 0x43; 3021 ack_frame->received_info.largest_observed = GG_UINT64_C(0x0123456789ABF); 3022 ack_frame->received_info.missing_packets.insert(GG_UINT64_C(0x0123456789ABE)); 3023 ack_frame->sent_info.entropy_hash = 0xE0; 3024 ack_frame->sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 3025 3026 QuicFrames frames; 3027 frames.push_back(QuicFrame(&close_frame)); 3028 3029 unsigned char packet[] = { 3030 // public flags (8 byte guid) 3031 0x3C, 3032 // guid 3033 0x10, 0x32, 0x54, 0x76, 3034 0x98, 0xBA, 0xDC, 0xFE, 3035 // packet sequence number 3036 0xBC, 0x9A, 0x78, 0x56, 3037 0x34, 0x12, 3038 // private flags (entropy) 3039 0x01, 3040 3041 // frame type (connection close frame) 3042 static_cast<unsigned char>(0x2F), 3043 // error code 3044 0x08, 0x07, 0x06, 0x05, 3045 // error details length 3046 0x0d, 0x00, 3047 // error details 3048 'b', 'e', 'c', 'a', 3049 'u', 's', 'e', ' ', 3050 'I', ' ', 'c', 'a', 3051 'n', 3052 3053 // Ack frame. 3054 // entropy hash of sent packets till least awaiting - 1. 3055 0xE0, 3056 // least packet sequence number awaiting an ack 3057 0xA0, 0x9A, 0x78, 0x56, 3058 0x34, 0x12, 3059 // entropy hash of all received packets. 3060 0x43, 3061 // largest observed packet sequence number 3062 0xBF, 0x9A, 0x78, 0x56, 3063 0x34, 0x12, 3064 // Infinite delta time. 3065 0xFF, 0xFF, 0xFF, 0xFF, 3066 // num missing packets 3067 0x01, 3068 // missing packet 3069 0xBE, 0x9A, 0x78, 0x56, 3070 0x34, 0x12, 3071 }; 3072 3073 scoped_ptr<QuicPacket> data( 3074 framer_.BuildUnsizedDataPacket(header, frames).packet); 3075 ASSERT_TRUE(data != NULL); 3076 3077 test::CompareCharArraysWithHexError("constructed packet", 3078 data->data(), data->length(), 3079 AsChars(packet), arraysize(packet)); 3080 } 3081 3082 TEST_P(QuicFramerTest, BuildGoAwayPacket) { 3083 QuicPacketHeader header; 3084 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3085 header.public_header.reset_flag = false; 3086 header.public_header.version_flag = false; 3087 header.fec_flag = false; 3088 header.entropy_flag = true; 3089 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3090 header.fec_group = 0; 3091 3092 QuicGoAwayFrame goaway_frame; 3093 goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 3094 goaway_frame.last_good_stream_id = 0x01020304; 3095 goaway_frame.reason_phrase = "because I can"; 3096 3097 QuicFrames frames; 3098 frames.push_back(QuicFrame(&goaway_frame)); 3099 3100 unsigned char packet[] = { 3101 // public flags (8 byte guid) 3102 0x3C, 3103 // guid 3104 0x10, 0x32, 0x54, 0x76, 3105 0x98, 0xBA, 0xDC, 0xFE, 3106 // packet sequence number 3107 0xBC, 0x9A, 0x78, 0x56, 3108 0x34, 0x12, 3109 // private flags(entropy) 3110 0x01, 3111 3112 // frame type (go away frame) 3113 static_cast<unsigned char>(0x37), 3114 // error code 3115 0x08, 0x07, 0x06, 0x05, 3116 // stream id 3117 0x04, 0x03, 0x02, 0x01, 3118 // error details length 3119 0x0d, 0x00, 3120 // error details 3121 'b', 'e', 'c', 'a', 3122 'u', 's', 'e', ' ', 3123 'I', ' ', 'c', 'a', 3124 'n', 3125 }; 3126 3127 scoped_ptr<QuicPacket> data( 3128 framer_.BuildUnsizedDataPacket(header, frames).packet); 3129 ASSERT_TRUE(data != NULL); 3130 3131 test::CompareCharArraysWithHexError("constructed packet", 3132 data->data(), data->length(), 3133 AsChars(packet), arraysize(packet)); 3134 } 3135 3136 TEST_P(QuicFramerTest, BuildPublicResetPacket) { 3137 QuicPublicResetPacket reset_packet; 3138 reset_packet.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3139 reset_packet.public_header.reset_flag = true; 3140 reset_packet.public_header.version_flag = false; 3141 reset_packet.rejected_sequence_number = GG_UINT64_C(0x123456789ABC); 3142 reset_packet.nonce_proof = GG_UINT64_C(0xABCDEF0123456789); 3143 3144 unsigned char packet[] = { 3145 // public flags (public reset, 8 byte GUID) 3146 0x3E, 3147 // guid 3148 0x10, 0x32, 0x54, 0x76, 3149 0x98, 0xBA, 0xDC, 0xFE, 3150 // nonce proof 3151 0x89, 0x67, 0x45, 0x23, 3152 0x01, 0xEF, 0xCD, 0xAB, 3153 // rejected sequence number 3154 0xBC, 0x9A, 0x78, 0x56, 3155 0x34, 0x12, 3156 }; 3157 3158 scoped_ptr<QuicEncryptedPacket> data( 3159 framer_.BuildPublicResetPacket(reset_packet)); 3160 ASSERT_TRUE(data != NULL); 3161 3162 test::CompareCharArraysWithHexError("constructed packet", 3163 data->data(), data->length(), 3164 AsChars(packet), arraysize(packet)); 3165 } 3166 3167 TEST_P(QuicFramerTest, BuildFecPacket) { 3168 QuicPacketHeader header; 3169 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3170 header.public_header.reset_flag = false; 3171 header.public_header.version_flag = false; 3172 header.fec_flag = true; 3173 header.entropy_flag = true; 3174 header.packet_sequence_number = (GG_UINT64_C(0x123456789ABC)); 3175 header.is_in_fec_group = IN_FEC_GROUP; 3176 header.fec_group = GG_UINT64_C(0x123456789ABB);; 3177 3178 QuicFecData fec_data; 3179 fec_data.fec_group = 1; 3180 fec_data.redundancy = "abcdefghijklmnop"; 3181 3182 unsigned char packet[] = { 3183 // public flags (8 byte guid) 3184 0x3C, 3185 // guid 3186 0x10, 0x32, 0x54, 0x76, 3187 0x98, 0xBA, 0xDC, 0xFE, 3188 // packet sequence number 3189 0xBC, 0x9A, 0x78, 0x56, 3190 0x34, 0x12, 3191 // private flags (entropy & fec group & fec packet) 3192 0x07, 3193 // first fec protected packet offset 3194 0x01, 3195 3196 // redundancy 3197 'a', 'b', 'c', 'd', 3198 'e', 'f', 'g', 'h', 3199 'i', 'j', 'k', 'l', 3200 'm', 'n', 'o', 'p', 3201 }; 3202 3203 scoped_ptr<QuicPacket> data( 3204 framer_.BuildFecPacket(header, fec_data).packet); 3205 ASSERT_TRUE(data != NULL); 3206 3207 test::CompareCharArraysWithHexError("constructed packet", 3208 data->data(), data->length(), 3209 AsChars(packet), arraysize(packet)); 3210 } 3211 3212 TEST_P(QuicFramerTest, EncryptPacket) { 3213 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC); 3214 unsigned char packet[] = { 3215 // public flags (8 byte guid) 3216 0x3C, 3217 // guid 3218 0x10, 0x32, 0x54, 0x76, 3219 0x98, 0xBA, 0xDC, 0xFE, 3220 // packet sequence number 3221 0xBC, 0x9A, 0x78, 0x56, 3222 0x34, 0x12, 3223 // private flags (fec group & fec packet) 3224 0x06, 3225 // first fec protected packet offset 3226 0x01, 3227 3228 // redundancy 3229 'a', 'b', 'c', 'd', 3230 'e', 'f', 'g', 'h', 3231 'i', 'j', 'k', 'l', 3232 'm', 'n', 'o', 'p', 3233 }; 3234 3235 scoped_ptr<QuicPacket> raw( 3236 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false, 3237 PACKET_8BYTE_GUID, !kIncludeVersion, 3238 PACKET_6BYTE_SEQUENCE_NUMBER)); 3239 scoped_ptr<QuicEncryptedPacket> encrypted( 3240 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); 3241 3242 ASSERT_TRUE(encrypted.get() != NULL); 3243 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); 3244 } 3245 3246 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) { 3247 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC); 3248 unsigned char packet[] = { 3249 // public flags (version, 8 byte guid) 3250 0x3D, 3251 // guid 3252 0x10, 0x32, 0x54, 0x76, 3253 0x98, 0xBA, 0xDC, 0xFE, 3254 // version tag 3255 'Q', '.', '1', '0', 3256 // packet sequence number 3257 0xBC, 0x9A, 0x78, 0x56, 3258 0x34, 0x12, 3259 // private flags (fec group & fec flags) 3260 0x06, 3261 // first fec protected packet offset 3262 0x01, 3263 3264 // redundancy 3265 'a', 'b', 'c', 'd', 3266 'e', 'f', 'g', 'h', 3267 'i', 'j', 'k', 'l', 3268 'm', 'n', 'o', 'p', 3269 }; 3270 3271 scoped_ptr<QuicPacket> raw( 3272 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false, 3273 PACKET_8BYTE_GUID, kIncludeVersion, 3274 PACKET_6BYTE_SEQUENCE_NUMBER)); 3275 scoped_ptr<QuicEncryptedPacket> encrypted( 3276 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); 3277 3278 ASSERT_TRUE(encrypted.get() != NULL); 3279 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); 3280 } 3281 3282 // TODO(rch): re-enable after https://codereview.chromium.org/11820005/ 3283 // lands. Currently this is causing valgrind problems, but it should be 3284 // fixed in the followup CL. 3285 TEST_P(QuicFramerTest, DISABLED_CalculateLargestReceived) { 3286 SequenceNumberSet missing; 3287 missing.insert(1); 3288 missing.insert(5); 3289 missing.insert(7); 3290 3291 // These two we just walk to the next gap, and return the largest seen. 3292 EXPECT_EQ(4u, QuicFramer::CalculateLargestObserved(missing, missing.find(1))); 3293 EXPECT_EQ(6u, QuicFramer::CalculateLargestObserved(missing, missing.find(5))); 3294 3295 missing.insert(2); 3296 // For 1, we can't go forward as 2 would be implicitly acked so we return the 3297 // largest missing packet. 3298 EXPECT_EQ(1u, QuicFramer::CalculateLargestObserved(missing, missing.find(1))); 3299 // For 2, we've seen 3 and 4, so can admit to a largest observed. 3300 EXPECT_EQ(4u, QuicFramer::CalculateLargestObserved(missing, missing.find(2))); 3301 } 3302 3303 // TODO(rch) enable after landing the revised truncation CL. 3304 TEST_P(QuicFramerTest, DISABLED_Truncation) { 3305 QuicPacketHeader header; 3306 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3307 header.public_header.reset_flag = false; 3308 header.public_header.version_flag = false; 3309 header.fec_flag = false; 3310 header.entropy_flag = false; 3311 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3312 header.fec_group = 0; 3313 3314 QuicConnectionCloseFrame close_frame; 3315 QuicAckFrame* ack_frame = &close_frame.ack_frame; 3316 close_frame.error_code = static_cast<QuicErrorCode>(0x05); 3317 close_frame.error_details = "because I can"; 3318 ack_frame->received_info.largest_observed = 201; 3319 ack_frame->sent_info.least_unacked = 0; 3320 for (uint64 i = 1; i < ack_frame->received_info.largest_observed; ++i) { 3321 ack_frame->received_info.missing_packets.insert(i); 3322 } 3323 3324 // Create a packet with just the ack 3325 QuicFrame frame; 3326 frame.type = ACK_FRAME; 3327 frame.ack_frame = ack_frame; 3328 QuicFrames frames; 3329 frames.push_back(frame); 3330 3331 scoped_ptr<QuicPacket> raw_ack_packet( 3332 framer_.BuildUnsizedDataPacket(header, frames).packet); 3333 ASSERT_TRUE(raw_ack_packet != NULL); 3334 3335 scoped_ptr<QuicEncryptedPacket> ack_packet( 3336 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 3337 *raw_ack_packet)); 3338 3339 // Create a packet with just connection close. 3340 frames.clear(); 3341 frame.type = CONNECTION_CLOSE_FRAME; 3342 frame.connection_close_frame = &close_frame; 3343 frames.push_back(frame); 3344 3345 scoped_ptr<QuicPacket> raw_close_packet( 3346 framer_.BuildUnsizedDataPacket(header, frames).packet); 3347 ASSERT_TRUE(raw_close_packet != NULL); 3348 3349 scoped_ptr<QuicEncryptedPacket> close_packet( 3350 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 3351 *raw_close_packet)); 3352 3353 // Now make sure we can turn our ack packet back into an ack frame 3354 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 3355 3356 // And do the same for the close frame. 3357 ASSERT_TRUE(framer_.ProcessPacket(*close_packet)); 3358 } 3359 3360 TEST_P(QuicFramerTest, CleanTruncation) { 3361 QuicPacketHeader header; 3362 header.public_header.guid = GG_UINT64_C(0xFEDCBA9876543210); 3363 header.public_header.reset_flag = false; 3364 header.public_header.version_flag = false; 3365 header.fec_flag = false; 3366 header.entropy_flag = true; 3367 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3368 header.fec_group = 0; 3369 3370 QuicConnectionCloseFrame close_frame; 3371 QuicAckFrame* ack_frame = &close_frame.ack_frame; 3372 close_frame.error_code = static_cast<QuicErrorCode>(0x05); 3373 close_frame.error_details = "because I can"; 3374 ack_frame->received_info.largest_observed = 201; 3375 ack_frame->sent_info.least_unacked = 0; 3376 for (uint64 i = 1; i < ack_frame->received_info.largest_observed; ++i) { 3377 ack_frame->received_info.missing_packets.insert(i); 3378 } 3379 3380 // Create a packet with just the ack 3381 QuicFrame frame; 3382 frame.type = ACK_FRAME; 3383 frame.ack_frame = ack_frame; 3384 QuicFrames frames; 3385 frames.push_back(frame); 3386 3387 scoped_ptr<QuicPacket> raw_ack_packet( 3388 framer_.BuildUnsizedDataPacket(header, frames).packet); 3389 ASSERT_TRUE(raw_ack_packet != NULL); 3390 3391 scoped_ptr<QuicEncryptedPacket> ack_packet( 3392 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 3393 *raw_ack_packet)); 3394 3395 // Create a packet with just connection close. 3396 frames.clear(); 3397 frame.type = CONNECTION_CLOSE_FRAME; 3398 frame.connection_close_frame = &close_frame; 3399 frames.push_back(frame); 3400 3401 scoped_ptr<QuicPacket> raw_close_packet( 3402 framer_.BuildUnsizedDataPacket(header, frames).packet); 3403 ASSERT_TRUE(raw_close_packet != NULL); 3404 3405 scoped_ptr<QuicEncryptedPacket> close_packet( 3406 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 3407 *raw_close_packet)); 3408 3409 // Now make sure we can turn our ack packet back into an ack frame 3410 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 3411 3412 // And do the same for the close frame. 3413 ASSERT_TRUE(framer_.ProcessPacket(*close_packet)); 3414 3415 // Test for clean truncation of the ack by comparing the length of the 3416 // original packets to the re-serialized packets. 3417 frames.clear(); 3418 frame.type = ACK_FRAME; 3419 frame.ack_frame = visitor_.ack_frames_[0]; 3420 frames.push_back(frame); 3421 3422 size_t original_raw_length = raw_ack_packet->length(); 3423 raw_ack_packet.reset( 3424 framer_.BuildUnsizedDataPacket(header, frames).packet); 3425 ASSERT_TRUE(raw_ack_packet != NULL); 3426 EXPECT_EQ(original_raw_length, raw_ack_packet->length()); 3427 3428 frames.clear(); 3429 frame.type = CONNECTION_CLOSE_FRAME; 3430 frame.connection_close_frame = &visitor_.connection_close_frame_; 3431 frames.push_back(frame); 3432 3433 original_raw_length = raw_close_packet->length(); 3434 raw_close_packet.reset( 3435 framer_.BuildUnsizedDataPacket(header, frames).packet); 3436 ASSERT_TRUE(raw_ack_packet != NULL); 3437 EXPECT_EQ(original_raw_length, raw_close_packet->length()); 3438 } 3439 3440 TEST_P(QuicFramerTest, EntropyFlagTest) { 3441 // Set a specific version. 3442 framer_.set_version(QUIC_VERSION_7); 3443 3444 unsigned char packet[] = { 3445 // public flags (8 byte guid) 3446 0x3C, 3447 // guid 3448 0x10, 0x32, 0x54, 0x76, 3449 0x98, 0xBA, 0xDC, 0xFE, 3450 // packet sequence number 3451 0xBC, 0x9A, 0x78, 0x56, 3452 0x34, 0x12, 3453 // private flags (Entropy) 3454 0x01, 3455 3456 // frame type (stream frame with fin and no length) 3457 0xBE, 3458 // stream id 3459 0x04, 0x03, 0x02, 0x01, 3460 // offset 3461 0x54, 0x76, 0x10, 0x32, 3462 0xDC, 0xFE, 0x98, 0xBA, 3463 // data 3464 'h', 'e', 'l', 'l', 3465 'o', ' ', 'w', 'o', 3466 'r', 'l', 'd', '!', 3467 }; 3468 3469 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3470 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3471 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3472 ASSERT_TRUE(visitor_.header_.get()); 3473 EXPECT_TRUE(visitor_.header_->entropy_flag); 3474 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash); 3475 EXPECT_FALSE(visitor_.header_->fec_flag); 3476 }; 3477 3478 TEST_P(QuicFramerTest, FecEntropyTest) { 3479 // Set a specific version. 3480 framer_.set_version(QUIC_VERSION_7); 3481 3482 unsigned char packet[] = { 3483 // public flags (8 byte guid) 3484 0x3C, 3485 // guid 3486 0x10, 0x32, 0x54, 0x76, 3487 0x98, 0xBA, 0xDC, 0xFE, 3488 // packet sequence number 3489 0xBC, 0x9A, 0x78, 0x56, 3490 0x34, 0x12, 3491 // private flags (Entropy & fec group & FEC) 3492 0x07, 3493 // first fec protected packet offset 3494 0xFF, 3495 3496 // frame type (stream frame with fin and no length) 3497 0xBE, 3498 // stream id 3499 0x04, 0x03, 0x02, 0x01, 3500 // offset 3501 0x54, 0x76, 0x10, 0x32, 3502 0xDC, 0xFE, 0x98, 0xBA, 3503 // data 3504 'h', 'e', 'l', 'l', 3505 'o', ' ', 'w', 'o', 3506 'r', 'l', 'd', '!', 3507 }; 3508 3509 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3510 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3511 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3512 ASSERT_TRUE(visitor_.header_.get()); 3513 EXPECT_TRUE(visitor_.header_->fec_flag); 3514 EXPECT_TRUE(visitor_.header_->entropy_flag); 3515 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash); 3516 }; 3517 3518 TEST_P(QuicFramerTest, StopPacketProcessing) { 3519 // Set a specific version. 3520 framer_.set_version(QUIC_VERSION_7); 3521 3522 unsigned char packet[] = { 3523 // public flags (8 byte guid) 3524 0x3C, 3525 // guid 3526 0x10, 0x32, 0x54, 0x76, 3527 0x98, 0xBA, 0xDC, 0xFE, 3528 // packet sequence number 3529 0xBC, 0x9A, 0x78, 0x56, 3530 0x34, 0x12, 3531 // Entropy 3532 0x01, 3533 3534 // frame type (stream frame with fin) 3535 0xFE, 3536 // stream id 3537 0x04, 0x03, 0x02, 0x01, 3538 // offset 3539 0x54, 0x76, 0x10, 0x32, 3540 0xDC, 0xFE, 0x98, 0xBA, 3541 // data length 3542 0x0c, 0x00, 3543 // data 3544 'h', 'e', 'l', 'l', 3545 'o', ' ', 'w', 'o', 3546 'r', 'l', 'd', '!', 3547 3548 // frame type (ack frame) 3549 0x02, 3550 // entropy hash of sent packets till least awaiting - 1. 3551 0x14, 3552 // least packet sequence number awaiting an ack 3553 0xA0, 0x9A, 0x78, 0x56, 3554 0x34, 0x12, 3555 // entropy hash of all received packets. 3556 0x43, 3557 // largest observed packet sequence number 3558 0xBF, 0x9A, 0x78, 0x56, 3559 0x34, 0x12, 3560 // num missing packets 3561 0x01, 3562 // missing packet 3563 0xBE, 0x9A, 0x78, 0x56, 3564 0x34, 0x12, 3565 }; 3566 3567 MockFramerVisitor visitor; 3568 framer_.set_visitor(&visitor); 3569 EXPECT_CALL(visitor, OnPacket()); 3570 EXPECT_CALL(visitor, OnPacketHeader(_)); 3571 EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false)); 3572 EXPECT_CALL(visitor, OnAckFrame(_)).Times(0); 3573 EXPECT_CALL(visitor, OnPacketComplete()); 3574 3575 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3576 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3577 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3578 } 3579 3580 TEST_P(QuicFramerTest, ConnectionCloseWithInvalidAck) { 3581 unsigned char packet[] = { 3582 // public flags (8 byte guid) 3583 0x3C, 3584 // guid 3585 0x10, 0x32, 0x54, 0x76, 3586 0x98, 0xBA, 0xDC, 0xFE, 3587 // packet sequence number 3588 0xBC, 0x9A, 0x78, 0x56, 3589 0x34, 0x12, 3590 // private flags 3591 0x00, 3592 3593 // frame type (connection close frame) 3594 static_cast<unsigned char>(0x2F), 3595 // error code 3596 0x11, 0x00, 0x00, 0x00, 3597 // error details length 3598 0x0d, 0x00, 3599 // error details 3600 'b', 'e', 'c', 'a', 3601 'u', 's', 'e', ' ', 3602 'I', ' ', 'c', 'a', 3603 'n', 3604 3605 // Ack frame. 3606 // entropy hash of sent packets till least awaiting - 1. 3607 0xE0, 3608 // least packet sequence number awaiting an ack 3609 0xA0, 0x9A, 0x78, 0x56, 3610 0x34, 0x12, 3611 // entropy hash of all received packets. 3612 0x43, 3613 // largest observed packet sequence number 3614 0xBF, 0x9A, 0x78, 0x56, 3615 0x34, 0x12, 3616 // Infinite delta time. 3617 0xFF, 0xFF, 0xFF, 0xFF, 3618 // num missing packets 3619 0x01, 3620 // missing packet 3621 0xBE, 0x9A, 0x78, 0x56, 3622 0x34, 0x12, 3623 }; 3624 3625 MockFramerVisitor visitor; 3626 framer_.set_visitor(&visitor); 3627 EXPECT_CALL(visitor, OnPacket()); 3628 EXPECT_CALL(visitor, OnPacketHeader(_)); 3629 EXPECT_CALL(visitor, OnAckFrame(_)).WillOnce(Return(false)); 3630 EXPECT_CALL(visitor, OnConnectionCloseFrame(_)).Times(0); 3631 EXPECT_CALL(visitor, OnPacketComplete()); 3632 3633 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3634 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3635 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3636 } 3637 3638 } // namespace test 3639 } // namespace net 3640
