1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "net/quic/quic_framer.h" 6 7#include <algorithm> 8#include <map> 9#include <string> 10#include <vector> 11 12#include "base/containers/hash_tables.h" 13#include "base/logging.h" 14#include "base/memory/scoped_ptr.h" 15#include "base/port.h" 16#include "base/stl_util.h" 17#include "net/quic/crypto/quic_decrypter.h" 18#include "net/quic/crypto/quic_encrypter.h" 19#include "net/quic/quic_protocol.h" 20#include "net/quic/quic_utils.h" 21#include "net/quic/test_tools/quic_framer_peer.h" 22#include "net/quic/test_tools/quic_test_utils.h" 23#include "net/test/gtest_util.h" 24 25using base::hash_set; 26using base::StringPiece; 27using std::make_pair; 28using std::map; 29using std::numeric_limits; 30using std::pair; 31using std::string; 32using std::vector; 33using testing::Return; 34using testing::_; 35 36namespace net { 37namespace test { 38 39const QuicPacketSequenceNumber kEpoch = GG_UINT64_C(1) << 48; 40const QuicPacketSequenceNumber kMask = kEpoch - 1; 41 42// Index into the connection_id offset in the header. 43const size_t kConnectionIdOffset = kPublicFlagsSize; 44// Index into the version string in the header. (if present). 45const size_t kVersionOffset = kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID; 46 47// Size in bytes of the stream frame fields for an arbitrary StreamID and 48// offset and the last frame in a packet. 49size_t GetMinStreamFrameSize() { 50 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize; 51} 52 53// Index into the sequence number offset in the header. 54size_t GetSequenceNumberOffset(QuicConnectionIdLength connection_id_length, 55 bool include_version) { 56 return kConnectionIdOffset + connection_id_length + 57 (include_version ? kQuicVersionSize : 0); 58} 59 60size_t GetSequenceNumberOffset(bool include_version) { 61 return GetSequenceNumberOffset(PACKET_8BYTE_CONNECTION_ID, include_version); 62} 63 64// Index into the private flags offset in the data packet header. 65size_t GetPrivateFlagsOffset(QuicConnectionIdLength connection_id_length, 66 bool include_version) { 67 return GetSequenceNumberOffset(connection_id_length, include_version) + 68 PACKET_6BYTE_SEQUENCE_NUMBER; 69} 70 71size_t GetPrivateFlagsOffset(bool include_version) { 72 return GetPrivateFlagsOffset(PACKET_8BYTE_CONNECTION_ID, include_version); 73} 74 75size_t GetPrivateFlagsOffset(bool include_version, 76 QuicSequenceNumberLength sequence_number_length) { 77 return GetSequenceNumberOffset(PACKET_8BYTE_CONNECTION_ID, include_version) + 78 sequence_number_length; 79} 80 81// Index into the fec group offset in the header. 82size_t GetFecGroupOffset(QuicConnectionIdLength connection_id_length, 83 bool include_version) { 84 return GetPrivateFlagsOffset(connection_id_length, include_version) + 85 kPrivateFlagsSize; 86} 87 88size_t GetFecGroupOffset(bool include_version) { 89 return GetPrivateFlagsOffset(PACKET_8BYTE_CONNECTION_ID, include_version) + 90 kPrivateFlagsSize; 91} 92 93size_t GetFecGroupOffset(bool include_version, 94 QuicSequenceNumberLength sequence_number_length) { 95 return GetPrivateFlagsOffset(include_version, sequence_number_length) + 96 kPrivateFlagsSize; 97} 98 99// Index into the message tag of the public reset packet. 100// Public resets always have full connection_ids. 101const size_t kPublicResetPacketMessageTagOffset = 102 kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID; 103 104class TestEncrypter : public QuicEncrypter { 105 public: 106 virtual ~TestEncrypter() {} 107 virtual bool SetKey(StringPiece key) OVERRIDE { 108 return true; 109 } 110 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE { 111 return true; 112 } 113 virtual bool Encrypt(StringPiece nonce, 114 StringPiece associated_data, 115 StringPiece plaintext, 116 unsigned char* output) OVERRIDE { 117 CHECK(false) << "Not implemented"; 118 return false; 119 } 120 virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number, 121 StringPiece associated_data, 122 StringPiece plaintext) OVERRIDE { 123 sequence_number_ = sequence_number; 124 associated_data_ = associated_data.as_string(); 125 plaintext_ = plaintext.as_string(); 126 return new QuicData(plaintext.data(), plaintext.length()); 127 } 128 virtual size_t GetKeySize() const OVERRIDE { 129 return 0; 130 } 131 virtual size_t GetNoncePrefixSize() const OVERRIDE { 132 return 0; 133 } 134 virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE { 135 return ciphertext_size; 136 } 137 virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE { 138 return plaintext_size; 139 } 140 virtual StringPiece GetKey() const OVERRIDE { 141 return StringPiece(); 142 } 143 virtual StringPiece GetNoncePrefix() const OVERRIDE { 144 return StringPiece(); 145 } 146 QuicPacketSequenceNumber sequence_number_; 147 string associated_data_; 148 string plaintext_; 149}; 150 151class TestDecrypter : public QuicDecrypter { 152 public: 153 virtual ~TestDecrypter() {} 154 virtual bool SetKey(StringPiece key) OVERRIDE { 155 return true; 156 } 157 virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE { 158 return true; 159 } 160 virtual bool Decrypt(StringPiece nonce, 161 StringPiece associated_data, 162 StringPiece ciphertext, 163 unsigned char* output, 164 size_t* output_length) OVERRIDE { 165 CHECK(false) << "Not implemented"; 166 return false; 167 } 168 virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number, 169 StringPiece associated_data, 170 StringPiece ciphertext) OVERRIDE { 171 sequence_number_ = sequence_number; 172 associated_data_ = associated_data.as_string(); 173 ciphertext_ = ciphertext.as_string(); 174 return new QuicData(ciphertext.data(), ciphertext.length()); 175 } 176 virtual StringPiece GetKey() const OVERRIDE { 177 return StringPiece(); 178 } 179 virtual StringPiece GetNoncePrefix() const OVERRIDE { 180 return StringPiece(); 181 } 182 QuicPacketSequenceNumber sequence_number_; 183 string associated_data_; 184 string ciphertext_; 185}; 186 187class TestQuicVisitor : public ::net::QuicFramerVisitorInterface { 188 public: 189 TestQuicVisitor() 190 : error_count_(0), 191 version_mismatch_(0), 192 packet_count_(0), 193 frame_count_(0), 194 fec_count_(0), 195 complete_packets_(0), 196 revived_packets_(0), 197 accept_packet_(true), 198 accept_public_header_(true) { 199 } 200 201 virtual ~TestQuicVisitor() { 202 STLDeleteElements(&stream_frames_); 203 STLDeleteElements(&ack_frames_); 204 STLDeleteElements(&congestion_feedback_frames_); 205 STLDeleteElements(&stop_waiting_frames_); 206 STLDeleteElements(&ping_frames_); 207 STLDeleteElements(&fec_data_); 208 } 209 210 virtual void OnError(QuicFramer* f) OVERRIDE { 211 DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error()) 212 << " (" << f->error() << ")"; 213 ++error_count_; 214 } 215 216 virtual void OnPacket() OVERRIDE {} 217 218 virtual void OnPublicResetPacket( 219 const QuicPublicResetPacket& packet) OVERRIDE { 220 public_reset_packet_.reset(new QuicPublicResetPacket(packet)); 221 } 222 223 virtual void OnVersionNegotiationPacket( 224 const QuicVersionNegotiationPacket& packet) OVERRIDE { 225 version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet)); 226 } 227 228 virtual void OnRevivedPacket() OVERRIDE { 229 ++revived_packets_; 230 } 231 232 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE { 233 DVLOG(1) << "QuicFramer Version Mismatch, version: " << version; 234 ++version_mismatch_; 235 return true; 236 } 237 238 virtual bool OnUnauthenticatedPublicHeader( 239 const QuicPacketPublicHeader& header) OVERRIDE { 240 public_header_.reset(new QuicPacketPublicHeader(header)); 241 return accept_public_header_; 242 } 243 244 virtual bool OnUnauthenticatedHeader( 245 const QuicPacketHeader& header) OVERRIDE { 246 return true; 247 } 248 249 virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {} 250 251 virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE { 252 ++packet_count_; 253 header_.reset(new QuicPacketHeader(header)); 254 return accept_packet_; 255 } 256 257 virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE { 258 ++frame_count_; 259 stream_frames_.push_back(new QuicStreamFrame(frame)); 260 return true; 261 } 262 263 virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE { 264 fec_protected_payload_ = payload.as_string(); 265 } 266 267 virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE { 268 ++frame_count_; 269 ack_frames_.push_back(new QuicAckFrame(frame)); 270 return true; 271 } 272 273 virtual bool OnCongestionFeedbackFrame( 274 const QuicCongestionFeedbackFrame& frame) OVERRIDE { 275 ++frame_count_; 276 congestion_feedback_frames_.push_back( 277 new QuicCongestionFeedbackFrame(frame)); 278 return true; 279 } 280 281 virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE { 282 ++frame_count_; 283 stop_waiting_frames_.push_back(new QuicStopWaitingFrame(frame)); 284 return true; 285 } 286 287 virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE { 288 ++frame_count_; 289 ping_frames_.push_back(new QuicPingFrame(frame)); 290 return true; 291 } 292 293 virtual void OnFecData(const QuicFecData& fec) OVERRIDE { 294 ++fec_count_; 295 fec_data_.push_back(new QuicFecData(fec)); 296 } 297 298 virtual void OnPacketComplete() OVERRIDE { 299 ++complete_packets_; 300 } 301 302 virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE { 303 rst_stream_frame_ = frame; 304 return true; 305 } 306 307 virtual bool OnConnectionCloseFrame( 308 const QuicConnectionCloseFrame& frame) OVERRIDE { 309 connection_close_frame_ = frame; 310 return true; 311 } 312 313 virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE { 314 goaway_frame_ = frame; 315 return true; 316 } 317 318 virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) 319 OVERRIDE { 320 window_update_frame_ = frame; 321 return true; 322 } 323 324 virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE { 325 blocked_frame_ = frame; 326 return true; 327 } 328 329 // Counters from the visitor_ callbacks. 330 int error_count_; 331 int version_mismatch_; 332 int packet_count_; 333 int frame_count_; 334 int fec_count_; 335 int complete_packets_; 336 int revived_packets_; 337 bool accept_packet_; 338 bool accept_public_header_; 339 340 scoped_ptr<QuicPacketHeader> header_; 341 scoped_ptr<QuicPacketPublicHeader> public_header_; 342 scoped_ptr<QuicPublicResetPacket> public_reset_packet_; 343 scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_; 344 vector<QuicStreamFrame*> stream_frames_; 345 vector<QuicAckFrame*> ack_frames_; 346 vector<QuicCongestionFeedbackFrame*> congestion_feedback_frames_; 347 vector<QuicStopWaitingFrame*> stop_waiting_frames_; 348 vector<QuicPingFrame*> ping_frames_; 349 vector<QuicFecData*> fec_data_; 350 string fec_protected_payload_; 351 QuicRstStreamFrame rst_stream_frame_; 352 QuicConnectionCloseFrame connection_close_frame_; 353 QuicGoAwayFrame goaway_frame_; 354 QuicWindowUpdateFrame window_update_frame_; 355 QuicBlockedFrame blocked_frame_; 356}; 357 358class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> { 359 public: 360 QuicFramerTest() 361 : encrypter_(new test::TestEncrypter()), 362 decrypter_(new test::TestDecrypter()), 363 start_(QuicTime::Zero().Add(QuicTime::Delta::FromMicroseconds(0x10))), 364 framer_(QuicSupportedVersions(), start_, true) { 365 version_ = GetParam(); 366 framer_.set_version(version_); 367 framer_.SetDecrypter(decrypter_, ENCRYPTION_NONE); 368 framer_.SetEncrypter(ENCRYPTION_NONE, encrypter_); 369 framer_.set_visitor(&visitor_); 370 framer_.set_received_entropy_calculator(&entropy_calculator_); 371 } 372 373 // Helper function to get unsigned char representation of digit in the 374 // units place of the current QUIC version number. 375 unsigned char GetQuicVersionDigitOnes() { 376 return static_cast<unsigned char> ('0' + version_%10); 377 } 378 379 // Helper function to get unsigned char representation of digit in the 380 // tens place of the current QUIC version number. 381 unsigned char GetQuicVersionDigitTens() { 382 return static_cast<unsigned char> ('0' + (version_/10)%10); 383 } 384 385 bool CheckEncryption(QuicPacketSequenceNumber sequence_number, 386 QuicPacket* packet) { 387 if (sequence_number != encrypter_->sequence_number_) { 388 LOG(ERROR) << "Encrypted incorrect packet sequence number. expected " 389 << sequence_number << " actual: " 390 << encrypter_->sequence_number_; 391 return false; 392 } 393 if (packet->AssociatedData() != encrypter_->associated_data_) { 394 LOG(ERROR) << "Encrypted incorrect associated data. expected " 395 << packet->AssociatedData() << " actual: " 396 << encrypter_->associated_data_; 397 return false; 398 } 399 if (packet->Plaintext() != encrypter_->plaintext_) { 400 LOG(ERROR) << "Encrypted incorrect plaintext data. expected " 401 << packet->Plaintext() << " actual: " 402 << encrypter_->plaintext_; 403 return false; 404 } 405 return true; 406 } 407 408 bool CheckDecryption(const QuicEncryptedPacket& encrypted, 409 bool includes_version) { 410 if (visitor_.header_->packet_sequence_number != 411 decrypter_->sequence_number_) { 412 LOG(ERROR) << "Decrypted incorrect packet sequence number. expected " 413 << visitor_.header_->packet_sequence_number << " actual: " 414 << decrypter_->sequence_number_; 415 return false; 416 } 417 if (QuicFramer::GetAssociatedDataFromEncryptedPacket( 418 encrypted, PACKET_8BYTE_CONNECTION_ID, 419 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) != 420 decrypter_->associated_data_) { 421 LOG(ERROR) << "Decrypted incorrect associated data. expected " 422 << QuicFramer::GetAssociatedDataFromEncryptedPacket( 423 encrypted, PACKET_8BYTE_CONNECTION_ID, 424 includes_version, PACKET_6BYTE_SEQUENCE_NUMBER) 425 << " actual: " << decrypter_->associated_data_; 426 return false; 427 } 428 StringPiece ciphertext(encrypted.AsStringPiece().substr( 429 GetStartOfEncryptedData(PACKET_8BYTE_CONNECTION_ID, includes_version, 430 PACKET_6BYTE_SEQUENCE_NUMBER))); 431 if (ciphertext != decrypter_->ciphertext_) { 432 LOG(ERROR) << "Decrypted incorrect ciphertext data. expected " 433 << ciphertext << " actual: " 434 << decrypter_->ciphertext_; 435 return false; 436 } 437 return true; 438 } 439 440 char* AsChars(unsigned char* data) { 441 return reinterpret_cast<char*>(data); 442 } 443 444 void CheckProcessingFails(unsigned char* packet, 445 size_t len, 446 string expected_error, 447 QuicErrorCode error_code) { 448 QuicEncryptedPacket encrypted(AsChars(packet), len, false); 449 EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len; 450 EXPECT_EQ(expected_error, framer_.detailed_error()) << "len: " << len; 451 EXPECT_EQ(error_code, framer_.error()) << "len: " << len; 452 } 453 454 // Checks if the supplied string matches data in the supplied StreamFrame. 455 void CheckStreamFrameData(string str, QuicStreamFrame* frame) { 456 scoped_ptr<string> frame_data(frame->GetDataAsString()); 457 EXPECT_EQ(str, *frame_data); 458 } 459 460 void CheckStreamFrameBoundaries(unsigned char* packet, 461 size_t stream_id_size, 462 bool include_version) { 463 // Now test framing boundaries. 464 for (size_t i = kQuicFrameTypeSize; i < GetMinStreamFrameSize(); ++i) { 465 string expected_error; 466 if (i < kQuicFrameTypeSize + stream_id_size) { 467 expected_error = "Unable to read stream_id."; 468 } else if (i < kQuicFrameTypeSize + stream_id_size + 469 kQuicMaxStreamOffsetSize) { 470 expected_error = "Unable to read offset."; 471 } else { 472 expected_error = "Unable to read frame data."; 473 } 474 CheckProcessingFails( 475 packet, 476 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version, 477 PACKET_6BYTE_SEQUENCE_NUMBER, 478 NOT_IN_FEC_GROUP), 479 expected_error, QUIC_INVALID_STREAM_DATA); 480 } 481 } 482 483 void CheckCalculatePacketSequenceNumber( 484 QuicPacketSequenceNumber expected_sequence_number, 485 QuicPacketSequenceNumber last_sequence_number) { 486 QuicPacketSequenceNumber wire_sequence_number = 487 expected_sequence_number & kMask; 488 QuicFramerPeer::SetLastSequenceNumber(&framer_, last_sequence_number); 489 EXPECT_EQ(expected_sequence_number, 490 QuicFramerPeer::CalculatePacketSequenceNumberFromWire( 491 &framer_, PACKET_6BYTE_SEQUENCE_NUMBER, wire_sequence_number)) 492 << "last_sequence_number: " << last_sequence_number 493 << " wire_sequence_number: " << wire_sequence_number; 494 } 495 496 QuicPacket* BuildDataPacket(const QuicPacketHeader& header, 497 const QuicFrames& frames) { 498 return BuildUnsizedDataPacket(&framer_, header, frames).packet; 499 } 500 501 test::TestEncrypter* encrypter_; 502 test::TestDecrypter* decrypter_; 503 QuicVersion version_; 504 QuicTime start_; 505 QuicFramer framer_; 506 test::TestQuicVisitor visitor_; 507 test::TestEntropyCalculator entropy_calculator_; 508}; 509 510// Run all framer tests with all supported versions of QUIC. 511INSTANTIATE_TEST_CASE_P(QuicFramerTests, 512 QuicFramerTest, 513 ::testing::ValuesIn(kSupportedQuicVersions)); 514 515TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochStart) { 516 // A few quick manual sanity checks 517 CheckCalculatePacketSequenceNumber(GG_UINT64_C(1), GG_UINT64_C(0)); 518 CheckCalculatePacketSequenceNumber(kEpoch + 1, kMask); 519 CheckCalculatePacketSequenceNumber(kEpoch, kMask); 520 521 // Cases where the last number was close to the start of the range 522 for (uint64 last = 0; last < 10; last++) { 523 // Small numbers should not wrap (even if they're out of order). 524 for (uint64 j = 0; j < 10; j++) { 525 CheckCalculatePacketSequenceNumber(j, last); 526 } 527 528 // Large numbers should not wrap either (because we're near 0 already). 529 for (uint64 j = 0; j < 10; j++) { 530 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last); 531 } 532 } 533} 534 535TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearEpochEnd) { 536 // Cases where the last number was close to the end of the range 537 for (uint64 i = 0; i < 10; i++) { 538 QuicPacketSequenceNumber last = kEpoch - i; 539 540 // Small numbers should wrap. 541 for (uint64 j = 0; j < 10; j++) { 542 CheckCalculatePacketSequenceNumber(kEpoch + j, last); 543 } 544 545 // Large numbers should not (even if they're out of order). 546 for (uint64 j = 0; j < 10; j++) { 547 CheckCalculatePacketSequenceNumber(kEpoch - 1 - j, last); 548 } 549 } 550} 551 552// Next check where we're in a non-zero epoch to verify we handle 553// reverse wrapping, too. 554TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearPrevEpoch) { 555 const uint64 prev_epoch = 1 * kEpoch; 556 const uint64 cur_epoch = 2 * kEpoch; 557 // Cases where the last number was close to the start of the range 558 for (uint64 i = 0; i < 10; i++) { 559 uint64 last = cur_epoch + i; 560 // Small number should not wrap (even if they're out of order). 561 for (uint64 j = 0; j < 10; j++) { 562 CheckCalculatePacketSequenceNumber(cur_epoch + j, last); 563 } 564 565 // But large numbers should reverse wrap. 566 for (uint64 j = 0; j < 10; j++) { 567 uint64 num = kEpoch - 1 - j; 568 CheckCalculatePacketSequenceNumber(prev_epoch + num, last); 569 } 570 } 571} 572 573TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextEpoch) { 574 const uint64 cur_epoch = 2 * kEpoch; 575 const uint64 next_epoch = 3 * kEpoch; 576 // Cases where the last number was close to the end of the range 577 for (uint64 i = 0; i < 10; i++) { 578 QuicPacketSequenceNumber last = next_epoch - 1 - i; 579 580 // Small numbers should wrap. 581 for (uint64 j = 0; j < 10; j++) { 582 CheckCalculatePacketSequenceNumber(next_epoch + j, last); 583 } 584 585 // but large numbers should not (even if they're out of order). 586 for (uint64 j = 0; j < 10; j++) { 587 uint64 num = kEpoch - 1 - j; 588 CheckCalculatePacketSequenceNumber(cur_epoch + num, last); 589 } 590 } 591} 592 593TEST_P(QuicFramerTest, CalculatePacketSequenceNumberFromWireNearNextMax) { 594 const uint64 max_number = numeric_limits<uint64>::max(); 595 const uint64 max_epoch = max_number & ~kMask; 596 597 // Cases where the last number was close to the end of the range 598 for (uint64 i = 0; i < 10; i++) { 599 // Subtract 1, because the expected next sequence number is 1 more than the 600 // last sequence number. 601 QuicPacketSequenceNumber last = max_number - i - 1; 602 603 // Small numbers should not wrap, because they have nowhere to go. 604 for (uint64 j = 0; j < 10; j++) { 605 CheckCalculatePacketSequenceNumber(max_epoch + j, last); 606 } 607 608 // Large numbers should not wrap either. 609 for (uint64 j = 0; j < 10; j++) { 610 uint64 num = kEpoch - 1 - j; 611 CheckCalculatePacketSequenceNumber(max_epoch + num, last); 612 } 613 } 614} 615 616TEST_P(QuicFramerTest, EmptyPacket) { 617 char packet[] = { 0x00 }; 618 QuicEncryptedPacket encrypted(packet, 0, false); 619 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 620 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error()); 621} 622 623TEST_P(QuicFramerTest, LargePacket) { 624 unsigned char packet[kMaxPacketSize + 1] = { 625 // public flags (8 byte connection_id) 626 0x3C, 627 // connection_id 628 0x10, 0x32, 0x54, 0x76, 629 0x98, 0xBA, 0xDC, 0xFE, 630 // packet sequence number 631 0xBC, 0x9A, 0x78, 0x56, 632 0x34, 0x12, 633 // private flags 634 0x00, 635 }; 636 637 memset(packet + GetPacketHeaderSize( 638 PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 639 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 0, 640 kMaxPacketSize - GetPacketHeaderSize( 641 PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 642 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP) + 1); 643 644 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 645 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 646 647 ASSERT_TRUE(visitor_.header_.get()); 648 // Make sure we've parsed the packet header, so we can send an error. 649 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 650 visitor_.header_->public_header.connection_id); 651 // Make sure the correct error is propagated. 652 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error()); 653} 654 655TEST_P(QuicFramerTest, PacketHeader) { 656 unsigned char packet[] = { 657 // public flags (8 byte connection_id) 658 0x3C, 659 // connection_id 660 0x10, 0x32, 0x54, 0x76, 661 0x98, 0xBA, 0xDC, 0xFE, 662 // packet sequence number 663 0xBC, 0x9A, 0x78, 0x56, 664 0x34, 0x12, 665 // private flags 666 0x00, 667 }; 668 669 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 670 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 671 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 672 ASSERT_TRUE(visitor_.header_.get()); 673 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 674 visitor_.header_->public_header.connection_id); 675 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 676 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 677 EXPECT_FALSE(visitor_.header_->fec_flag); 678 EXPECT_FALSE(visitor_.header_->entropy_flag); 679 EXPECT_EQ(0, visitor_.header_->entropy_hash); 680 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 681 visitor_.header_->packet_sequence_number); 682 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 683 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 684 685 // Now test framing boundaries. 686 for (size_t i = 0; 687 i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 688 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 689 ++i) { 690 string expected_error; 691 if (i < kConnectionIdOffset) { 692 expected_error = "Unable to read public flags."; 693 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 694 expected_error = "Unable to read ConnectionId."; 695 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion)) { 696 expected_error = "Unable to read sequence number."; 697 } else if (i < GetFecGroupOffset(!kIncludeVersion)) { 698 expected_error = "Unable to read private flags."; 699 } else { 700 expected_error = "Unable to read first fec protected packet offset."; 701 } 702 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 703 } 704} 705 706TEST_P(QuicFramerTest, PacketHeaderWith4ByteConnectionId) { 707 QuicFramerPeer::SetLastSerializedConnectionId( 708 &framer_, GG_UINT64_C(0xFEDCBA9876543210)); 709 710 unsigned char packet[] = { 711 // public flags (4 byte connection_id) 712 0x38, 713 // connection_id 714 0x10, 0x32, 0x54, 0x76, 715 // packet sequence number 716 0xBC, 0x9A, 0x78, 0x56, 717 0x34, 0x12, 718 // private flags 719 0x00, 720 }; 721 722 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 723 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 724 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 725 ASSERT_TRUE(visitor_.header_.get()); 726 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 727 visitor_.header_->public_header.connection_id); 728 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 729 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 730 EXPECT_FALSE(visitor_.header_->fec_flag); 731 EXPECT_FALSE(visitor_.header_->entropy_flag); 732 EXPECT_EQ(0, visitor_.header_->entropy_hash); 733 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 734 visitor_.header_->packet_sequence_number); 735 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 736 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 737 738 // Now test framing boundaries. 739 for (size_t i = 0; 740 i < GetPacketHeaderSize(PACKET_4BYTE_CONNECTION_ID, !kIncludeVersion, 741 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 742 ++i) { 743 string expected_error; 744 if (i < kConnectionIdOffset) { 745 expected_error = "Unable to read public flags."; 746 } else if (i < GetSequenceNumberOffset(PACKET_4BYTE_CONNECTION_ID, 747 !kIncludeVersion)) { 748 expected_error = "Unable to read ConnectionId."; 749 } else if (i < GetPrivateFlagsOffset(PACKET_4BYTE_CONNECTION_ID, 750 !kIncludeVersion)) { 751 expected_error = "Unable to read sequence number."; 752 } else if (i < GetFecGroupOffset(PACKET_4BYTE_CONNECTION_ID, 753 !kIncludeVersion)) { 754 expected_error = "Unable to read private flags."; 755 } else { 756 expected_error = "Unable to read first fec protected packet offset."; 757 } 758 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 759 } 760} 761 762TEST_P(QuicFramerTest, PacketHeader1ByteConnectionId) { 763 QuicFramerPeer::SetLastSerializedConnectionId( 764 &framer_, GG_UINT64_C(0xFEDCBA9876543210)); 765 766 unsigned char packet[] = { 767 // public flags (1 byte connection_id) 768 0x34, 769 // connection_id 770 0x10, 771 // packet sequence number 772 0xBC, 0x9A, 0x78, 0x56, 773 0x34, 0x12, 774 // private flags 775 0x00, 776 }; 777 778 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 779 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 780 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 781 ASSERT_TRUE(visitor_.header_.get()); 782 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 783 visitor_.header_->public_header.connection_id); 784 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 785 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 786 EXPECT_FALSE(visitor_.header_->fec_flag); 787 EXPECT_FALSE(visitor_.header_->entropy_flag); 788 EXPECT_EQ(0, visitor_.header_->entropy_hash); 789 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 790 visitor_.header_->packet_sequence_number); 791 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 792 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 793 794 // Now test framing boundaries. 795 for (size_t i = 0; 796 i < GetPacketHeaderSize(PACKET_1BYTE_CONNECTION_ID, !kIncludeVersion, 797 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 798 ++i) { 799 string expected_error; 800 if (i < kConnectionIdOffset) { 801 expected_error = "Unable to read public flags."; 802 } else if (i < GetSequenceNumberOffset(PACKET_1BYTE_CONNECTION_ID, 803 !kIncludeVersion)) { 804 expected_error = "Unable to read ConnectionId."; 805 } else if (i < GetPrivateFlagsOffset(PACKET_1BYTE_CONNECTION_ID, 806 !kIncludeVersion)) { 807 expected_error = "Unable to read sequence number."; 808 } else if (i < GetFecGroupOffset(PACKET_1BYTE_CONNECTION_ID, 809 !kIncludeVersion)) { 810 expected_error = "Unable to read private flags."; 811 } else { 812 expected_error = "Unable to read first fec protected packet offset."; 813 } 814 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 815 } 816} 817 818TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) { 819 QuicFramerPeer::SetLastSerializedConnectionId( 820 &framer_, GG_UINT64_C(0xFEDCBA9876543210)); 821 822 unsigned char packet[] = { 823 // public flags (0 byte connection_id) 824 0x30, 825 // connection_id 826 // packet sequence number 827 0xBC, 0x9A, 0x78, 0x56, 828 0x34, 0x12, 829 // private flags 830 0x00, 831 }; 832 833 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 834 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 835 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 836 ASSERT_TRUE(visitor_.header_.get()); 837 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 838 visitor_.header_->public_header.connection_id); 839 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 840 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 841 EXPECT_FALSE(visitor_.header_->fec_flag); 842 EXPECT_FALSE(visitor_.header_->entropy_flag); 843 EXPECT_EQ(0, visitor_.header_->entropy_hash); 844 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 845 visitor_.header_->packet_sequence_number); 846 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 847 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 848 849 // Now test framing boundaries. 850 for (size_t i = 0; 851 i < GetPacketHeaderSize(PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion, 852 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 853 ++i) { 854 string expected_error; 855 if (i < kConnectionIdOffset) { 856 expected_error = "Unable to read public flags."; 857 } else if (i < GetSequenceNumberOffset(PACKET_0BYTE_CONNECTION_ID, 858 !kIncludeVersion)) { 859 expected_error = "Unable to read ConnectionId."; 860 } else if (i < GetPrivateFlagsOffset(PACKET_0BYTE_CONNECTION_ID, 861 !kIncludeVersion)) { 862 expected_error = "Unable to read sequence number."; 863 } else if (i < GetFecGroupOffset(PACKET_0BYTE_CONNECTION_ID, 864 !kIncludeVersion)) { 865 expected_error = "Unable to read private flags."; 866 } else { 867 expected_error = "Unable to read first fec protected packet offset."; 868 } 869 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 870 } 871} 872 873TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) { 874 unsigned char packet[] = { 875 // public flags (version) 876 0x3D, 877 // connection_id 878 0x10, 0x32, 0x54, 0x76, 879 0x98, 0xBA, 0xDC, 0xFE, 880 // version tag 881 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 882 // packet sequence number 883 0xBC, 0x9A, 0x78, 0x56, 884 0x34, 0x12, 885 // private flags 886 0x00, 887 }; 888 889 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 890 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 891 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 892 ASSERT_TRUE(visitor_.header_.get()); 893 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 894 visitor_.header_->public_header.connection_id); 895 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 896 EXPECT_TRUE(visitor_.header_->public_header.version_flag); 897 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); 898 EXPECT_FALSE(visitor_.header_->fec_flag); 899 EXPECT_FALSE(visitor_.header_->entropy_flag); 900 EXPECT_EQ(0, visitor_.header_->entropy_hash); 901 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 902 visitor_.header_->packet_sequence_number); 903 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 904 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 905 906 // Now test framing boundaries. 907 for (size_t i = 0; 908 i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, 909 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 910 ++i) { 911 string expected_error; 912 if (i < kConnectionIdOffset) { 913 expected_error = "Unable to read public flags."; 914 } else if (i < kVersionOffset) { 915 expected_error = "Unable to read ConnectionId."; 916 } else if (i < GetSequenceNumberOffset(kIncludeVersion)) { 917 expected_error = "Unable to read protocol version."; 918 } else if (i < GetPrivateFlagsOffset(kIncludeVersion)) { 919 expected_error = "Unable to read sequence number."; 920 } else if (i < GetFecGroupOffset(kIncludeVersion)) { 921 expected_error = "Unable to read private flags."; 922 } else { 923 expected_error = "Unable to read first fec protected packet offset."; 924 } 925 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 926 } 927} 928 929TEST_P(QuicFramerTest, PacketHeaderWith4ByteSequenceNumber) { 930 QuicFramerPeer::SetLastSequenceNumber(&framer_, 931 GG_UINT64_C(0x123456789ABA)); 932 933 unsigned char packet[] = { 934 // public flags (8 byte connection_id and 4 byte sequence number) 935 0x2C, 936 // connection_id 937 0x10, 0x32, 0x54, 0x76, 938 0x98, 0xBA, 0xDC, 0xFE, 939 // packet sequence number 940 0xBC, 0x9A, 0x78, 0x56, 941 // private flags 942 0x00, 943 }; 944 945 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 946 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 947 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 948 ASSERT_TRUE(visitor_.header_.get()); 949 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 950 visitor_.header_->public_header.connection_id); 951 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 952 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 953 EXPECT_FALSE(visitor_.header_->fec_flag); 954 EXPECT_FALSE(visitor_.header_->entropy_flag); 955 EXPECT_EQ(0, visitor_.header_->entropy_hash); 956 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 957 visitor_.header_->packet_sequence_number); 958 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 959 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 960 961 // Now test framing boundaries. 962 for (size_t i = 0; 963 i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 964 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 965 ++i) { 966 string expected_error; 967 if (i < kConnectionIdOffset) { 968 expected_error = "Unable to read public flags."; 969 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 970 expected_error = "Unable to read ConnectionId."; 971 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 972 PACKET_4BYTE_SEQUENCE_NUMBER)) { 973 expected_error = "Unable to read sequence number."; 974 } else if (i < GetFecGroupOffset(!kIncludeVersion, 975 PACKET_4BYTE_SEQUENCE_NUMBER)) { 976 expected_error = "Unable to read private flags."; 977 } else { 978 expected_error = "Unable to read first fec protected packet offset."; 979 } 980 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 981 } 982} 983 984TEST_P(QuicFramerTest, PacketHeaderWith2ByteSequenceNumber) { 985 QuicFramerPeer::SetLastSequenceNumber(&framer_, 986 GG_UINT64_C(0x123456789ABA)); 987 988 unsigned char packet[] = { 989 // public flags (8 byte connection_id and 2 byte sequence number) 990 0x1C, 991 // connection_id 992 0x10, 0x32, 0x54, 0x76, 993 0x98, 0xBA, 0xDC, 0xFE, 994 // packet sequence number 995 0xBC, 0x9A, 996 // private flags 997 0x00, 998 }; 999 1000 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1001 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 1002 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 1003 ASSERT_TRUE(visitor_.header_.get()); 1004 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 1005 visitor_.header_->public_header.connection_id); 1006 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 1007 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 1008 EXPECT_FALSE(visitor_.header_->fec_flag); 1009 EXPECT_FALSE(visitor_.header_->entropy_flag); 1010 EXPECT_EQ(0, visitor_.header_->entropy_hash); 1011 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 1012 visitor_.header_->packet_sequence_number); 1013 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1014 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 1015 1016 // Now test framing boundaries. 1017 for (size_t i = 0; 1018 i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 1019 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 1020 ++i) { 1021 string expected_error; 1022 if (i < kConnectionIdOffset) { 1023 expected_error = "Unable to read public flags."; 1024 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 1025 expected_error = "Unable to read ConnectionId."; 1026 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 1027 PACKET_2BYTE_SEQUENCE_NUMBER)) { 1028 expected_error = "Unable to read sequence number."; 1029 } else if (i < GetFecGroupOffset(!kIncludeVersion, 1030 PACKET_2BYTE_SEQUENCE_NUMBER)) { 1031 expected_error = "Unable to read private flags."; 1032 } else { 1033 expected_error = "Unable to read first fec protected packet offset."; 1034 } 1035 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 1036 } 1037} 1038 1039TEST_P(QuicFramerTest, PacketHeaderWith1ByteSequenceNumber) { 1040 QuicFramerPeer::SetLastSequenceNumber(&framer_, 1041 GG_UINT64_C(0x123456789ABA)); 1042 1043 unsigned char packet[] = { 1044 // public flags (8 byte connection_id and 1 byte sequence number) 1045 0x0C, 1046 // connection_id 1047 0x10, 0x32, 0x54, 0x76, 1048 0x98, 0xBA, 0xDC, 0xFE, 1049 // packet sequence number 1050 0xBC, 1051 // private flags 1052 0x00, 1053 }; 1054 1055 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1056 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 1057 EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error()); 1058 ASSERT_TRUE(visitor_.header_.get()); 1059 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 1060 visitor_.header_->public_header.connection_id); 1061 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 1062 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 1063 EXPECT_FALSE(visitor_.header_->fec_flag); 1064 EXPECT_FALSE(visitor_.header_->entropy_flag); 1065 EXPECT_EQ(0, visitor_.header_->entropy_hash); 1066 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 1067 visitor_.header_->packet_sequence_number); 1068 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1069 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 1070 1071 // Now test framing boundaries. 1072 for (size_t i = 0; 1073 i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 1074 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 1075 ++i) { 1076 string expected_error; 1077 if (i < kConnectionIdOffset) { 1078 expected_error = "Unable to read public flags."; 1079 } else if (i < GetSequenceNumberOffset(!kIncludeVersion)) { 1080 expected_error = "Unable to read ConnectionId."; 1081 } else if (i < GetPrivateFlagsOffset(!kIncludeVersion, 1082 PACKET_1BYTE_SEQUENCE_NUMBER)) { 1083 expected_error = "Unable to read sequence number."; 1084 } else if (i < GetFecGroupOffset(!kIncludeVersion, 1085 PACKET_1BYTE_SEQUENCE_NUMBER)) { 1086 expected_error = "Unable to read private flags."; 1087 } else { 1088 expected_error = "Unable to read first fec protected packet offset."; 1089 } 1090 CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER); 1091 } 1092} 1093 1094TEST_P(QuicFramerTest, InvalidPublicFlag) { 1095 unsigned char packet[] = { 1096 // public flags: all flags set but the public reset flag and version flag. 1097 0xFC, 1098 // connection_id 1099 0x10, 0x32, 0x54, 0x76, 1100 0x98, 0xBA, 0xDC, 0xFE, 1101 // packet sequence number 1102 0xBC, 0x9A, 0x78, 0x56, 1103 0x34, 0x12, 1104 // private flags 1105 0x00, 1106 1107 // frame type (padding) 1108 0x00, 1109 0x00, 0x00, 0x00, 0x00 1110 }; 1111 CheckProcessingFails(packet, 1112 arraysize(packet), 1113 "Illegal public flags value.", 1114 QUIC_INVALID_PACKET_HEADER); 1115 1116 // Now turn off validation. 1117 framer_.set_validate_flags(false); 1118 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1119 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1120}; 1121 1122TEST_P(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) { 1123 unsigned char packet[] = { 1124 // public flags (8 byte connection_id and version flag and an unknown flag) 1125 0x4D, 1126 // connection_id 1127 0x10, 0x32, 0x54, 0x76, 1128 0x98, 0xBA, 0xDC, 0xFE, 1129 // version tag 1130 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 1131 // packet sequence number 1132 0xBC, 0x9A, 0x78, 0x56, 1133 0x34, 0x12, 1134 // private flags 1135 0x00, 1136 1137 // frame type (padding) 1138 0x00, 1139 0x00, 0x00, 0x00, 0x00 1140 }; 1141 CheckProcessingFails(packet, 1142 arraysize(packet), 1143 "Illegal public flags value.", 1144 QUIC_INVALID_PACKET_HEADER); 1145}; 1146 1147TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) { 1148 unsigned char packet[] = { 1149 // public flags (8 byte connection_id, version flag and an unknown flag) 1150 0x7D, 1151 // connection_id 1152 0x10, 0x32, 0x54, 0x76, 1153 0x98, 0xBA, 0xDC, 0xFE, 1154 // version tag 1155 'Q', '0', '0', '0', 1156 // packet sequence number 1157 0xBC, 0x9A, 0x78, 0x56, 1158 0x34, 0x12, 1159 // private flags 1160 0x00, 1161 1162 // frame type (padding frame) 1163 0x00, 1164 0x00, 0x00, 0x00, 0x00 1165 }; 1166 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1167 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1168 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1169 ASSERT_TRUE(visitor_.header_.get()); 1170 EXPECT_EQ(0, visitor_.frame_count_); 1171 EXPECT_EQ(1, visitor_.version_mismatch_); 1172}; 1173 1174TEST_P(QuicFramerTest, InvalidPrivateFlag) { 1175 unsigned char packet[] = { 1176 // public flags (8 byte connection_id) 1177 0x3C, 1178 // connection_id 1179 0x10, 0x32, 0x54, 0x76, 1180 0x98, 0xBA, 0xDC, 0xFE, 1181 // packet sequence number 1182 0xBC, 0x9A, 0x78, 0x56, 1183 0x34, 0x12, 1184 // private flags 1185 0x10, 1186 1187 // frame type (padding) 1188 0x00, 1189 0x00, 0x00, 0x00, 0x00 1190 }; 1191 CheckProcessingFails(packet, 1192 arraysize(packet), 1193 "Illegal private flags value.", 1194 QUIC_INVALID_PACKET_HEADER); 1195}; 1196 1197TEST_P(QuicFramerTest, InvalidFECGroupOffset) { 1198 unsigned char packet[] = { 1199 // public flags (8 byte connection_id) 1200 0x3C, 1201 // connection_id 1202 0x10, 0x32, 0x54, 0x76, 1203 0x98, 0xBA, 0xDC, 0xFE, 1204 // packet sequence number 1205 0x01, 0x00, 0x00, 0x00, 1206 0x00, 0x00, 1207 // private flags (fec group) 1208 0x02, 1209 // first fec protected packet offset 1210 0x10 1211 }; 1212 CheckProcessingFails(packet, 1213 arraysize(packet), 1214 "First fec protected packet offset must be less " 1215 "than the sequence number.", 1216 QUIC_INVALID_PACKET_HEADER); 1217}; 1218 1219TEST_P(QuicFramerTest, PaddingFrame) { 1220 unsigned char packet[] = { 1221 // public flags (8 byte connection_id) 1222 0x3C, 1223 // connection_id 1224 0x10, 0x32, 0x54, 0x76, 1225 0x98, 0xBA, 0xDC, 0xFE, 1226 // packet sequence number 1227 0xBC, 0x9A, 0x78, 0x56, 1228 0x34, 0x12, 1229 // private flags 1230 0x00, 1231 1232 // frame type (padding frame) 1233 0x00, 1234 // Ignored data (which in this case is a stream frame) 1235 // frame type (stream frame with fin) 1236 0xFF, 1237 // stream id 1238 0x04, 0x03, 0x02, 0x01, 1239 // offset 1240 0x54, 0x76, 0x10, 0x32, 1241 0xDC, 0xFE, 0x98, 0xBA, 1242 // data length 1243 0x0c, 0x00, 1244 // data 1245 'h', 'e', 'l', 'l', 1246 'o', ' ', 'w', 'o', 1247 'r', 'l', 'd', '!', 1248 }; 1249 1250 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1251 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1252 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1253 ASSERT_TRUE(visitor_.header_.get()); 1254 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1255 1256 ASSERT_EQ(0u, visitor_.stream_frames_.size()); 1257 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1258 // A packet with no frames is not acceptable. 1259 CheckProcessingFails( 1260 packet, 1261 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 1262 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1263 "Packet has no frames.", QUIC_MISSING_PAYLOAD); 1264} 1265 1266TEST_P(QuicFramerTest, StreamFrame) { 1267 unsigned char packet[] = { 1268 // public flags (8 byte connection_id) 1269 0x3C, 1270 // connection_id 1271 0x10, 0x32, 0x54, 0x76, 1272 0x98, 0xBA, 0xDC, 0xFE, 1273 // packet sequence number 1274 0xBC, 0x9A, 0x78, 0x56, 1275 0x34, 0x12, 1276 // private flags 1277 0x00, 1278 1279 // frame type (stream frame with fin) 1280 0xFF, 1281 // stream id 1282 0x04, 0x03, 0x02, 0x01, 1283 // offset 1284 0x54, 0x76, 0x10, 0x32, 1285 0xDC, 0xFE, 0x98, 0xBA, 1286 // data length 1287 0x0c, 0x00, 1288 // data 1289 'h', 'e', 'l', 'l', 1290 'o', ' ', 'w', 'o', 1291 'r', 'l', 'd', '!', 1292 }; 1293 1294 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1295 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1296 1297 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1298 ASSERT_TRUE(visitor_.header_.get()); 1299 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1300 1301 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1302 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1303 EXPECT_EQ(static_cast<uint64>(0x01020304), 1304 visitor_.stream_frames_[0]->stream_id); 1305 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1306 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1307 visitor_.stream_frames_[0]->offset); 1308 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1309 1310 // Now test framing boundaries. 1311 CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, !kIncludeVersion); 1312} 1313 1314TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) { 1315 unsigned char packet[] = { 1316 // public flags (8 byte connection_id) 1317 0x3C, 1318 // connection_id 1319 0x10, 0x32, 0x54, 0x76, 1320 0x98, 0xBA, 0xDC, 0xFE, 1321 // packet sequence number 1322 0xBC, 0x9A, 0x78, 0x56, 1323 0x34, 0x12, 1324 // private flags 1325 0x00, 1326 1327 // frame type (stream frame with fin) 1328 0xFE, 1329 // stream id 1330 0x04, 0x03, 0x02, 1331 // offset 1332 0x54, 0x76, 0x10, 0x32, 1333 0xDC, 0xFE, 0x98, 0xBA, 1334 // data length 1335 0x0c, 0x00, 1336 // data 1337 'h', 'e', 'l', 'l', 1338 'o', ' ', 'w', 'o', 1339 'r', 'l', 'd', '!', 1340 }; 1341 1342 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1343 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1344 1345 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1346 ASSERT_TRUE(visitor_.header_.get()); 1347 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1348 1349 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1350 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1351 EXPECT_EQ(GG_UINT64_C(0x00020304), 1352 visitor_.stream_frames_[0]->stream_id); 1353 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1354 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1355 visitor_.stream_frames_[0]->offset); 1356 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1357 1358 // Now test framing boundaries. 1359 const size_t stream_id_size = 3; 1360 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion); 1361} 1362 1363TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) { 1364 unsigned char packet[] = { 1365 // public flags (8 byte connection_id) 1366 0x3C, 1367 // connection_id 1368 0x10, 0x32, 0x54, 0x76, 1369 0x98, 0xBA, 0xDC, 0xFE, 1370 // packet sequence number 1371 0xBC, 0x9A, 0x78, 0x56, 1372 0x34, 0x12, 1373 // private flags 1374 0x00, 1375 1376 // frame type (stream frame with fin) 1377 0xFD, 1378 // stream id 1379 0x04, 0x03, 1380 // offset 1381 0x54, 0x76, 0x10, 0x32, 1382 0xDC, 0xFE, 0x98, 0xBA, 1383 // data length 1384 0x0c, 0x00, 1385 // data 1386 'h', 'e', 'l', 'l', 1387 'o', ' ', 'w', 'o', 1388 'r', 'l', 'd', '!', 1389 }; 1390 1391 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1392 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1393 1394 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1395 ASSERT_TRUE(visitor_.header_.get()); 1396 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1397 1398 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1399 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1400 EXPECT_EQ(static_cast<uint64>(0x00000304), 1401 visitor_.stream_frames_[0]->stream_id); 1402 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1403 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1404 visitor_.stream_frames_[0]->offset); 1405 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1406 1407 // Now test framing boundaries. 1408 const size_t stream_id_size = 2; 1409 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion); 1410} 1411 1412TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) { 1413 unsigned char packet[] = { 1414 // public flags (8 byte connection_id) 1415 0x3C, 1416 // connection_id 1417 0x10, 0x32, 0x54, 0x76, 1418 0x98, 0xBA, 0xDC, 0xFE, 1419 // packet sequence number 1420 0xBC, 0x9A, 0x78, 0x56, 1421 0x34, 0x12, 1422 // private flags 1423 0x00, 1424 1425 // frame type (stream frame with fin) 1426 0xFC, 1427 // stream id 1428 0x04, 1429 // offset 1430 0x54, 0x76, 0x10, 0x32, 1431 0xDC, 0xFE, 0x98, 0xBA, 1432 // data length 1433 0x0c, 0x00, 1434 // data 1435 'h', 'e', 'l', 'l', 1436 'o', ' ', 'w', 'o', 1437 'r', 'l', 'd', '!', 1438 }; 1439 1440 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1441 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1442 1443 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1444 ASSERT_TRUE(visitor_.header_.get()); 1445 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1446 1447 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1448 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1449 EXPECT_EQ(static_cast<uint64>(0x00000004), 1450 visitor_.stream_frames_[0]->stream_id); 1451 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1452 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1453 visitor_.stream_frames_[0]->offset); 1454 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1455 1456 // Now test framing boundaries. 1457 const size_t stream_id_size = 1; 1458 CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion); 1459} 1460 1461TEST_P(QuicFramerTest, StreamFrameWithVersion) { 1462 unsigned char packet[] = { 1463 // public flags (version, 8 byte connection_id) 1464 0x3D, 1465 // connection_id 1466 0x10, 0x32, 0x54, 0x76, 1467 0x98, 0xBA, 0xDC, 0xFE, 1468 // version tag 1469 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 1470 // packet sequence number 1471 0xBC, 0x9A, 0x78, 0x56, 1472 0x34, 0x12, 1473 // private flags 1474 0x00, 1475 1476 // frame type (stream frame with fin) 1477 0xFF, 1478 // stream id 1479 0x04, 0x03, 0x02, 0x01, 1480 // offset 1481 0x54, 0x76, 0x10, 0x32, 1482 0xDC, 0xFE, 0x98, 0xBA, 1483 // data length 1484 0x0c, 0x00, 1485 // data 1486 'h', 'e', 'l', 'l', 1487 'o', ' ', 'w', 'o', 1488 'r', 'l', 'd', '!', 1489 }; 1490 1491 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1492 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1493 1494 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1495 ASSERT_TRUE(visitor_.header_.get()); 1496 EXPECT_TRUE(visitor_.header_->public_header.version_flag); 1497 EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]); 1498 EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion)); 1499 1500 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1501 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1502 EXPECT_EQ(static_cast<uint64>(0x01020304), 1503 visitor_.stream_frames_[0]->stream_id); 1504 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1505 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1506 visitor_.stream_frames_[0]->offset); 1507 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1508 1509 // Now test framing boundaries. 1510 CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, kIncludeVersion); 1511} 1512 1513TEST_P(QuicFramerTest, RejectPacket) { 1514 visitor_.accept_packet_ = false; 1515 1516 unsigned char packet[] = { 1517 // public flags (8 byte connection_id) 1518 0x3C, 1519 // connection_id 1520 0x10, 0x32, 0x54, 0x76, 1521 0x98, 0xBA, 0xDC, 0xFE, 1522 // packet sequence number 1523 0xBC, 0x9A, 0x78, 0x56, 1524 0x34, 0x12, 1525 // private flags 1526 0x00, 1527 1528 // frame type (stream frame with fin) 1529 0xFF, 1530 // stream id 1531 0x04, 0x03, 0x02, 0x01, 1532 // offset 1533 0x54, 0x76, 0x10, 0x32, 1534 0xDC, 0xFE, 0x98, 0xBA, 1535 // data length 1536 0x0c, 0x00, 1537 // data 1538 'h', 'e', 'l', 'l', 1539 'o', ' ', 'w', 'o', 1540 'r', 'l', 'd', '!', 1541 }; 1542 1543 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1544 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1545 1546 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1547 ASSERT_TRUE(visitor_.header_.get()); 1548 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1549 1550 ASSERT_EQ(0u, visitor_.stream_frames_.size()); 1551 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1552} 1553 1554TEST_P(QuicFramerTest, RejectPublicHeader) { 1555 visitor_.accept_public_header_ = false; 1556 1557 unsigned char packet[] = { 1558 // public flags (8 byte connection_id) 1559 0x3C, 1560 // connection_id 1561 0x10, 0x32, 0x54, 0x76, 1562 0x98, 0xBA, 0xDC, 0xFE, 1563 }; 1564 1565 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1566 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1567 1568 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1569 ASSERT_TRUE(visitor_.public_header_.get()); 1570 ASSERT_FALSE(visitor_.header_.get()); 1571} 1572 1573TEST_P(QuicFramerTest, RevivedStreamFrame) { 1574 unsigned char payload[] = { 1575 // frame type (stream frame with fin) 1576 0xFF, 1577 // stream id 1578 0x04, 0x03, 0x02, 0x01, 1579 // offset 1580 0x54, 0x76, 0x10, 0x32, 1581 0xDC, 0xFE, 0x98, 0xBA, 1582 // data length 1583 0x0c, 0x00, 1584 // data 1585 'h', 'e', 'l', 'l', 1586 'o', ' ', 'w', 'o', 1587 'r', 'l', 'd', '!', 1588 }; 1589 1590 QuicPacketHeader header; 1591 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 1592 header.public_header.reset_flag = false; 1593 header.public_header.version_flag = false; 1594 header.fec_flag = true; 1595 header.entropy_flag = true; 1596 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1597 header.fec_group = 0; 1598 1599 // Do not encrypt the payload because the revived payload is post-encryption. 1600 EXPECT_TRUE(framer_.ProcessRevivedPacket(&header, 1601 StringPiece(AsChars(payload), 1602 arraysize(payload)))); 1603 1604 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1605 ASSERT_EQ(1, visitor_.revived_packets_); 1606 ASSERT_TRUE(visitor_.header_.get()); 1607 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 1608 visitor_.header_->public_header.connection_id); 1609 EXPECT_FALSE(visitor_.header_->public_header.reset_flag); 1610 EXPECT_FALSE(visitor_.header_->public_header.version_flag); 1611 EXPECT_TRUE(visitor_.header_->fec_flag); 1612 EXPECT_TRUE(visitor_.header_->entropy_flag); 1613 EXPECT_EQ(1 << (header.packet_sequence_number % 8), 1614 visitor_.header_->entropy_hash); 1615 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 1616 visitor_.header_->packet_sequence_number); 1617 EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1618 EXPECT_EQ(0x00u, visitor_.header_->fec_group); 1619 1620 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1621 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1622 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 1623 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1624 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1625 visitor_.stream_frames_[0]->offset); 1626 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1627} 1628 1629TEST_P(QuicFramerTest, StreamFrameInFecGroup) { 1630 unsigned char packet[] = { 1631 // public flags (8 byte connection_id) 1632 0x3C, 1633 // connection_id 1634 0x10, 0x32, 0x54, 0x76, 1635 0x98, 0xBA, 0xDC, 0xFE, 1636 // packet sequence number 1637 0xBC, 0x9A, 0x78, 0x56, 1638 0x12, 0x34, 1639 // private flags (fec group) 1640 0x02, 1641 // first fec protected packet offset 1642 0x02, 1643 1644 // frame type (stream frame with fin) 1645 0xFF, 1646 // stream id 1647 0x04, 0x03, 0x02, 0x01, 1648 // offset 1649 0x54, 0x76, 0x10, 0x32, 1650 0xDC, 0xFE, 0x98, 0xBA, 1651 // data length 1652 0x0c, 0x00, 1653 // data 1654 'h', 'e', 'l', 'l', 1655 'o', ' ', 'w', 'o', 1656 'r', 'l', 'd', '!', 1657 }; 1658 1659 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1660 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1661 1662 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1663 ASSERT_TRUE(visitor_.header_.get()); 1664 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1665 EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group); 1666 EXPECT_EQ(GG_UINT64_C(0x341256789ABA), 1667 visitor_.header_->fec_group); 1668 const size_t fec_offset = 1669 GetStartOfFecProtectedData(PACKET_8BYTE_CONNECTION_ID, 1670 !kIncludeVersion, 1671 PACKET_6BYTE_SEQUENCE_NUMBER); 1672 EXPECT_EQ( 1673 string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset), 1674 visitor_.fec_protected_payload_); 1675 1676 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 1677 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1678 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 1679 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 1680 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1681 visitor_.stream_frames_[0]->offset); 1682 CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]); 1683} 1684 1685TEST_P(QuicFramerTest, AckFramev22) { 1686 if (version_ > QUIC_VERSION_22) { 1687 return; 1688 } 1689 unsigned char packet[] = { 1690 // public flags (8 byte connection_id) 1691 0x3C, 1692 // connection_id 1693 0x10, 0x32, 0x54, 0x76, 1694 0x98, 0xBA, 0xDC, 0xFE, 1695 // packet sequence number 1696 0xA8, 0x9A, 0x78, 0x56, 1697 0x34, 0x12, 1698 // private flags (entropy) 1699 0x01, 1700 1701 // frame type (ack frame) 1702 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 1703 0x6C, 1704 // entropy hash of all received packets. 1705 0xBA, 1706 // largest observed packet sequence number 1707 0xBF, 0x9A, 0x78, 0x56, 1708 0x34, 0x12, 1709 // Zero delta time. 1710 0x0, 0x0, 1711 // num missing packets 1712 0x01, 1713 // missing packet delta 1714 0x01, 1715 // 0 more missing packets in range. 1716 0x00, 1717 // Number of revived packets. 1718 0x00, 1719 }; 1720 1721 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1722 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1723 1724 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1725 ASSERT_TRUE(visitor_.header_.get()); 1726 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1727 1728 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1729 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 1730 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 1731 EXPECT_EQ(0xBA, frame.entropy_hash); 1732 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 1733 ASSERT_EQ(1u, frame.missing_packets.size()); 1734 SequenceNumberSet::const_iterator missing_iter = 1735 frame.missing_packets.begin(); 1736 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 1737 1738 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 1739 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 1740 kQuicEntropyHashSize; 1741 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 1742 PACKET_6BYTE_SEQUENCE_NUMBER; 1743 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset + 1744 kQuicDeltaTimeLargestObservedSize; 1745 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 1746 kNumberOfNackRangesSize; 1747 const size_t kMissingPacketsRange = kMissingPacketsOffset + 1748 PACKET_1BYTE_SEQUENCE_NUMBER; 1749 const size_t kRevivedPacketsLength = kMissingPacketsRange + 1750 PACKET_1BYTE_SEQUENCE_NUMBER; 1751 // Now test framing boundaries. 1752 const size_t ack_frame_size = kRevivedPacketsLength + 1753 PACKET_1BYTE_SEQUENCE_NUMBER; 1754 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 1755 string expected_error; 1756 if (i < kLargestObservedOffset) { 1757 expected_error = "Unable to read entropy hash for received packets."; 1758 } else if (i < kMissingDeltaTimeOffset) { 1759 expected_error = "Unable to read largest observed."; 1760 } else if (i < kNumMissingPacketOffset) { 1761 expected_error = "Unable to read delta time largest observed."; 1762 } else if (i < kMissingPacketsOffset) { 1763 expected_error = "Unable to read num missing packet ranges."; 1764 } else if (i < kMissingPacketsRange) { 1765 expected_error = "Unable to read missing sequence number delta."; 1766 } else if (i < kRevivedPacketsLength) { 1767 expected_error = "Unable to read missing sequence number range."; 1768 } else { 1769 expected_error = "Unable to read num revived packets."; 1770 } 1771 CheckProcessingFails( 1772 packet, 1773 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 1774 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1775 expected_error, QUIC_INVALID_ACK_DATA); 1776 } 1777} 1778 1779 1780TEST_P(QuicFramerTest, AckFrameTwoTimestamp) { 1781 if (version_ <= QUIC_VERSION_22) { 1782 return; 1783 } 1784 unsigned char packet[] = { 1785 // public flags (8 byte connection_id) 1786 0x3C, 1787 // connection_id 1788 0x10, 0x32, 0x54, 0x76, 1789 0x98, 0xBA, 0xDC, 0xFE, 1790 // packet sequence number 1791 0xA8, 0x9A, 0x78, 0x56, 1792 0x34, 0x12, 1793 // private flags (entropy) 1794 0x01, 1795 1796 // frame type (ack frame) 1797 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 1798 0x6C, 1799 // entropy hash of all received packets. 1800 0xBA, 1801 // largest observed packet sequence number 1802 0xBF, 0x9A, 0x78, 0x56, 1803 0x34, 0x12, 1804 // Zero delta time. 1805 0x0, 0x0, 1806 // Number of timestamps. 1807 0x02, 1808 // Delta from largest observed. 1809 0x01, 1810 // Delta time. 1811 0x10, 0x32, 0x54, 0x76, 1812 // Delta from largest observed. 1813 0x02, 1814 // Delta time. 1815 0x10, 0x32, 1816 // num missing packets 1817 0x01, 1818 // missing packet delta 1819 0x01, 1820 // 0 more missing packets in range. 1821 0x00, 1822 // Number of revived packets. 1823 0x00, 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_.ack_frames_.size()); 1835 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 1836 EXPECT_EQ(0xBA, frame.entropy_hash); 1837 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 1838 ASSERT_EQ(1u, frame.missing_packets.size()); 1839 ASSERT_EQ(2u, frame.received_packet_times.size()); 1840 SequenceNumberSet::const_iterator missing_iter = 1841 frame.missing_packets.begin(); 1842 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 1843 1844 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 1845 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 1846 kQuicEntropyHashSize; 1847 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 1848 PACKET_6BYTE_SEQUENCE_NUMBER; 1849 const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset + 1850 kQuicDeltaTimeLargestObservedSize; 1851 const size_t kTimestampDeltaLargestObserved1 = kNumTimestampsOffset + 1852 kQuicNumTimestampsSize; 1853 const size_t kTimestampTimeDeltaLargestObserved1 = 1854 kTimestampDeltaLargestObserved1 + 1; 1855 const size_t kTimestampDeltaLargestObserved2 = 1856 kTimestampTimeDeltaLargestObserved1 + 4; 1857 const size_t kTimestampTimeDeltaLargestObserved2 = 1858 kTimestampDeltaLargestObserved2 + 1; 1859 const size_t kNumMissingPacketOffset = 1860 kTimestampTimeDeltaLargestObserved2 + 2; 1861 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 1862 kNumberOfNackRangesSize; 1863 const size_t kMissingPacketsRange = kMissingPacketsOffset + 1864 PACKET_1BYTE_SEQUENCE_NUMBER; 1865 const size_t kRevivedPacketsLength = kMissingPacketsRange + 1866 PACKET_1BYTE_SEQUENCE_NUMBER; 1867 // Now test framing boundaries. 1868 const size_t ack_frame_size = kRevivedPacketsLength + 1869 PACKET_1BYTE_SEQUENCE_NUMBER; 1870 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 1871 string expected_error; 1872 if (i < kLargestObservedOffset) { 1873 expected_error = "Unable to read entropy hash for received packets."; 1874 } else if (i < kMissingDeltaTimeOffset) { 1875 expected_error = "Unable to read largest observed."; 1876 } else if (i < kNumTimestampsOffset) { 1877 expected_error = "Unable to read delta time largest observed."; 1878 } else if (i < kTimestampDeltaLargestObserved1) { 1879 expected_error = "Unable to read num received packets."; 1880 } else if (i < kTimestampTimeDeltaLargestObserved1) { 1881 expected_error = "Unable to read sequence delta in received packets."; 1882 } else if (i < kTimestampDeltaLargestObserved2) { 1883 expected_error = "Unable to read time delta in received packets."; 1884 } else if (i < kTimestampTimeDeltaLargestObserved2) { 1885 expected_error = "Unable to read sequence delta in received packets."; 1886 } else if (i < kNumMissingPacketOffset) { 1887 expected_error = 1888 "Unable to read incremental time delta in received packets."; 1889 } else if (i < kMissingPacketsOffset) { 1890 expected_error = "Unable to read num missing packet ranges."; 1891 } else if (i < kMissingPacketsRange) { 1892 expected_error = "Unable to read missing sequence number delta."; 1893 } else if (i < kRevivedPacketsLength) { 1894 expected_error = "Unable to read missing sequence number range."; 1895 } else { 1896 expected_error = "Unable to read num revived packets."; 1897 } 1898 CheckProcessingFails( 1899 packet, 1900 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 1901 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 1902 expected_error, QUIC_INVALID_ACK_DATA); 1903 } 1904} 1905 1906 1907TEST_P(QuicFramerTest, AckFrameOneTimestamp) { 1908 if (version_ <= QUIC_VERSION_22) { 1909 return; 1910 } 1911 unsigned char packet[] = { 1912 // public flags (8 byte connection_id) 1913 0x3C, 1914 // connection_id 1915 0x10, 0x32, 0x54, 0x76, 1916 0x98, 0xBA, 0xDC, 0xFE, 1917 // packet sequence number 1918 0xA8, 0x9A, 0x78, 0x56, 1919 0x34, 0x12, 1920 // private flags (entropy) 1921 0x01, 1922 1923 // frame type (ack frame) 1924 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 1925 0x6C, 1926 // entropy hash of all received packets. 1927 0xBA, 1928 // largest observed packet sequence number 1929 0xBF, 0x9A, 0x78, 0x56, 1930 0x34, 0x12, 1931 // Zero delta time. 1932 0x0, 0x0, 1933 // Number of timestamps. 1934 0x01, 1935 // Delta from largest observed. 1936 0x01, 1937 // Delta time. 1938 0x10, 0x32, 0x54, 0x76, 1939 // num missing packets 1940 0x01, 1941 // missing packet delta 1942 0x01, 1943 // 0 more missing packets in range. 1944 0x00, 1945 // Number of revived packets. 1946 0x00, 1947 }; 1948 1949 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1950 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 1951 1952 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1953 ASSERT_TRUE(visitor_.header_.get()); 1954 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 1955 1956 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1957 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 1958 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 1959 EXPECT_EQ(0xBA, frame.entropy_hash); 1960 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 1961 ASSERT_EQ(1u, frame.missing_packets.size()); 1962 ASSERT_EQ(1u, frame.received_packet_times.size()); 1963 SequenceNumberSet::const_iterator missing_iter = 1964 frame.missing_packets.begin(); 1965 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 1966 1967 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 1968 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 1969 kQuicEntropyHashSize; 1970 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 1971 PACKET_6BYTE_SEQUENCE_NUMBER; 1972 const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset + 1973 kQuicDeltaTimeLargestObservedSize; 1974 const size_t kTimestampDeltaLargestObserved = kNumTimestampsOffset + 1975 kQuicNumTimestampsSize; 1976 const size_t kTimestampTimeDeltaLargestObserved = 1977 kTimestampDeltaLargestObserved + 1; 1978 const size_t kNumMissingPacketOffset = kTimestampTimeDeltaLargestObserved + 4; 1979 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 1980 kNumberOfNackRangesSize; 1981 const size_t kMissingPacketsRange = kMissingPacketsOffset + 1982 PACKET_1BYTE_SEQUENCE_NUMBER; 1983 const size_t kRevivedPacketsLength = kMissingPacketsRange + 1984 PACKET_1BYTE_SEQUENCE_NUMBER; 1985 // Now test framing boundaries. 1986 const size_t ack_frame_size = kRevivedPacketsLength + 1987 PACKET_1BYTE_SEQUENCE_NUMBER; 1988 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 1989 string expected_error; 1990 if (i < kLargestObservedOffset) { 1991 expected_error = "Unable to read entropy hash for received packets."; 1992 } else if (i < kMissingDeltaTimeOffset) { 1993 expected_error = "Unable to read largest observed."; 1994 } else if (i < kNumTimestampsOffset) { 1995 expected_error = "Unable to read delta time largest observed."; 1996 } else if (i < kTimestampDeltaLargestObserved) { 1997 expected_error = "Unable to read num received packets."; 1998 } else if (i < kTimestampTimeDeltaLargestObserved) { 1999 expected_error = "Unable to read sequence delta in received packets."; 2000 } else if (i < kNumMissingPacketOffset) { 2001 expected_error = "Unable to read time delta in received packets."; 2002 } else if (i < kMissingPacketsOffset) { 2003 expected_error = "Unable to read num missing packet ranges."; 2004 } else if (i < kMissingPacketsRange) { 2005 expected_error = "Unable to read missing sequence number delta."; 2006 } else if (i < kRevivedPacketsLength) { 2007 expected_error = "Unable to read missing sequence number range."; 2008 } else { 2009 expected_error = "Unable to read num revived packets."; 2010 } 2011 CheckProcessingFails( 2012 packet, 2013 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2014 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2015 expected_error, QUIC_INVALID_ACK_DATA); 2016 } 2017} 2018 2019 2020TEST_P(QuicFramerTest, AckFrame) { 2021 if (version_ <= QUIC_VERSION_22) { 2022 return; 2023 } 2024 unsigned char packet[] = { 2025 // public flags (8 byte connection_id) 2026 0x3C, 2027 // connection_id 2028 0x10, 0x32, 0x54, 0x76, 2029 0x98, 0xBA, 0xDC, 0xFE, 2030 // packet sequence number 2031 0xA8, 0x9A, 0x78, 0x56, 2032 0x34, 0x12, 2033 // private flags (entropy) 2034 0x01, 2035 2036 // frame type (ack frame) 2037 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2038 0x6C, 2039 // entropy hash of all received packets. 2040 0xBA, 2041 // largest observed packet sequence number 2042 0xBF, 0x9A, 0x78, 0x56, 2043 0x34, 0x12, 2044 // Zero delta time. 2045 0x0, 0x0, 2046 // Number of timestamps. 2047 0x00, 2048 // num missing packets 2049 0x01, 2050 // missing packet delta 2051 0x01, 2052 // 0 more missing packets in range. 2053 0x00, 2054 // Number of revived packets. 2055 0x00, 2056 }; 2057 2058 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2059 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2060 2061 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2062 ASSERT_TRUE(visitor_.header_.get()); 2063 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2064 2065 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2066 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2067 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 2068 EXPECT_EQ(0xBA, frame.entropy_hash); 2069 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 2070 ASSERT_EQ(1u, frame.missing_packets.size()); 2071 SequenceNumberSet::const_iterator missing_iter = 2072 frame.missing_packets.begin(); 2073 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 2074 2075 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 2076 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 2077 kQuicEntropyHashSize; 2078 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 2079 PACKET_6BYTE_SEQUENCE_NUMBER; 2080 const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset + 2081 kQuicDeltaTimeLargestObservedSize; 2082 const size_t kNumMissingPacketOffset = kNumTimestampsOffset + 2083 kQuicNumTimestampsSize; 2084 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 2085 kNumberOfNackRangesSize; 2086 const size_t kMissingPacketsRange = kMissingPacketsOffset + 2087 PACKET_1BYTE_SEQUENCE_NUMBER; 2088 const size_t kRevivedPacketsLength = kMissingPacketsRange + 2089 PACKET_1BYTE_SEQUENCE_NUMBER; 2090 // Now test framing boundaries. 2091 const size_t ack_frame_size = kRevivedPacketsLength + 2092 PACKET_1BYTE_SEQUENCE_NUMBER; 2093 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 2094 string expected_error; 2095 if (i < kLargestObservedOffset) { 2096 expected_error = "Unable to read entropy hash for received packets."; 2097 } else if (i < kMissingDeltaTimeOffset) { 2098 expected_error = "Unable to read largest observed."; 2099 } else if (i < kNumTimestampsOffset) { 2100 expected_error = "Unable to read delta time largest observed."; 2101 } else if (i < kNumMissingPacketOffset) { 2102 expected_error = "Unable to read num received packets."; 2103 } else if (i < kMissingPacketsOffset) { 2104 expected_error = "Unable to read num missing packet ranges."; 2105 } else if (i < kMissingPacketsRange) { 2106 expected_error = "Unable to read missing sequence number delta."; 2107 } else if (i < kRevivedPacketsLength) { 2108 expected_error = "Unable to read missing sequence number range."; 2109 } else { 2110 expected_error = "Unable to read num revived packets."; 2111 } 2112 CheckProcessingFails( 2113 packet, 2114 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2115 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2116 expected_error, QUIC_INVALID_ACK_DATA); 2117 } 2118} 2119 2120TEST_P(QuicFramerTest, AckFrameRevivedPackets) { 2121 if (version_ <= QUIC_VERSION_22) { 2122 return; 2123 } 2124 unsigned char packet[] = { 2125 // public flags (8 byte connection_id) 2126 0x3C, 2127 // connection_id 2128 0x10, 0x32, 0x54, 0x76, 2129 0x98, 0xBA, 0xDC, 0xFE, 2130 // packet sequence number 2131 0xA8, 0x9A, 0x78, 0x56, 2132 0x34, 0x12, 2133 // private flags (entropy) 2134 0x01, 2135 2136 // frame type (ack frame) 2137 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2138 0x6C, 2139 // entropy hash of all received packets. 2140 0xBA, 2141 // largest observed packet sequence number 2142 0xBF, 0x9A, 0x78, 0x56, 2143 0x34, 0x12, 2144 // Zero delta time. 2145 0x0, 0x0, 2146 // num received packets. 2147 0x00, 2148 // num missing packets 2149 0x01, 2150 // missing packet delta 2151 0x01, 2152 // 0 more missing packets in range. 2153 0x00, 2154 // Number of revived packets. 2155 0x01, 2156 // Revived packet sequence number. 2157 0xBE, 0x9A, 0x78, 0x56, 2158 0x34, 0x12, 2159 // Number of revived packets. 2160 0x00, 2161 }; 2162 2163 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2164 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2165 2166 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2167 ASSERT_TRUE(visitor_.header_.get()); 2168 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2169 2170 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2171 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2172 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 2173 EXPECT_EQ(0xBA, frame.entropy_hash); 2174 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 2175 ASSERT_EQ(1u, frame.missing_packets.size()); 2176 SequenceNumberSet::const_iterator missing_iter = 2177 frame.missing_packets.begin(); 2178 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 2179 2180 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 2181 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 2182 kQuicEntropyHashSize; 2183 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 2184 PACKET_6BYTE_SEQUENCE_NUMBER; 2185 const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset + 2186 kQuicDeltaTimeLargestObservedSize; 2187 const size_t kNumMissingPacketOffset = kNumTimestampsOffset + 2188 kQuicNumTimestampsSize; 2189 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 2190 kNumberOfNackRangesSize; 2191 const size_t kMissingPacketsRange = kMissingPacketsOffset + 2192 PACKET_1BYTE_SEQUENCE_NUMBER; 2193 const size_t kRevivedPacketsLength = kMissingPacketsRange + 2194 PACKET_1BYTE_SEQUENCE_NUMBER; 2195 const size_t kRevivedPacketSequenceNumberLength = kRevivedPacketsLength + 2196 PACKET_1BYTE_SEQUENCE_NUMBER; 2197 // Now test framing boundaries. 2198 const size_t ack_frame_size = kRevivedPacketSequenceNumberLength + 2199 PACKET_6BYTE_SEQUENCE_NUMBER; 2200 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 2201 string expected_error; 2202 if (i < kReceivedEntropyOffset) { 2203 expected_error = "Unable to read least unacked delta."; 2204 } else if (i < kLargestObservedOffset) { 2205 expected_error = "Unable to read entropy hash for received packets."; 2206 } else if (i < kMissingDeltaTimeOffset) { 2207 expected_error = "Unable to read largest observed."; 2208 } else if (i < kNumTimestampsOffset) { 2209 expected_error = "Unable to read delta time largest observed."; 2210 } else if (i < kNumMissingPacketOffset) { 2211 expected_error = "Unable to read num received packets."; 2212 } else if (i < kMissingPacketsOffset) { 2213 expected_error = "Unable to read num missing packet ranges."; 2214 } else if (i < kMissingPacketsRange) { 2215 expected_error = "Unable to read missing sequence number delta."; 2216 } else if (i < kRevivedPacketsLength) { 2217 expected_error = "Unable to read missing sequence number range."; 2218 } else if (i < kRevivedPacketSequenceNumberLength) { 2219 expected_error = "Unable to read num revived packets."; 2220 } else { 2221 expected_error = "Unable to read revived packet."; 2222 } 2223 CheckProcessingFails( 2224 packet, 2225 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2226 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2227 expected_error, QUIC_INVALID_ACK_DATA); 2228 } 2229} 2230 2231TEST_P(QuicFramerTest, AckFrameRevivedPacketsv22) { 2232 if (version_ > QUIC_VERSION_22) { 2233 return; 2234 } 2235 unsigned char packet[] = { 2236 // public flags (8 byte connection_id) 2237 0x3C, 2238 // connection_id 2239 0x10, 0x32, 0x54, 0x76, 2240 0x98, 0xBA, 0xDC, 0xFE, 2241 // packet sequence number 2242 0xA8, 0x9A, 0x78, 0x56, 2243 0x34, 0x12, 2244 // private flags (entropy) 2245 0x01, 2246 2247 // frame type (ack frame) 2248 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2249 0x6C, 2250 // entropy hash of all received packets. 2251 0xBA, 2252 // largest observed packet sequence number 2253 0xBF, 0x9A, 0x78, 0x56, 2254 0x34, 0x12, 2255 // Zero delta time. 2256 0x0, 0x0, 2257 // num missing packets 2258 0x01, 2259 // missing packet delta 2260 0x01, 2261 // 0 more missing packets in range. 2262 0x00, 2263 // Number of revived packets. 2264 0x01, 2265 // Revived packet sequence number. 2266 0xBE, 0x9A, 0x78, 0x56, 2267 0x34, 0x12, 2268 // Number of revived packets. 2269 0x00, 2270 }; 2271 2272 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2273 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2274 2275 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2276 ASSERT_TRUE(visitor_.header_.get()); 2277 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2278 2279 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2280 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2281 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 2282 EXPECT_EQ(0xBA, frame.entropy_hash); 2283 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame.largest_observed); 2284 ASSERT_EQ(1u, frame.missing_packets.size()); 2285 SequenceNumberSet::const_iterator missing_iter = 2286 frame.missing_packets.begin(); 2287 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *missing_iter); 2288 2289 const size_t kReceivedEntropyOffset = kQuicFrameTypeSize; 2290 const size_t kLargestObservedOffset = kReceivedEntropyOffset + 2291 kQuicEntropyHashSize; 2292 const size_t kMissingDeltaTimeOffset = kLargestObservedOffset + 2293 PACKET_6BYTE_SEQUENCE_NUMBER; 2294 const size_t kNumMissingPacketOffset = kMissingDeltaTimeOffset + 2295 kQuicDeltaTimeLargestObservedSize; 2296 const size_t kMissingPacketsOffset = kNumMissingPacketOffset + 2297 kNumberOfNackRangesSize; 2298 const size_t kMissingPacketsRange = kMissingPacketsOffset + 2299 PACKET_1BYTE_SEQUENCE_NUMBER; 2300 const size_t kRevivedPacketsLength = kMissingPacketsRange + 2301 PACKET_1BYTE_SEQUENCE_NUMBER; 2302 const size_t kRevivedPacketSequenceNumberLength = kRevivedPacketsLength + 2303 PACKET_1BYTE_SEQUENCE_NUMBER; 2304 // Now test framing boundaries. 2305 const size_t ack_frame_size = kRevivedPacketSequenceNumberLength + 2306 PACKET_6BYTE_SEQUENCE_NUMBER; 2307 for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) { 2308 string expected_error; 2309 if (i < kReceivedEntropyOffset) { 2310 expected_error = "Unable to read least unacked delta."; 2311 } else if (i < kLargestObservedOffset) { 2312 expected_error = "Unable to read entropy hash for received packets."; 2313 } else if (i < kMissingDeltaTimeOffset) { 2314 expected_error = "Unable to read largest observed."; 2315 } else if (i < kNumMissingPacketOffset) { 2316 expected_error = "Unable to read delta time largest observed."; 2317 } else if (i < kMissingPacketsOffset) { 2318 expected_error = "Unable to read num missing packet ranges."; 2319 } else if (i < kMissingPacketsRange) { 2320 expected_error = "Unable to read missing sequence number delta."; 2321 } else if (i < kRevivedPacketsLength) { 2322 expected_error = "Unable to read missing sequence number range."; 2323 } else if (i < kRevivedPacketSequenceNumberLength) { 2324 expected_error = "Unable to read num revived packets."; 2325 } else { 2326 expected_error = "Unable to read revived packet."; 2327 } 2328 CheckProcessingFails( 2329 packet, 2330 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2331 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2332 expected_error, QUIC_INVALID_ACK_DATA); 2333 } 2334} 2335 2336TEST_P(QuicFramerTest, AckFrameNoNacksv22) { 2337 if (version_ > QUIC_VERSION_22) { 2338 return; 2339 } 2340 unsigned char packet[] = { 2341 // public flags (8 byte connection_id) 2342 0x3C, 2343 // connection_id 2344 0x10, 0x32, 0x54, 0x76, 2345 0x98, 0xBA, 0xDC, 0xFE, 2346 // packet sequence number 2347 0xA8, 0x9A, 0x78, 0x56, 2348 0x34, 0x12, 2349 // private flags (entropy) 2350 0x01, 2351 2352 // frame type (ack frame) 2353 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta) 2354 0x4C, 2355 // entropy hash of all received packets. 2356 0xBA, 2357 // largest observed packet sequence number 2358 0xBF, 0x9A, 0x78, 0x56, 2359 0x34, 0x12, 2360 // Zero delta time. 2361 0x0, 0x0, 2362 }; 2363 2364 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2365 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2366 2367 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2368 ASSERT_TRUE(visitor_.header_.get()); 2369 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2370 2371 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2372 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2373 QuicAckFrame* frame = visitor_.ack_frames_[0]; 2374 EXPECT_EQ(0xBA, frame->entropy_hash); 2375 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame->largest_observed); 2376 ASSERT_EQ(0u, frame->missing_packets.size()); 2377 2378 // Verify that the packet re-serializes identically. 2379 QuicFrames frames; 2380 frames.push_back(QuicFrame(frame)); 2381 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); 2382 ASSERT_TRUE(data != NULL); 2383 2384 test::CompareCharArraysWithHexError("constructed packet", 2385 data->data(), data->length(), 2386 AsChars(packet), arraysize(packet)); 2387} 2388 2389TEST_P(QuicFramerTest, AckFrameNoNacks) { 2390 if (version_ <= QUIC_VERSION_22) { 2391 return; 2392 } 2393 unsigned char packet[] = { 2394 // public flags (8 byte connection_id) 2395 0x3C, 2396 // connection_id 2397 0x10, 0x32, 0x54, 0x76, 2398 0x98, 0xBA, 0xDC, 0xFE, 2399 // packet sequence number 2400 0xA8, 0x9A, 0x78, 0x56, 2401 0x34, 0x12, 2402 // private flags (entropy) 2403 0x01, 2404 2405 // frame type (ack frame) 2406 // (no nacks, not truncated, 6 byte largest observed, 1 byte delta) 2407 0x4C, 2408 // entropy hash of all received packets. 2409 0xBA, 2410 // largest observed packet sequence number 2411 0xBF, 0x9A, 0x78, 0x56, 2412 0x34, 0x12, 2413 // Zero delta time. 2414 0x0, 0x0, 2415 // Number of received packets. 2416 0x00, 2417 }; 2418 2419 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2420 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2421 2422 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2423 ASSERT_TRUE(visitor_.header_.get()); 2424 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2425 2426 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2427 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2428 QuicAckFrame* frame = visitor_.ack_frames_[0]; 2429 EXPECT_EQ(0xBA, frame->entropy_hash); 2430 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame->largest_observed); 2431 ASSERT_EQ(0u, frame->missing_packets.size()); 2432 2433 // Verify that the packet re-serializes identically. 2434 QuicFrames frames; 2435 frames.push_back(QuicFrame(frame)); 2436 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); 2437 ASSERT_TRUE(data != NULL); 2438 2439 test::CompareCharArraysWithHexError("constructed packet", 2440 data->data(), data->length(), 2441 AsChars(packet), arraysize(packet)); 2442} 2443 2444TEST_P(QuicFramerTest, AckFrame500Nacksv22) { 2445 if (version_ > QUIC_VERSION_22) { 2446 return; 2447 } 2448 unsigned char packet[] = { 2449 // public flags (8 byte connection_id) 2450 0x3C, 2451 // connection_id 2452 0x10, 0x32, 0x54, 0x76, 2453 0x98, 0xBA, 0xDC, 0xFE, 2454 // packet sequence number 2455 0xA8, 0x9A, 0x78, 0x56, 2456 0x34, 0x12, 2457 // private flags (entropy) 2458 0x01, 2459 2460 // frame type (ack frame) 2461 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2462 0x6C, 2463 // entropy hash of all received packets. 2464 0xBA, 2465 // largest observed packet sequence number 2466 0xBF, 0x9A, 0x78, 0x56, 2467 0x34, 0x12, 2468 // Zero delta time. 2469 0x0, 0x0, 2470 // num missing packet ranges 2471 0x02, 2472 // missing packet delta 2473 0x01, 2474 // 243 more missing packets in range. 2475 // The ranges are listed in this order so the re-constructed packet matches. 2476 0xF3, 2477 // No gap between ranges 2478 0x00, 2479 // 255 more missing packets in range. 2480 0xFF, 2481 // No revived packets. 2482 0x00, 2483 }; 2484 2485 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2486 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2487 2488 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2489 ASSERT_TRUE(visitor_.header_.get()); 2490 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2491 2492 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2493 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2494 QuicAckFrame* frame = visitor_.ack_frames_[0]; 2495 EXPECT_EQ(0xBA, frame->entropy_hash); 2496 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame->largest_observed); 2497 EXPECT_EQ(0u, frame->revived_packets.size()); 2498 ASSERT_EQ(500u, frame->missing_packets.size()); 2499 SequenceNumberSet::const_iterator first_missing_iter = 2500 frame->missing_packets.begin(); 2501 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter); 2502 SequenceNumberSet::const_reverse_iterator last_missing_iter = 2503 frame->missing_packets.rbegin(); 2504 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter); 2505 2506 // Verify that the packet re-serializes identically. 2507 QuicFrames frames; 2508 frames.push_back(QuicFrame(frame)); 2509 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); 2510 ASSERT_TRUE(data != NULL); 2511 2512 test::CompareCharArraysWithHexError("constructed packet", 2513 data->data(), data->length(), 2514 AsChars(packet), arraysize(packet)); 2515} 2516 2517TEST_P(QuicFramerTest, AckFrame500Nacks) { 2518 if (version_ <= QUIC_VERSION_22) { 2519 return; 2520 } 2521 unsigned char packet[] = { 2522 // public flags (8 byte connection_id) 2523 0x3C, 2524 // connection_id 2525 0x10, 0x32, 0x54, 0x76, 2526 0x98, 0xBA, 0xDC, 0xFE, 2527 // packet sequence number 2528 0xA8, 0x9A, 0x78, 0x56, 2529 0x34, 0x12, 2530 // private flags (entropy) 2531 0x01, 2532 2533 // frame type (ack frame) 2534 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2535 0x6C, 2536 // entropy hash of all received packets. 2537 0xBA, 2538 // largest observed packet sequence number 2539 0xBF, 0x9A, 0x78, 0x56, 2540 0x34, 0x12, 2541 // Zero delta time. 2542 0x0, 0x0, 2543 // No received packets. 2544 0x00, 2545 // num missing packet ranges 2546 0x02, 2547 // missing packet delta 2548 0x01, 2549 // 243 more missing packets in range. 2550 // The ranges are listed in this order so the re-constructed packet matches. 2551 0xF3, 2552 // No gap between ranges 2553 0x00, 2554 // 255 more missing packets in range. 2555 0xFF, 2556 // No revived packets. 2557 0x00, 2558 }; 2559 2560 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2561 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2562 2563 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2564 ASSERT_TRUE(visitor_.header_.get()); 2565 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2566 2567 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2568 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 2569 QuicAckFrame* frame = visitor_.ack_frames_[0]; 2570 EXPECT_EQ(0xBA, frame->entropy_hash); 2571 EXPECT_EQ(GG_UINT64_C(0x0123456789ABF), frame->largest_observed); 2572 EXPECT_EQ(0u, frame->revived_packets.size()); 2573 ASSERT_EQ(500u, frame->missing_packets.size()); 2574 SequenceNumberSet::const_iterator first_missing_iter = 2575 frame->missing_packets.begin(); 2576 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE) - 499, *first_missing_iter); 2577 SequenceNumberSet::const_reverse_iterator last_missing_iter = 2578 frame->missing_packets.rbegin(); 2579 EXPECT_EQ(GG_UINT64_C(0x0123456789ABE), *last_missing_iter); 2580 2581 // Verify that the packet re-serializes identically. 2582 QuicFrames frames; 2583 frames.push_back(QuicFrame(frame)); 2584 scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames)); 2585 ASSERT_TRUE(data != NULL); 2586 2587 test::CompareCharArraysWithHexError("constructed packet", 2588 data->data(), data->length(), 2589 AsChars(packet), arraysize(packet)); 2590} 2591 2592TEST_P(QuicFramerTest, CongestionFeedbackFrameTCP) { 2593 unsigned char packet[] = { 2594 // public flags (8 byte connection_id) 2595 0x3C, 2596 // connection_id 2597 0x10, 0x32, 0x54, 0x76, 2598 0x98, 0xBA, 0xDC, 0xFE, 2599 // packet sequence number 2600 0xBC, 0x9A, 0x78, 0x56, 2601 0x34, 0x12, 2602 // private flags 2603 0x00, 2604 2605 // frame type (congestion feedback frame) 2606 0x20, 2607 // congestion feedback type (tcp) 2608 0x00, 2609 // ack_frame.feedback.tcp.receive_window 2610 0x03, 0x04, 2611 }; 2612 2613 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2614 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2615 2616 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2617 ASSERT_TRUE(visitor_.header_.get()); 2618 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2619 2620 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2621 ASSERT_EQ(1u, visitor_.congestion_feedback_frames_.size()); 2622 const QuicCongestionFeedbackFrame& frame = 2623 *visitor_.congestion_feedback_frames_[0]; 2624 ASSERT_EQ(kTCP, frame.type); 2625 EXPECT_EQ(0x4030u, frame.tcp.receive_window); 2626 2627 // Now test framing boundaries. 2628 for (size_t i = kQuicFrameTypeSize; i < 4; ++i) { 2629 string expected_error; 2630 if (i < 2) { 2631 expected_error = "Unable to read congestion feedback type."; 2632 } else if (i < 4) { 2633 expected_error = "Unable to read receive window."; 2634 } 2635 CheckProcessingFails( 2636 packet, 2637 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2638 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2639 expected_error, QUIC_INVALID_CONGESTION_FEEDBACK_DATA); 2640 } 2641} 2642 2643TEST_P(QuicFramerTest, CongestionFeedbackFrameInvalidFeedback) { 2644 unsigned char packet[] = { 2645 // public flags (8 byte connection_id) 2646 0x3C, 2647 // connection_id 2648 0x10, 0x32, 0x54, 0x76, 2649 0x98, 0xBA, 0xDC, 0xFE, 2650 // packet sequence number 2651 0xBC, 0x9A, 0x78, 0x56, 2652 0x34, 0x12, 2653 // private flags 2654 0x00, 2655 2656 // frame type (congestion feedback frame) 2657 0x20, 2658 // congestion feedback type (invalid) 2659 0x03, 2660 }; 2661 2662 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2663 EXPECT_FALSE(framer_.ProcessPacket(encrypted)); 2664 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2665 EXPECT_EQ(QUIC_INVALID_CONGESTION_FEEDBACK_DATA, framer_.error()); 2666} 2667 2668TEST_P(QuicFramerTest, StopWaitingFrame) { 2669 unsigned char packet[] = { 2670 // public flags (8 byte connection_id) 2671 0x3C, 2672 // connection_id 2673 0x10, 0x32, 0x54, 0x76, 2674 0x98, 0xBA, 0xDC, 0xFE, 2675 // packet sequence number 2676 0xA8, 0x9A, 0x78, 0x56, 2677 0x34, 0x12, 2678 // private flags (entropy) 2679 0x01, 2680 2681 // frame type (ack frame) 2682 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 2683 0x06, 2684 // entropy hash of sent packets till least awaiting - 1. 2685 0xAB, 2686 // least packet sequence number awaiting an ack, delta from sequence number. 2687 0x08, 0x00, 0x00, 0x00, 2688 0x00, 0x00, 2689 }; 2690 2691 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2692 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2693 2694 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2695 ASSERT_TRUE(visitor_.header_.get()); 2696 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2697 2698 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2699 ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size()); 2700 const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0]; 2701 EXPECT_EQ(0xAB, frame.entropy_hash); 2702 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.least_unacked); 2703 2704 const size_t kSentEntropyOffset = kQuicFrameTypeSize; 2705 const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize; 2706 const size_t frame_size = 7; 2707 for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) { 2708 string expected_error; 2709 if (i < kLeastUnackedOffset) { 2710 expected_error = "Unable to read entropy hash for sent packets."; 2711 } else { 2712 expected_error = "Unable to read least unacked delta."; 2713 } 2714 CheckProcessingFails( 2715 packet, 2716 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2717 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2718 expected_error, QUIC_INVALID_STOP_WAITING_DATA); 2719 } 2720} 2721 2722TEST_P(QuicFramerTest, RstStreamFrameQuic) { 2723 unsigned char packet[] = { 2724 // public flags (8 byte connection_id) 2725 0x3C, 2726 // connection_id 2727 0x10, 0x32, 0x54, 0x76, 2728 0x98, 0xBA, 0xDC, 0xFE, 2729 // packet sequence number 2730 0xBC, 0x9A, 0x78, 0x56, 2731 0x34, 0x12, 2732 // private flags 2733 0x00, 2734 2735 // frame type (rst stream frame) 2736 0x01, 2737 // stream id 2738 0x04, 0x03, 0x02, 0x01, 2739 2740 // sent byte offset 2741 0x01, 0x02, 0x03, 0x04, 2742 0x05, 0x06, 0x07, 0x08, 2743 2744 // error code 2745 0x01, 0x00, 0x00, 0x00, 2746 2747 // error details length 2748 0x0d, 0x00, 2749 // error details 2750 'b', 'e', 'c', 'a', 2751 'u', 's', 'e', ' ', 2752 'I', ' ', 'c', 'a', 2753 'n', 2754 }; 2755 2756 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2757 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2758 2759 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2760 ASSERT_TRUE(visitor_.header_.get()); 2761 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2762 2763 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id); 2764 EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code); 2765 EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details); 2766 EXPECT_EQ(GG_UINT64_C(0x0807060504030201), 2767 visitor_.rst_stream_frame_.byte_offset); 2768 2769 // Now test framing boundaries. 2770 for (size_t i = kQuicFrameTypeSize; 2771 i < QuicFramer::GetMinRstStreamFrameSize(); ++i) { 2772 string expected_error; 2773 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 2774 expected_error = "Unable to read stream_id."; 2775 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + 2776 + kQuicMaxStreamOffsetSize) { 2777 expected_error = "Unable to read rst stream sent byte offset."; 2778 } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize + 2779 + kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) { 2780 expected_error = "Unable to read rst stream error code."; 2781 } else { 2782 expected_error = "Unable to read rst stream error details."; 2783 } 2784 CheckProcessingFails( 2785 packet, 2786 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2787 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2788 expected_error, QUIC_INVALID_RST_STREAM_DATA); 2789 } 2790} 2791 2792TEST_P(QuicFramerTest, ConnectionCloseFrame) { 2793 unsigned char packet[] = { 2794 // public flags (8 byte connection_id) 2795 0x3C, 2796 // connection_id 2797 0x10, 0x32, 0x54, 0x76, 2798 0x98, 0xBA, 0xDC, 0xFE, 2799 // packet sequence number 2800 0xBC, 0x9A, 0x78, 0x56, 2801 0x34, 0x12, 2802 // private flags 2803 0x00, 2804 2805 // frame type (connection close frame) 2806 0x02, 2807 // error code 2808 0x11, 0x00, 0x00, 0x00, 2809 2810 // error details length 2811 0x0d, 0x00, 2812 // error details 2813 'b', 'e', 'c', 'a', 2814 'u', 's', 'e', ' ', 2815 'I', ' ', 'c', 'a', 2816 'n', 2817 }; 2818 2819 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2820 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2821 2822 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2823 ASSERT_TRUE(visitor_.header_.get()); 2824 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2825 2826 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 2827 2828 EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code); 2829 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details); 2830 2831 ASSERT_EQ(0u, visitor_.ack_frames_.size()); 2832 2833 // Now test framing boundaries. 2834 for (size_t i = kQuicFrameTypeSize; 2835 i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) { 2836 string expected_error; 2837 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { 2838 expected_error = "Unable to read connection close error code."; 2839 } else { 2840 expected_error = "Unable to read connection close error details."; 2841 } 2842 CheckProcessingFails( 2843 packet, 2844 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2845 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2846 expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA); 2847 } 2848} 2849 2850TEST_P(QuicFramerTest, GoAwayFrame) { 2851 unsigned char packet[] = { 2852 // public flags (8 byte connection_id) 2853 0x3C, 2854 // connection_id 2855 0x10, 0x32, 0x54, 0x76, 2856 0x98, 0xBA, 0xDC, 0xFE, 2857 // packet sequence number 2858 0xBC, 0x9A, 0x78, 0x56, 2859 0x34, 0x12, 2860 // private flags 2861 0x00, 2862 2863 // frame type (go away frame) 2864 0x03, 2865 // error code 2866 0x09, 0x00, 0x00, 0x00, 2867 // stream id 2868 0x04, 0x03, 0x02, 0x01, 2869 // error details length 2870 0x0d, 0x00, 2871 // error details 2872 'b', 'e', 'c', 'a', 2873 'u', 's', 'e', ' ', 2874 'I', ' ', 'c', 'a', 2875 'n', 2876 }; 2877 2878 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2879 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2880 2881 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2882 ASSERT_TRUE(visitor_.header_.get()); 2883 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2884 2885 EXPECT_EQ(GG_UINT64_C(0x01020304), 2886 visitor_.goaway_frame_.last_good_stream_id); 2887 EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code); 2888 EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase); 2889 2890 const size_t reason_size = arraysize("because I can") - 1; 2891 // Now test framing boundaries. 2892 for (size_t i = kQuicFrameTypeSize; 2893 i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) { 2894 string expected_error; 2895 if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) { 2896 expected_error = "Unable to read go away error code."; 2897 } else if (i < kQuicFrameTypeSize + kQuicErrorCodeSize + 2898 kQuicMaxStreamIdSize) { 2899 expected_error = "Unable to read last good stream id."; 2900 } else { 2901 expected_error = "Unable to read goaway reason."; 2902 } 2903 CheckProcessingFails( 2904 packet, 2905 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2906 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2907 expected_error, QUIC_INVALID_GOAWAY_DATA); 2908 } 2909} 2910 2911TEST_P(QuicFramerTest, WindowUpdateFrame) { 2912 unsigned char packet[] = { 2913 // public flags (8 byte connection_id) 2914 0x3C, 2915 // connection_id 2916 0x10, 0x32, 0x54, 0x76, 2917 0x98, 0xBA, 0xDC, 0xFE, 2918 // packet sequence number 2919 0xBC, 0x9A, 0x78, 0x56, 2920 0x34, 0x12, 2921 // private flags 2922 0x00, 2923 2924 // frame type (window update frame) 2925 0x04, 2926 // stream id 2927 0x04, 0x03, 0x02, 0x01, 2928 // byte offset 2929 0x05, 0x06, 0x07, 0x08, 2930 0x09, 0x0a, 0x0b, 0x0c, 2931 }; 2932 2933 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2934 2935 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2936 2937 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2938 ASSERT_TRUE(visitor_.header_.get()); 2939 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2940 2941 EXPECT_EQ(GG_UINT64_C(0x01020304), 2942 visitor_.window_update_frame_.stream_id); 2943 EXPECT_EQ(GG_UINT64_C(0x0c0b0a0908070605), 2944 visitor_.window_update_frame_.byte_offset); 2945 2946 // Now test framing boundaries. 2947 for (size_t i = kQuicFrameTypeSize; 2948 i < QuicFramer::GetWindowUpdateFrameSize(); ++i) { 2949 string expected_error; 2950 if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) { 2951 expected_error = "Unable to read stream_id."; 2952 } else { 2953 expected_error = "Unable to read window byte_offset."; 2954 } 2955 CheckProcessingFails( 2956 packet, 2957 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 2958 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 2959 expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA); 2960 } 2961} 2962 2963TEST_P(QuicFramerTest, BlockedFrame) { 2964 unsigned char packet[] = { 2965 // public flags (8 byte connection_id) 2966 0x3C, 2967 // connection_id 2968 0x10, 0x32, 0x54, 0x76, 2969 0x98, 0xBA, 0xDC, 0xFE, 2970 // packet sequence number 2971 0xBC, 0x9A, 0x78, 0x56, 2972 0x34, 0x12, 2973 // private flags 2974 0x00, 2975 2976 // frame type (blocked frame) 2977 0x05, 2978 // stream id 2979 0x04, 0x03, 0x02, 0x01, 2980 }; 2981 2982 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 2983 2984 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 2985 2986 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 2987 ASSERT_TRUE(visitor_.header_.get()); 2988 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 2989 2990 EXPECT_EQ(GG_UINT64_C(0x01020304), 2991 visitor_.blocked_frame_.stream_id); 2992 2993 // Now test framing boundaries. 2994 for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize(); 2995 ++i) { 2996 string expected_error = "Unable to read stream_id."; 2997 CheckProcessingFails( 2998 packet, 2999 i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 3000 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP), 3001 expected_error, QUIC_INVALID_BLOCKED_DATA); 3002 } 3003} 3004 3005TEST_P(QuicFramerTest, PingFrame) { 3006 if (version_ <= QUIC_VERSION_16) { 3007 return; 3008 } 3009 3010 unsigned char packet[] = { 3011 // public flags (8 byte connection_id) 3012 0x3C, 3013 // connection_id 3014 0x10, 0x32, 0x54, 0x76, 3015 0x98, 0xBA, 0xDC, 0xFE, 3016 // packet sequence number 3017 0xBC, 0x9A, 0x78, 0x56, 3018 0x34, 0x12, 3019 // private flags 3020 0x00, 3021 3022 // frame type (ping frame) 3023 0x07, 3024 }; 3025 3026 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3027 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3028 3029 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3030 ASSERT_TRUE(visitor_.header_.get()); 3031 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 3032 3033 EXPECT_EQ(1u, visitor_.ping_frames_.size()); 3034 3035 // No need to check the PING frame boundaries because it has no payload. 3036} 3037 3038TEST_P(QuicFramerTest, PublicResetPacket) { 3039 unsigned char packet[] = { 3040 // public flags (public reset, 8 byte connection_id) 3041 0x0E, 3042 // connection_id 3043 0x10, 0x32, 0x54, 0x76, 3044 0x98, 0xBA, 0xDC, 0xFE, 3045 // message tag (kPRST) 3046 'P', 'R', 'S', 'T', 3047 // num_entries (2) + padding 3048 0x02, 0x00, 0x00, 0x00, 3049 // tag kRNON 3050 'R', 'N', 'O', 'N', 3051 // end offset 8 3052 0x08, 0x00, 0x00, 0x00, 3053 // tag kRSEQ 3054 'R', 'S', 'E', 'Q', 3055 // end offset 16 3056 0x10, 0x00, 0x00, 0x00, 3057 // nonce proof 3058 0x89, 0x67, 0x45, 0x23, 3059 0x01, 0xEF, 0xCD, 0xAB, 3060 // rejected sequence number 3061 0xBC, 0x9A, 0x78, 0x56, 3062 0x34, 0x12, 0x00, 0x00, 3063 }; 3064 3065 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3066 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3067 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); 3068 ASSERT_TRUE(visitor_.public_reset_packet_.get()); 3069 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 3070 visitor_.public_reset_packet_->public_header.connection_id); 3071 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); 3072 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); 3073 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789), 3074 visitor_.public_reset_packet_->nonce_proof); 3075 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 3076 visitor_.public_reset_packet_->rejected_sequence_number); 3077 EXPECT_TRUE( 3078 visitor_.public_reset_packet_->client_address.address().empty()); 3079 3080 // Now test framing boundaries. 3081 for (size_t i = 0; i < arraysize(packet); ++i) { 3082 string expected_error; 3083 DVLOG(1) << "iteration: " << i; 3084 if (i < kConnectionIdOffset) { 3085 expected_error = "Unable to read public flags."; 3086 CheckProcessingFails(packet, i, expected_error, 3087 QUIC_INVALID_PACKET_HEADER); 3088 } else if (i < kPublicResetPacketMessageTagOffset) { 3089 expected_error = "Unable to read ConnectionId."; 3090 CheckProcessingFails(packet, i, expected_error, 3091 QUIC_INVALID_PACKET_HEADER); 3092 } else { 3093 expected_error = "Unable to read reset message."; 3094 CheckProcessingFails(packet, i, expected_error, 3095 QUIC_INVALID_PUBLIC_RST_PACKET); 3096 } 3097 } 3098} 3099 3100TEST_P(QuicFramerTest, PublicResetPacketWithTrailingJunk) { 3101 unsigned char packet[] = { 3102 // public flags (public reset, 8 byte connection_id) 3103 0x0E, 3104 // connection_id 3105 0x10, 0x32, 0x54, 0x76, 3106 0x98, 0xBA, 0xDC, 0xFE, 3107 // message tag (kPRST) 3108 'P', 'R', 'S', 'T', 3109 // num_entries (2) + padding 3110 0x02, 0x00, 0x00, 0x00, 3111 // tag kRNON 3112 'R', 'N', 'O', 'N', 3113 // end offset 8 3114 0x08, 0x00, 0x00, 0x00, 3115 // tag kRSEQ 3116 'R', 'S', 'E', 'Q', 3117 // end offset 16 3118 0x10, 0x00, 0x00, 0x00, 3119 // nonce proof 3120 0x89, 0x67, 0x45, 0x23, 3121 0x01, 0xEF, 0xCD, 0xAB, 3122 // rejected sequence number 3123 0xBC, 0x9A, 0x78, 0x56, 3124 0x34, 0x12, 0x00, 0x00, 3125 // trailing junk 3126 'j', 'u', 'n', 'k', 3127 }; 3128 3129 string expected_error = "Unable to read reset message."; 3130 CheckProcessingFails(packet, arraysize(packet), expected_error, 3131 QUIC_INVALID_PUBLIC_RST_PACKET); 3132} 3133 3134TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) { 3135 unsigned char packet[] = { 3136 // public flags (public reset, 8 byte connection_id) 3137 0x0E, 3138 // connection_id 3139 0x10, 0x32, 0x54, 0x76, 3140 0x98, 0xBA, 0xDC, 0xFE, 3141 // message tag (kPRST) 3142 'P', 'R', 'S', 'T', 3143 // num_entries (3) + padding 3144 0x03, 0x00, 0x00, 0x00, 3145 // tag kRNON 3146 'R', 'N', 'O', 'N', 3147 // end offset 8 3148 0x08, 0x00, 0x00, 0x00, 3149 // tag kRSEQ 3150 'R', 'S', 'E', 'Q', 3151 // end offset 16 3152 0x10, 0x00, 0x00, 0x00, 3153 // tag kCADR 3154 'C', 'A', 'D', 'R', 3155 // end offset 24 3156 0x18, 0x00, 0x00, 0x00, 3157 // nonce proof 3158 0x89, 0x67, 0x45, 0x23, 3159 0x01, 0xEF, 0xCD, 0xAB, 3160 // rejected sequence number 3161 0xBC, 0x9A, 0x78, 0x56, 3162 0x34, 0x12, 0x00, 0x00, 3163 // client address: 4.31.198.44:443 3164 0x02, 0x00, 3165 0x04, 0x1F, 0xC6, 0x2C, 3166 0xBB, 0x01, 3167 }; 3168 3169 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3170 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3171 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); 3172 ASSERT_TRUE(visitor_.public_reset_packet_.get()); 3173 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), 3174 visitor_.public_reset_packet_->public_header.connection_id); 3175 EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag); 3176 EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag); 3177 EXPECT_EQ(GG_UINT64_C(0xABCDEF0123456789), 3178 visitor_.public_reset_packet_->nonce_proof); 3179 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 3180 visitor_.public_reset_packet_->rejected_sequence_number); 3181 EXPECT_EQ("4.31.198.44", 3182 IPAddressToString(visitor_.public_reset_packet_-> 3183 client_address.address())); 3184 EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port()); 3185 3186 // Now test framing boundaries. 3187 for (size_t i = 0; i < arraysize(packet); ++i) { 3188 string expected_error; 3189 DVLOG(1) << "iteration: " << i; 3190 if (i < kConnectionIdOffset) { 3191 expected_error = "Unable to read public flags."; 3192 CheckProcessingFails(packet, i, expected_error, 3193 QUIC_INVALID_PACKET_HEADER); 3194 } else if (i < kPublicResetPacketMessageTagOffset) { 3195 expected_error = "Unable to read ConnectionId."; 3196 CheckProcessingFails(packet, i, expected_error, 3197 QUIC_INVALID_PACKET_HEADER); 3198 } else { 3199 expected_error = "Unable to read reset message."; 3200 CheckProcessingFails(packet, i, expected_error, 3201 QUIC_INVALID_PUBLIC_RST_PACKET); 3202 } 3203 } 3204} 3205 3206TEST_P(QuicFramerTest, VersionNegotiationPacket) { 3207 unsigned char packet[] = { 3208 // public flags (version, 8 byte connection_id) 3209 0x3D, 3210 // connection_id 3211 0x10, 0x32, 0x54, 0x76, 3212 0x98, 0xBA, 0xDC, 0xFE, 3213 // version tag 3214 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 3215 'Q', '2', '.', '0', 3216 }; 3217 3218 QuicFramerPeer::SetIsServer(&framer_, false); 3219 3220 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3221 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3222 ASSERT_EQ(QUIC_NO_ERROR, framer_.error()); 3223 ASSERT_TRUE(visitor_.version_negotiation_packet_.get()); 3224 EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size()); 3225 EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]); 3226 3227 for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) { 3228 string expected_error; 3229 QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER; 3230 if (i < kConnectionIdOffset) { 3231 expected_error = "Unable to read public flags."; 3232 } else if (i < kVersionOffset) { 3233 expected_error = "Unable to read ConnectionId."; 3234 } else { 3235 expected_error = "Unable to read supported version in negotiation."; 3236 error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET; 3237 } 3238 CheckProcessingFails(packet, i, expected_error, error_code); 3239 } 3240} 3241 3242TEST_P(QuicFramerTest, FecPacket) { 3243 unsigned char packet[] = { 3244 // public flags (8 byte connection_id) 3245 0x3C, 3246 // connection_id 3247 0x10, 0x32, 0x54, 0x76, 3248 0x98, 0xBA, 0xDC, 0xFE, 3249 // packet sequence number 3250 0xBC, 0x9A, 0x78, 0x56, 3251 0x34, 0x12, 3252 // private flags (fec group & FEC) 3253 0x06, 3254 // first fec protected packet offset 3255 0x01, 3256 3257 // redundancy 3258 'a', 'b', 'c', 'd', 3259 'e', 'f', 'g', 'h', 3260 'i', 'j', 'k', 'l', 3261 'm', 'n', 'o', 'p', 3262 }; 3263 3264 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 3265 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 3266 3267 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 3268 ASSERT_TRUE(visitor_.header_.get()); 3269 EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion)); 3270 3271 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 3272 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 3273 ASSERT_EQ(1, visitor_.fec_count_); 3274 const QuicFecData& fec_data = *visitor_.fec_data_[0]; 3275 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), fec_data.fec_group); 3276 EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy); 3277} 3278 3279TEST_P(QuicFramerTest, BuildPaddingFramePacket) { 3280 QuicPacketHeader header; 3281 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3282 header.public_header.reset_flag = false; 3283 header.public_header.version_flag = false; 3284 header.fec_flag = false; 3285 header.entropy_flag = false; 3286 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3287 header.fec_group = 0; 3288 3289 QuicPaddingFrame padding_frame; 3290 3291 QuicFrames frames; 3292 frames.push_back(QuicFrame(&padding_frame)); 3293 3294 unsigned char packet[kMaxPacketSize] = { 3295 // public flags (8 byte connection_id) 3296 0x3C, 3297 // connection_id 3298 0x10, 0x32, 0x54, 0x76, 3299 0x98, 0xBA, 0xDC, 0xFE, 3300 // packet sequence number 3301 0xBC, 0x9A, 0x78, 0x56, 3302 0x34, 0x12, 3303 // private flags 3304 0x00, 3305 3306 // frame type (padding frame) 3307 0x00, 3308 0x00, 0x00, 0x00, 0x00 3309 }; 3310 3311 uint64 header_size = 3312 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 3313 PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 3314 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 3315 3316 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3317 ASSERT_TRUE(data != NULL); 3318 3319 test::CompareCharArraysWithHexError("constructed packet", 3320 data->data(), data->length(), 3321 AsChars(packet), 3322 arraysize(packet)); 3323} 3324 3325TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { 3326 QuicPacketHeader header; 3327 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3328 header.public_header.reset_flag = false; 3329 header.public_header.version_flag = false; 3330 header.fec_flag = false; 3331 header.entropy_flag = false; 3332 header.public_header.sequence_number_length = PACKET_4BYTE_SEQUENCE_NUMBER; 3333 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3334 header.fec_group = 0; 3335 3336 QuicPaddingFrame padding_frame; 3337 3338 QuicFrames frames; 3339 frames.push_back(QuicFrame(&padding_frame)); 3340 3341 unsigned char packet[kMaxPacketSize] = { 3342 // public flags (8 byte connection_id and 4 byte sequence number) 3343 0x2C, 3344 // connection_id 3345 0x10, 0x32, 0x54, 0x76, 3346 0x98, 0xBA, 0xDC, 0xFE, 3347 // packet sequence number 3348 0xBC, 0x9A, 0x78, 0x56, 3349 // private flags 3350 0x00, 3351 3352 // frame type (padding frame) 3353 0x00, 3354 0x00, 0x00, 0x00, 0x00 3355 }; 3356 3357 uint64 header_size = 3358 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 3359 PACKET_4BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 3360 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 3361 3362 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3363 ASSERT_TRUE(data != NULL); 3364 3365 test::CompareCharArraysWithHexError("constructed packet", 3366 data->data(), data->length(), 3367 AsChars(packet), 3368 arraysize(packet)); 3369} 3370 3371TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) { 3372 QuicPacketHeader header; 3373 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3374 header.public_header.reset_flag = false; 3375 header.public_header.version_flag = false; 3376 header.fec_flag = false; 3377 header.entropy_flag = false; 3378 header.public_header.sequence_number_length = PACKET_2BYTE_SEQUENCE_NUMBER; 3379 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3380 header.fec_group = 0; 3381 3382 QuicPaddingFrame padding_frame; 3383 3384 QuicFrames frames; 3385 frames.push_back(QuicFrame(&padding_frame)); 3386 3387 unsigned char packet[kMaxPacketSize] = { 3388 // public flags (8 byte connection_id and 2 byte sequence number) 3389 0x1C, 3390 // connection_id 3391 0x10, 0x32, 0x54, 0x76, 3392 0x98, 0xBA, 0xDC, 0xFE, 3393 // packet sequence number 3394 0xBC, 0x9A, 3395 // private flags 3396 0x00, 3397 3398 // frame type (padding frame) 3399 0x00, 3400 0x00, 0x00, 0x00, 0x00 3401 }; 3402 3403 uint64 header_size = 3404 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 3405 PACKET_2BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 3406 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 3407 3408 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3409 ASSERT_TRUE(data != NULL); 3410 3411 test::CompareCharArraysWithHexError("constructed packet", 3412 data->data(), data->length(), 3413 AsChars(packet), 3414 arraysize(packet)); 3415} 3416 3417TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) { 3418 QuicPacketHeader header; 3419 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3420 header.public_header.reset_flag = false; 3421 header.public_header.version_flag = false; 3422 header.fec_flag = false; 3423 header.entropy_flag = false; 3424 header.public_header.sequence_number_length = PACKET_1BYTE_SEQUENCE_NUMBER; 3425 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 3426 header.fec_group = 0; 3427 3428 QuicPaddingFrame padding_frame; 3429 3430 QuicFrames frames; 3431 frames.push_back(QuicFrame(&padding_frame)); 3432 3433 unsigned char packet[kMaxPacketSize] = { 3434 // public flags (8 byte connection_id and 1 byte sequence number) 3435 0x0C, 3436 // connection_id 3437 0x10, 0x32, 0x54, 0x76, 3438 0x98, 0xBA, 0xDC, 0xFE, 3439 // packet sequence number 3440 0xBC, 3441 // private flags 3442 0x00, 3443 3444 // frame type (padding frame) 3445 0x00, 3446 0x00, 0x00, 0x00, 0x00 3447 }; 3448 3449 uint64 header_size = 3450 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 3451 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP); 3452 memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1); 3453 3454 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3455 ASSERT_TRUE(data != NULL); 3456 3457 test::CompareCharArraysWithHexError("constructed packet", 3458 data->data(), data->length(), 3459 AsChars(packet), 3460 arraysize(packet)); 3461} 3462 3463TEST_P(QuicFramerTest, BuildStreamFramePacket) { 3464 QuicPacketHeader header; 3465 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3466 header.public_header.reset_flag = false; 3467 header.public_header.version_flag = false; 3468 header.fec_flag = false; 3469 header.entropy_flag = true; 3470 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC); 3471 header.fec_group = 0; 3472 3473 QuicStreamFrame stream_frame; 3474 stream_frame.stream_id = 0x01020304; 3475 stream_frame.fin = true; 3476 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 3477 stream_frame.data = MakeIOVector("hello world!"); 3478 3479 QuicFrames frames; 3480 frames.push_back(QuicFrame(&stream_frame)); 3481 3482 unsigned char packet[] = { 3483 // public flags (8 byte connection_id) 3484 0x3C, 3485 // connection_id 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) 3492 0x01, 3493 3494 // frame type (stream frame with fin and no length) 3495 0xDF, 3496 // stream id 3497 0x04, 0x03, 0x02, 0x01, 3498 // offset 3499 0x54, 0x76, 0x10, 0x32, 3500 0xDC, 0xFE, 0x98, 0xBA, 3501 // data 3502 'h', 'e', 'l', 'l', 3503 'o', ' ', 'w', 'o', 3504 'r', 'l', 'd', '!', 3505 }; 3506 3507 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3508 ASSERT_TRUE(data != NULL); 3509 3510 test::CompareCharArraysWithHexError("constructed packet", 3511 data->data(), data->length(), 3512 AsChars(packet), arraysize(packet)); 3513} 3514 3515TEST_P(QuicFramerTest, BuildStreamFramePacketInFecGroup) { 3516 QuicPacketHeader header; 3517 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3518 header.public_header.reset_flag = false; 3519 header.public_header.version_flag = false; 3520 header.fec_flag = false; 3521 header.entropy_flag = true; 3522 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC); 3523 header.is_in_fec_group = IN_FEC_GROUP; 3524 header.fec_group = GG_UINT64_C(0x77123456789ABC); 3525 3526 QuicStreamFrame stream_frame; 3527 stream_frame.stream_id = 0x01020304; 3528 stream_frame.fin = true; 3529 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 3530 stream_frame.data = MakeIOVector("hello world!"); 3531 3532 QuicFrames frames; 3533 frames.push_back(QuicFrame(&stream_frame)); 3534 unsigned char packet[] = { 3535 // public flags (8 byte connection_id) 3536 0x3C, 3537 // connection_id 3538 0x10, 0x32, 0x54, 0x76, 3539 0x98, 0xBA, 0xDC, 0xFE, 3540 // packet sequence number 3541 0xBC, 0x9A, 0x78, 0x56, 3542 0x34, 0x12, 3543 // private flags (entropy, is_in_fec_group) 3544 0x03, 3545 // FEC group 3546 0x00, 3547 // frame type (stream frame with fin and data length field) 3548 0xFF, 3549 // stream id 3550 0x04, 0x03, 0x02, 0x01, 3551 // offset 3552 0x54, 0x76, 0x10, 0x32, 3553 0xDC, 0xFE, 0x98, 0xBA, 3554 // data length (since packet is in an FEC group) 3555 0x0C, 0x00, 3556 // data 3557 'h', 'e', 'l', 'l', 3558 'o', ' ', 'w', 'o', 3559 'r', 'l', 'd', '!', 3560 }; 3561 3562 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3563 ASSERT_TRUE(data != NULL); 3564 3565 test::CompareCharArraysWithHexError("constructed packet", 3566 data->data(), data->length(), 3567 AsChars(packet), arraysize(packet)); 3568} 3569 3570TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { 3571 QuicPacketHeader header; 3572 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3573 header.public_header.reset_flag = false; 3574 header.public_header.version_flag = true; 3575 header.fec_flag = false; 3576 header.entropy_flag = true; 3577 header.packet_sequence_number = GG_UINT64_C(0x77123456789ABC); 3578 header.fec_group = 0; 3579 3580 QuicStreamFrame stream_frame; 3581 stream_frame.stream_id = 0x01020304; 3582 stream_frame.fin = true; 3583 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 3584 stream_frame.data = MakeIOVector("hello world!"); 3585 3586 QuicFrames frames; 3587 frames.push_back(QuicFrame(&stream_frame)); 3588 3589 unsigned char packet[] = { 3590 // public flags (version, 8 byte connection_id) 3591 0x3D, 3592 // connection_id 3593 0x10, 0x32, 0x54, 0x76, 3594 0x98, 0xBA, 0xDC, 0xFE, 3595 // version tag 3596 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 3597 // packet sequence number 3598 0xBC, 0x9A, 0x78, 0x56, 3599 0x34, 0x12, 3600 // private flags (entropy) 3601 0x01, 3602 3603 // frame type (stream frame with fin and no length) 3604 0xDF, 3605 // stream id 3606 0x04, 0x03, 0x02, 0x01, 3607 // offset 3608 0x54, 0x76, 0x10, 0x32, 3609 0xDC, 0xFE, 0x98, 0xBA, 3610 // data 3611 'h', 'e', 'l', 'l', 3612 'o', ' ', 'w', 'o', 3613 'r', 'l', 'd', '!', 3614 }; 3615 3616 QuicFramerPeer::SetIsServer(&framer_, false); 3617 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3618 ASSERT_TRUE(data != NULL); 3619 3620 test::CompareCharArraysWithHexError("constructed packet", 3621 data->data(), data->length(), 3622 AsChars(packet), arraysize(packet)); 3623} 3624 3625TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) { 3626 QuicPacketPublicHeader header; 3627 header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3628 header.reset_flag = false; 3629 header.version_flag = true; 3630 3631 unsigned char packet[] = { 3632 // public flags (version, 8 byte connection_id) 3633 0x0D, 3634 // connection_id 3635 0x10, 0x32, 0x54, 0x76, 3636 0x98, 0xBA, 0xDC, 0xFE, 3637 // version tag 3638 'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(), 3639 }; 3640 3641 QuicVersionVector versions; 3642 versions.push_back(GetParam()); 3643 scoped_ptr<QuicEncryptedPacket> data( 3644 framer_.BuildVersionNegotiationPacket(header, versions)); 3645 3646 test::CompareCharArraysWithHexError("constructed packet", 3647 data->data(), data->length(), 3648 AsChars(packet), arraysize(packet)); 3649} 3650 3651TEST_P(QuicFramerTest, BuildAckFramePacketv22) { 3652 if (version_ > QUIC_VERSION_22) { 3653 return; 3654 } 3655 QuicPacketHeader header; 3656 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3657 header.public_header.reset_flag = false; 3658 header.public_header.version_flag = false; 3659 header.fec_flag = false; 3660 header.entropy_flag = true; 3661 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 3662 header.fec_group = 0; 3663 3664 QuicAckFrame ack_frame; 3665 ack_frame.entropy_hash = 0x43; 3666 ack_frame.largest_observed = GG_UINT64_C(0x770123456789ABF); 3667 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 3668 ack_frame.missing_packets.insert( 3669 GG_UINT64_C(0x770123456789ABE)); 3670 3671 QuicFrames frames; 3672 frames.push_back(QuicFrame(&ack_frame)); 3673 3674 unsigned char packet[] = { 3675 // public flags (8 byte connection_id) 3676 0x3C, 3677 // connection_id 3678 0x10, 0x32, 0x54, 0x76, 3679 0x98, 0xBA, 0xDC, 0xFE, 3680 // packet sequence number 3681 0xA8, 0x9A, 0x78, 0x56, 3682 0x34, 0x12, 3683 // private flags (entropy) 3684 0x01, 3685 3686 // frame type (ack frame) 3687 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 3688 0x6C, 3689 // entropy hash of all received packets. 3690 0x43, 3691 // largest observed packet sequence number 3692 0xBF, 0x9A, 0x78, 0x56, 3693 0x34, 0x12, 3694 // Zero delta time. 3695 0x0, 0x0, 3696 // num missing packet ranges 3697 0x01, 3698 // missing packet delta 3699 0x01, 3700 // 0 more missing packets in range. 3701 0x00, 3702 // 0 revived packets. 3703 0x00, 3704 }; 3705 3706 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3707 ASSERT_TRUE(data != NULL); 3708 3709 test::CompareCharArraysWithHexError("constructed packet", 3710 data->data(), data->length(), 3711 AsChars(packet), arraysize(packet)); 3712} 3713 3714TEST_P(QuicFramerTest, BuildAckFramePacket) { 3715 if (version_ <= QUIC_VERSION_22) { 3716 return; 3717 } 3718 QuicPacketHeader header; 3719 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3720 header.public_header.reset_flag = false; 3721 header.public_header.version_flag = false; 3722 header.fec_flag = false; 3723 header.entropy_flag = true; 3724 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 3725 header.fec_group = 0; 3726 3727 QuicAckFrame ack_frame; 3728 ack_frame.entropy_hash = 0x43; 3729 ack_frame.largest_observed = GG_UINT64_C(0x770123456789ABF); 3730 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 3731 ack_frame.missing_packets.insert( 3732 GG_UINT64_C(0x770123456789ABE)); 3733 3734 QuicFrames frames; 3735 frames.push_back(QuicFrame(&ack_frame)); 3736 3737 unsigned char packet[] = { 3738 // public flags (8 byte connection_id) 3739 0x3C, 3740 // connection_id 3741 0x10, 0x32, 0x54, 0x76, 3742 0x98, 0xBA, 0xDC, 0xFE, 3743 // packet sequence number 3744 0xA8, 0x9A, 0x78, 0x56, 3745 0x34, 0x12, 3746 // private flags (entropy) 3747 0x01, 3748 3749 // frame type (ack frame) 3750 // (has nacks, not truncated, 6 byte largest observed, 1 byte delta) 3751 0x6C, 3752 // entropy hash of all received packets. 3753 0x43, 3754 // largest observed packet sequence number 3755 0xBF, 0x9A, 0x78, 0x56, 3756 0x34, 0x12, 3757 // Zero delta time. 3758 0x0, 0x0, 3759 // num received packets. 3760 0x00, 3761 // num missing packet ranges 3762 0x01, 3763 // missing packet delta 3764 0x01, 3765 // 0 more missing packets in range. 3766 0x00, 3767 // 0 revived packets. 3768 0x00, 3769 }; 3770 3771 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 3772 ASSERT_TRUE(data != NULL); 3773 3774 test::CompareCharArraysWithHexError("constructed packet", 3775 data->data(), data->length(), 3776 AsChars(packet), arraysize(packet)); 3777} 3778 3779// TODO(jri): Add test for tuncated packets in which the original ack frame had 3780// revived packets. (In both the large and small packet cases below). 3781 3782TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacketv22) { 3783 if (version_ > QUIC_VERSION_22) { 3784 return; 3785 } 3786 QuicPacketHeader header; 3787 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3788 header.public_header.reset_flag = false; 3789 header.public_header.version_flag = false; 3790 header.fec_flag = false; 3791 header.entropy_flag = true; 3792 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 3793 header.fec_group = 0; 3794 3795 QuicAckFrame ack_frame; 3796 // This entropy hash is different from what shows up in the packet below, 3797 // since entropy is recomputed by the framer on ack truncation (by 3798 // TestEntropyCalculator for this test.) 3799 ack_frame.entropy_hash = 0x43; 3800 ack_frame.largest_observed = 2 * 300; 3801 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 3802 for (size_t i = 1; i < 2 * 300; i += 2) { 3803 ack_frame.missing_packets.insert(i); 3804 } 3805 3806 QuicFrames frames; 3807 frames.push_back(QuicFrame(&ack_frame)); 3808 3809 unsigned char packet[] = { 3810 // public flags (8 byte connection_id) 3811 0x3C, 3812 // connection_id 3813 0x10, 0x32, 0x54, 0x76, 3814 0x98, 0xBA, 0xDC, 0xFE, 3815 // packet sequence number 3816 0xA8, 0x9A, 0x78, 0x56, 3817 0x34, 0x12, 3818 // private flags (entropy) 3819 0x01, 3820 3821 // frame type (ack frame) 3822 // (has nacks, is truncated, 2 byte largest observed, 1 byte delta) 3823 0x74, 3824 // entropy hash of all received packets, set to 1 by TestEntropyCalculator 3825 // since ack is truncated. 3826 0x01, 3827 // 2-byte largest observed packet sequence number. 3828 // Expected to be 510 (0x1FE), since only 255 nack ranges can fit. 3829 0xFE, 0x01, 3830 // Zero delta time. 3831 0x0, 0x0, 3832 // num missing packet ranges (limited to 255 by size of this field). 3833 0xFF, 3834 // {missing packet delta, further missing packets in range} 3835 // 6 nack ranges x 42 + 3 nack ranges 3836 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3837 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3838 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3839 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3840 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3841 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3842 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3843 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3844 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3845 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3846 3847 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3848 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3849 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3850 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3851 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3852 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3853 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3854 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3855 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3856 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3857 3858 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3859 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3860 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3861 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3862 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3863 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3864 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3865 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3866 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3867 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3868 3869 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3870 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3871 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3872 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3873 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3874 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3875 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3876 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3877 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3878 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3879 3880 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3881 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3882 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3883 3884 // 0 revived packets. 3885 0x00, 3886 }; 3887 3888 scoped_ptr<QuicPacket> data( 3889 framer_.BuildDataPacket(header, frames, kMaxPacketSize).packet); 3890 ASSERT_TRUE(data != NULL); 3891 3892 test::CompareCharArraysWithHexError("constructed packet", 3893 data->data(), data->length(), 3894 AsChars(packet), arraysize(packet)); 3895} 3896 3897TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) { 3898 if (version_ <= QUIC_VERSION_22) { 3899 return; 3900 } 3901 QuicPacketHeader header; 3902 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 3903 header.public_header.reset_flag = false; 3904 header.public_header.version_flag = false; 3905 header.fec_flag = false; 3906 header.entropy_flag = true; 3907 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 3908 header.fec_group = 0; 3909 3910 QuicAckFrame ack_frame; 3911 // This entropy hash is different from what shows up in the packet below, 3912 // since entropy is recomputed by the framer on ack truncation (by 3913 // TestEntropyCalculator for this test.) 3914 ack_frame.entropy_hash = 0x43; 3915 ack_frame.largest_observed = 2 * 300; 3916 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 3917 for (size_t i = 1; i < 2 * 300; i += 2) { 3918 ack_frame.missing_packets.insert(i); 3919 } 3920 3921 QuicFrames frames; 3922 frames.push_back(QuicFrame(&ack_frame)); 3923 3924 unsigned char packet[] = { 3925 // public flags (8 byte connection_id) 3926 0x3C, 3927 // connection_id 3928 0x10, 0x32, 0x54, 0x76, 3929 0x98, 0xBA, 0xDC, 0xFE, 3930 // packet sequence number 3931 0xA8, 0x9A, 0x78, 0x56, 3932 0x34, 0x12, 3933 // private flags (entropy) 3934 0x01, 3935 3936 // frame type (ack frame) 3937 // (has nacks, is truncated, 2 byte largest observed, 1 byte delta) 3938 0x74, 3939 // entropy hash of all received packets, set to 1 by TestEntropyCalculator 3940 // since ack is truncated. 3941 0x01, 3942 // 2-byte largest observed packet sequence number. 3943 // Expected to be 510 (0x1FE), since only 255 nack ranges can fit. 3944 0xFE, 0x01, 3945 // Zero delta time. 3946 0x0, 0x0, 3947 // num missing packet ranges (limited to 255 by size of this field). 3948 0xFF, 3949 // {missing packet delta, further missing packets in range} 3950 // 6 nack ranges x 42 + 3 nack ranges 3951 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3952 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3953 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3954 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3955 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3956 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3957 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3958 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3959 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3960 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3961 3962 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3963 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3964 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3965 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3966 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3967 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3968 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3969 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3970 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3971 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3972 3973 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3974 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3975 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3976 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3977 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3978 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3979 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3980 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3981 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3982 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3983 3984 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3985 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3986 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3987 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3988 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3989 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3990 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3991 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3992 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3993 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3994 3995 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3996 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3997 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 3998 3999 // 0 revived packets. 4000 0x00, 4001 }; 4002 4003 scoped_ptr<QuicPacket> data( 4004 framer_.BuildDataPacket(header, frames, kMaxPacketSize).packet); 4005 ASSERT_TRUE(data != NULL); 4006 4007 test::CompareCharArraysWithHexError("constructed packet", 4008 data->data(), data->length(), 4009 AsChars(packet), arraysize(packet)); 4010} 4011 4012 4013TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacketv22) { 4014 if (version_ > QUIC_VERSION_22) { 4015 return; 4016 } 4017 QuicPacketHeader header; 4018 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4019 header.public_header.reset_flag = false; 4020 header.public_header.version_flag = false; 4021 header.fec_flag = false; 4022 header.entropy_flag = true; 4023 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 4024 header.fec_group = 0; 4025 4026 QuicAckFrame ack_frame; 4027 // This entropy hash is different from what shows up in the packet below, 4028 // since entropy is recomputed by the framer on ack truncation (by 4029 // TestEntropyCalculator for this test.) 4030 ack_frame.entropy_hash = 0x43; 4031 ack_frame.largest_observed = 2 * 300; 4032 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 4033 for (size_t i = 1; i < 2 * 300; i += 2) { 4034 ack_frame.missing_packets.insert(i); 4035 } 4036 4037 QuicFrames frames; 4038 frames.push_back(QuicFrame(&ack_frame)); 4039 4040 unsigned char packet[] = { 4041 // public flags (8 byte connection_id) 4042 0x3C, 4043 // connection_id 4044 0x10, 0x32, 0x54, 0x76, 4045 0x98, 0xBA, 0xDC, 0xFE, 4046 // packet sequence number 4047 0xA8, 0x9A, 0x78, 0x56, 4048 0x34, 0x12, 4049 // private flags (entropy) 4050 0x01, 4051 4052 // frame type (ack frame) 4053 // (has nacks, is truncated, 2 byte largest observed, 1 byte delta) 4054 0x74, 4055 // entropy hash of all received packets, set to 1 by TestEntropyCalculator 4056 // since ack is truncated. 4057 0x01, 4058 // 2-byte largest observed packet sequence number. 4059 // Expected to be 12 (0x0C), since only 6 nack ranges can fit. 4060 0x0C, 0x00, 4061 // Zero delta time. 4062 0x0, 0x0, 4063 // num missing packet ranges (limited to 6 by packet size of 37). 4064 0x06, 4065 // {missing packet delta, further missing packets in range} 4066 // 6 nack ranges 4067 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 4068 // 0 revived packets. 4069 0x00, 4070 }; 4071 4072 scoped_ptr<QuicPacket> data( 4073 framer_.BuildDataPacket(header, frames, 37u).packet); 4074 ASSERT_TRUE(data != NULL); 4075 // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks. 4076 EXPECT_EQ(36u, data->length()); 4077 test::CompareCharArraysWithHexError("constructed packet", 4078 data->data(), data->length(), 4079 AsChars(packet), arraysize(packet)); 4080} 4081 4082TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) { 4083 if (version_ <= QUIC_VERSION_22) { 4084 return; 4085 } 4086 QuicPacketHeader header; 4087 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4088 header.public_header.reset_flag = false; 4089 header.public_header.version_flag = false; 4090 header.fec_flag = false; 4091 header.entropy_flag = true; 4092 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 4093 header.fec_group = 0; 4094 4095 QuicAckFrame ack_frame; 4096 // This entropy hash is different from what shows up in the packet below, 4097 // since entropy is recomputed by the framer on ack truncation (by 4098 // TestEntropyCalculator for this test.) 4099 ack_frame.entropy_hash = 0x43; 4100 ack_frame.largest_observed = 2 * 300; 4101 ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero(); 4102 for (size_t i = 1; i < 2 * 300; i += 2) { 4103 ack_frame.missing_packets.insert(i); 4104 } 4105 4106 QuicFrames frames; 4107 frames.push_back(QuicFrame(&ack_frame)); 4108 4109 unsigned char packet[] = { 4110 // public flags (8 byte connection_id) 4111 0x3C, 4112 // connection_id 4113 0x10, 0x32, 0x54, 0x76, 4114 0x98, 0xBA, 0xDC, 0xFE, 4115 // packet sequence number 4116 0xA8, 0x9A, 0x78, 0x56, 4117 0x34, 0x12, 4118 // private flags (entropy) 4119 0x01, 4120 4121 // frame type (ack frame) 4122 // (has nacks, is truncated, 2 byte largest observed, 1 byte delta) 4123 0x74, 4124 // entropy hash of all received packets, set to 1 by TestEntropyCalculator 4125 // since ack is truncated. 4126 0x01, 4127 // 2-byte largest observed packet sequence number. 4128 // Expected to be 12 (0x0C), since only 6 nack ranges can fit. 4129 0x0C, 0x00, 4130 // Zero delta time. 4131 0x0, 0x0, 4132 // num missing packet ranges (limited to 6 by packet size of 37). 4133 0x06, 4134 // {missing packet delta, further missing packets in range} 4135 // 6 nack ranges 4136 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 4137 // 0 revived packets. 4138 0x00, 4139 }; 4140 4141 scoped_ptr<QuicPacket> data( 4142 framer_.BuildDataPacket(header, frames, 37u).packet); 4143 ASSERT_TRUE(data != NULL); 4144 // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks. 4145 EXPECT_EQ(36u, data->length()); 4146 test::CompareCharArraysWithHexError("constructed packet", 4147 data->data(), data->length(), 4148 AsChars(packet), arraysize(packet)); 4149} 4150 4151TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketTCP) { 4152 QuicPacketHeader header; 4153 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4154 header.public_header.reset_flag = false; 4155 header.public_header.version_flag = false; 4156 header.fec_flag = false; 4157 header.entropy_flag = false; 4158 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4159 header.fec_group = 0; 4160 4161 QuicCongestionFeedbackFrame congestion_feedback_frame; 4162 congestion_feedback_frame.type = kTCP; 4163 congestion_feedback_frame.tcp.receive_window = 0x4030; 4164 4165 QuicFrames frames; 4166 frames.push_back(QuicFrame(&congestion_feedback_frame)); 4167 4168 unsigned char packet[] = { 4169 // public flags (8 byte connection_id) 4170 0x3C, 4171 // connection_id 4172 0x10, 0x32, 0x54, 0x76, 4173 0x98, 0xBA, 0xDC, 0xFE, 4174 // packet sequence number 4175 0xBC, 0x9A, 0x78, 0x56, 4176 0x34, 0x12, 4177 // private flags 4178 0x00, 4179 4180 // frame type (congestion feedback frame) 4181 0x20, 4182 // congestion feedback type (TCP) 4183 0x00, 4184 // TCP receive window 4185 0x03, 0x04, 4186 }; 4187 4188 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4189 ASSERT_TRUE(data != NULL); 4190 4191 test::CompareCharArraysWithHexError("constructed packet", 4192 data->data(), data->length(), 4193 AsChars(packet), arraysize(packet)); 4194} 4195 4196TEST_P(QuicFramerTest, BuildStopWaitingPacket) { 4197 QuicPacketHeader header; 4198 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4199 header.public_header.reset_flag = false; 4200 header.public_header.version_flag = false; 4201 header.fec_flag = false; 4202 header.entropy_flag = true; 4203 header.packet_sequence_number = GG_UINT64_C(0x770123456789AA8); 4204 header.fec_group = 0; 4205 4206 QuicStopWaitingFrame stop_waiting_frame; 4207 stop_waiting_frame.entropy_hash = 0x14; 4208 stop_waiting_frame.least_unacked = GG_UINT64_C(0x770123456789AA0); 4209 4210 QuicFrames frames; 4211 frames.push_back(QuicFrame(&stop_waiting_frame)); 4212 4213 unsigned char packet[] = { 4214 // public flags (8 byte connection_id) 4215 0x3C, 4216 // connection_id 4217 0x10, 0x32, 0x54, 0x76, 4218 0x98, 0xBA, 0xDC, 0xFE, 4219 // packet sequence number 4220 0xA8, 0x9A, 0x78, 0x56, 4221 0x34, 0x12, 4222 // private flags (entropy) 4223 0x01, 4224 4225 // frame type (stop waiting frame) 4226 0x06, 4227 // entropy hash of sent packets till least awaiting - 1. 4228 0x14, 4229 // least packet sequence number awaiting an ack, delta from sequence number. 4230 0x08, 0x00, 0x00, 0x00, 4231 0x00, 0x00, 4232 }; 4233 4234 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4235 ASSERT_TRUE(data != NULL); 4236 4237 test::CompareCharArraysWithHexError("constructed packet", 4238 data->data(), data->length(), 4239 AsChars(packet), arraysize(packet)); 4240} 4241 4242TEST_P(QuicFramerTest, BuildCongestionFeedbackFramePacketInvalidFeedback) { 4243 QuicPacketHeader header; 4244 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4245 header.public_header.reset_flag = false; 4246 header.public_header.version_flag = false; 4247 header.fec_flag = false; 4248 header.entropy_flag = false; 4249 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4250 header.fec_group = 0; 4251 4252 QuicCongestionFeedbackFrame congestion_feedback_frame; 4253 congestion_feedback_frame.type = 4254 static_cast<CongestionFeedbackType>(kTCP + 1); 4255 4256 QuicFrames frames; 4257 frames.push_back(QuicFrame(&congestion_feedback_frame)); 4258 4259 scoped_ptr<QuicPacket> data; 4260 EXPECT_DFATAL( 4261 data.reset(BuildDataPacket(header, frames)), 4262 "AppendCongestionFeedbackFrame failed"); 4263 ASSERT_TRUE(data == NULL); 4264} 4265 4266TEST_P(QuicFramerTest, BuildRstFramePacketQuic) { 4267 QuicPacketHeader header; 4268 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4269 header.public_header.reset_flag = false; 4270 header.public_header.version_flag = false; 4271 header.fec_flag = false; 4272 header.entropy_flag = false; 4273 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4274 header.fec_group = 0; 4275 4276 QuicRstStreamFrame rst_frame; 4277 rst_frame.stream_id = 0x01020304; 4278 rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708); 4279 rst_frame.error_details = "because I can"; 4280 rst_frame.byte_offset = 0x0807060504030201; 4281 4282 unsigned char packet[] = { 4283 // public flags (8 byte connection_id) 4284 0x3C, 4285 // connection_id 4286 0x10, 0x32, 0x54, 0x76, 4287 0x98, 0xBA, 0xDC, 0xFE, 4288 // packet sequence number 4289 0xBC, 0x9A, 0x78, 0x56, 4290 0x34, 0x12, 4291 // private flags 4292 0x00, 4293 4294 // frame type (rst stream frame) 4295 0x01, 4296 // stream id 4297 0x04, 0x03, 0x02, 0x01, 4298 // sent byte offset 4299 0x01, 0x02, 0x03, 0x04, 4300 0x05, 0x06, 0x07, 0x08, 4301 // error code 4302 0x08, 0x07, 0x06, 0x05, 4303 // error details length 4304 0x0d, 0x00, 4305 // error details 4306 'b', 'e', 'c', 'a', 4307 'u', 's', 'e', ' ', 4308 'I', ' ', 'c', 'a', 4309 'n', 4310 }; 4311 4312 QuicFrames frames; 4313 frames.push_back(QuicFrame(&rst_frame)); 4314 4315 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4316 ASSERT_TRUE(data != NULL); 4317 4318 test::CompareCharArraysWithHexError("constructed packet", 4319 data->data(), data->length(), 4320 AsChars(packet), arraysize(packet)); 4321} 4322 4323TEST_P(QuicFramerTest, BuildCloseFramePacket) { 4324 QuicPacketHeader header; 4325 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4326 header.public_header.reset_flag = false; 4327 header.public_header.version_flag = false; 4328 header.fec_flag = false; 4329 header.entropy_flag = true; 4330 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4331 header.fec_group = 0; 4332 4333 QuicConnectionCloseFrame close_frame; 4334 close_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 4335 close_frame.error_details = "because I can"; 4336 4337 QuicFrames frames; 4338 frames.push_back(QuicFrame(&close_frame)); 4339 4340 unsigned char packet[] = { 4341 // public flags (8 byte connection_id) 4342 0x3C, 4343 // connection_id 4344 0x10, 0x32, 0x54, 0x76, 4345 0x98, 0xBA, 0xDC, 0xFE, 4346 // packet sequence number 4347 0xBC, 0x9A, 0x78, 0x56, 4348 0x34, 0x12, 4349 // private flags (entropy) 4350 0x01, 4351 4352 // frame type (connection close frame) 4353 0x02, 4354 // error code 4355 0x08, 0x07, 0x06, 0x05, 4356 // error details length 4357 0x0d, 0x00, 4358 // error details 4359 'b', 'e', 'c', 'a', 4360 'u', 's', 'e', ' ', 4361 'I', ' ', 'c', 'a', 4362 'n', 4363 }; 4364 4365 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4366 ASSERT_TRUE(data != NULL); 4367 4368 test::CompareCharArraysWithHexError("constructed packet", 4369 data->data(), data->length(), 4370 AsChars(packet), arraysize(packet)); 4371} 4372 4373TEST_P(QuicFramerTest, BuildGoAwayPacket) { 4374 QuicPacketHeader header; 4375 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4376 header.public_header.reset_flag = false; 4377 header.public_header.version_flag = false; 4378 header.fec_flag = false; 4379 header.entropy_flag = true; 4380 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4381 header.fec_group = 0; 4382 4383 QuicGoAwayFrame goaway_frame; 4384 goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 4385 goaway_frame.last_good_stream_id = 0x01020304; 4386 goaway_frame.reason_phrase = "because I can"; 4387 4388 QuicFrames frames; 4389 frames.push_back(QuicFrame(&goaway_frame)); 4390 4391 unsigned char packet[] = { 4392 // public flags (8 byte connection_id) 4393 0x3C, 4394 // connection_id 4395 0x10, 0x32, 0x54, 0x76, 4396 0x98, 0xBA, 0xDC, 0xFE, 4397 // packet sequence number 4398 0xBC, 0x9A, 0x78, 0x56, 4399 0x34, 0x12, 4400 // private flags(entropy) 4401 0x01, 4402 4403 // frame type (go away frame) 4404 0x03, 4405 // error code 4406 0x08, 0x07, 0x06, 0x05, 4407 // stream id 4408 0x04, 0x03, 0x02, 0x01, 4409 // error details length 4410 0x0d, 0x00, 4411 // error details 4412 'b', 'e', 'c', 'a', 4413 'u', 's', 'e', ' ', 4414 'I', ' ', 'c', 'a', 4415 'n', 4416 }; 4417 4418 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4419 ASSERT_TRUE(data != NULL); 4420 4421 test::CompareCharArraysWithHexError("constructed packet", 4422 data->data(), data->length(), 4423 AsChars(packet), arraysize(packet)); 4424} 4425 4426TEST_P(QuicFramerTest, BuildWindowUpdatePacket) { 4427 QuicPacketHeader header; 4428 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4429 header.public_header.reset_flag = false; 4430 header.public_header.version_flag = false; 4431 header.fec_flag = false; 4432 header.entropy_flag = true; 4433 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4434 header.fec_group = 0; 4435 4436 QuicWindowUpdateFrame window_update_frame; 4437 window_update_frame.stream_id = 0x01020304; 4438 window_update_frame.byte_offset = 0x1122334455667788; 4439 4440 QuicFrames frames; 4441 frames.push_back(QuicFrame(&window_update_frame)); 4442 4443 unsigned char packet[] = { 4444 // public flags (8 byte connection_id) 4445 0x3C, 4446 // connection_id 4447 0x10, 0x32, 0x54, 0x76, 4448 0x98, 0xBA, 0xDC, 0xFE, 4449 // packet sequence number 4450 0xBC, 0x9A, 0x78, 0x56, 4451 0x34, 0x12, 4452 // private flags(entropy) 4453 0x01, 4454 4455 // frame type (window update frame) 4456 0x04, 4457 // stream id 4458 0x04, 0x03, 0x02, 0x01, 4459 // byte offset 4460 0x88, 0x77, 0x66, 0x55, 4461 0x44, 0x33, 0x22, 0x11, 4462 }; 4463 4464 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4465 ASSERT_TRUE(data != NULL); 4466 4467 test::CompareCharArraysWithHexError("constructed packet", data->data(), 4468 data->length(), AsChars(packet), 4469 arraysize(packet)); 4470} 4471 4472TEST_P(QuicFramerTest, BuildBlockedPacket) { 4473 QuicPacketHeader header; 4474 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4475 header.public_header.reset_flag = false; 4476 header.public_header.version_flag = false; 4477 header.fec_flag = false; 4478 header.entropy_flag = true; 4479 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4480 header.fec_group = 0; 4481 4482 QuicBlockedFrame blocked_frame; 4483 blocked_frame.stream_id = 0x01020304; 4484 4485 QuicFrames frames; 4486 frames.push_back(QuicFrame(&blocked_frame)); 4487 4488 unsigned char packet[] = { 4489 // public flags (8 byte connection_id) 4490 0x3C, 4491 // connection_id 4492 0x10, 0x32, 0x54, 0x76, 4493 0x98, 0xBA, 0xDC, 0xFE, 4494 // packet sequence number 4495 0xBC, 0x9A, 0x78, 0x56, 4496 0x34, 0x12, 4497 // private flags(entropy) 4498 0x01, 4499 4500 // frame type (blocked frame) 4501 0x05, 4502 // stream id 4503 0x04, 0x03, 0x02, 0x01, 4504 }; 4505 4506 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4507 ASSERT_TRUE(data != NULL); 4508 4509 test::CompareCharArraysWithHexError("constructed packet", data->data(), 4510 data->length(), AsChars(packet), 4511 arraysize(packet)); 4512} 4513 4514TEST_P(QuicFramerTest, BuildPingPacket) { 4515 QuicPacketHeader header; 4516 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4517 header.public_header.reset_flag = false; 4518 header.public_header.version_flag = false; 4519 header.fec_flag = false; 4520 header.entropy_flag = true; 4521 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4522 header.fec_group = 0; 4523 4524 QuicPingFrame ping_frame; 4525 4526 QuicFrames frames; 4527 frames.push_back(QuicFrame(&ping_frame)); 4528 4529 unsigned char packet[] = { 4530 // public flags (8 byte connection_id) 4531 0x3C, 4532 // connection_id 4533 0x10, 0x32, 0x54, 0x76, 4534 0x98, 0xBA, 0xDC, 0xFE, 4535 // packet sequence number 4536 0xBC, 0x9A, 0x78, 0x56, 4537 0x34, 0x12, 4538 // private flags(entropy) 4539 0x01, 4540 4541 // frame type (ping frame) 4542 0x07, 4543 }; 4544 4545 if (version_ >= QUIC_VERSION_18) { 4546 scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames)); 4547 ASSERT_TRUE(data != NULL); 4548 4549 test::CompareCharArraysWithHexError("constructed packet", data->data(), 4550 data->length(), AsChars(packet), 4551 arraysize(packet)); 4552 } else { 4553 string expected_error = 4554 "Attempt to add a PingFrame in " + QuicVersionToString(version_); 4555 EXPECT_DFATAL(BuildDataPacket(header, frames), 4556 expected_error); 4557 return; 4558 } 4559} 4560 4561TEST_P(QuicFramerTest, BuildPublicResetPacket) { 4562 QuicPublicResetPacket reset_packet; 4563 reset_packet.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4564 reset_packet.public_header.reset_flag = true; 4565 reset_packet.public_header.version_flag = false; 4566 reset_packet.rejected_sequence_number = GG_UINT64_C(0x123456789ABC); 4567 reset_packet.nonce_proof = GG_UINT64_C(0xABCDEF0123456789); 4568 4569 unsigned char packet[] = { 4570 // public flags (public reset, 8 byte ConnectionId) 4571 0x0E, 4572 // connection_id 4573 0x10, 0x32, 0x54, 0x76, 4574 0x98, 0xBA, 0xDC, 0xFE, 4575 // message tag (kPRST) 4576 'P', 'R', 'S', 'T', 4577 // num_entries (2) + padding 4578 0x02, 0x00, 0x00, 0x00, 4579 // tag kRNON 4580 'R', 'N', 'O', 'N', 4581 // end offset 8 4582 0x08, 0x00, 0x00, 0x00, 4583 // tag kRSEQ 4584 'R', 'S', 'E', 'Q', 4585 // end offset 16 4586 0x10, 0x00, 0x00, 0x00, 4587 // nonce proof 4588 0x89, 0x67, 0x45, 0x23, 4589 0x01, 0xEF, 0xCD, 0xAB, 4590 // rejected sequence number 4591 0xBC, 0x9A, 0x78, 0x56, 4592 0x34, 0x12, 0x00, 0x00, 4593 }; 4594 4595 scoped_ptr<QuicEncryptedPacket> data( 4596 framer_.BuildPublicResetPacket(reset_packet)); 4597 ASSERT_TRUE(data != NULL); 4598 4599 test::CompareCharArraysWithHexError("constructed packet", 4600 data->data(), data->length(), 4601 AsChars(packet), arraysize(packet)); 4602} 4603 4604TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) { 4605 QuicPublicResetPacket reset_packet; 4606 reset_packet.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4607 reset_packet.public_header.reset_flag = true; 4608 reset_packet.public_header.version_flag = false; 4609 reset_packet.rejected_sequence_number = GG_UINT64_C(0x123456789ABC); 4610 reset_packet.nonce_proof = GG_UINT64_C(0xABCDEF0123456789); 4611 reset_packet.client_address = IPEndPoint(Loopback4(), 0x1234); 4612 4613 unsigned char packet[] = { 4614 // public flags (public reset, 8 byte ConnectionId) 4615 0x0E, 4616 // connection_id 4617 0x10, 0x32, 0x54, 0x76, 4618 0x98, 0xBA, 0xDC, 0xFE, 4619 // message tag (kPRST) 4620 'P', 'R', 'S', 'T', 4621 // num_entries (3) + padding 4622 0x03, 0x00, 0x00, 0x00, 4623 // tag kRNON 4624 'R', 'N', 'O', 'N', 4625 // end offset 8 4626 0x08, 0x00, 0x00, 0x00, 4627 // tag kRSEQ 4628 'R', 'S', 'E', 'Q', 4629 // end offset 16 4630 0x10, 0x00, 0x00, 0x00, 4631 // tag kCADR 4632 'C', 'A', 'D', 'R', 4633 // end offset 24 4634 0x18, 0x00, 0x00, 0x00, 4635 // nonce proof 4636 0x89, 0x67, 0x45, 0x23, 4637 0x01, 0xEF, 0xCD, 0xAB, 4638 // rejected sequence number 4639 0xBC, 0x9A, 0x78, 0x56, 4640 0x34, 0x12, 0x00, 0x00, 4641 // client address 4642 0x02, 0x00, 4643 0x7F, 0x00, 0x00, 0x01, 4644 0x34, 0x12, 4645 }; 4646 4647 scoped_ptr<QuicEncryptedPacket> data( 4648 framer_.BuildPublicResetPacket(reset_packet)); 4649 ASSERT_TRUE(data != NULL); 4650 4651 test::CompareCharArraysWithHexError("constructed packet", 4652 data->data(), data->length(), 4653 AsChars(packet), arraysize(packet)); 4654} 4655 4656TEST_P(QuicFramerTest, BuildFecPacket) { 4657 QuicPacketHeader header; 4658 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4659 header.public_header.reset_flag = false; 4660 header.public_header.version_flag = false; 4661 header.fec_flag = true; 4662 header.entropy_flag = true; 4663 header.packet_sequence_number = (GG_UINT64_C(0x123456789ABC)); 4664 header.is_in_fec_group = IN_FEC_GROUP; 4665 header.fec_group = GG_UINT64_C(0x123456789ABB);; 4666 4667 QuicFecData fec_data; 4668 fec_data.fec_group = 1; 4669 fec_data.redundancy = "abcdefghijklmnop"; 4670 4671 unsigned char packet[] = { 4672 // public flags (8 byte connection_id) 4673 0x3C, 4674 // connection_id 4675 0x10, 0x32, 0x54, 0x76, 4676 0x98, 0xBA, 0xDC, 0xFE, 4677 // packet sequence number 4678 0xBC, 0x9A, 0x78, 0x56, 4679 0x34, 0x12, 4680 // private flags (entropy & fec group & fec packet) 4681 0x07, 4682 // first fec protected packet offset 4683 0x01, 4684 4685 // redundancy 4686 'a', 'b', 'c', 'd', 4687 'e', 'f', 'g', 'h', 4688 'i', 'j', 'k', 'l', 4689 'm', 'n', 'o', 'p', 4690 }; 4691 4692 scoped_ptr<QuicPacket> data( 4693 framer_.BuildFecPacket(header, fec_data).packet); 4694 ASSERT_TRUE(data != NULL); 4695 4696 test::CompareCharArraysWithHexError("constructed packet", 4697 data->data(), data->length(), 4698 AsChars(packet), arraysize(packet)); 4699} 4700 4701TEST_P(QuicFramerTest, EncryptPacket) { 4702 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC); 4703 unsigned char packet[] = { 4704 // public flags (8 byte connection_id) 4705 0x3C, 4706 // connection_id 4707 0x10, 0x32, 0x54, 0x76, 4708 0x98, 0xBA, 0xDC, 0xFE, 4709 // packet sequence number 4710 0xBC, 0x9A, 0x78, 0x56, 4711 0x34, 0x12, 4712 // private flags (fec group & fec packet) 4713 0x06, 4714 // first fec protected packet offset 4715 0x01, 4716 4717 // redundancy 4718 'a', 'b', 'c', 'd', 4719 'e', 'f', 'g', 'h', 4720 'i', 'j', 'k', 'l', 4721 'm', 'n', 'o', 'p', 4722 }; 4723 4724 scoped_ptr<QuicPacket> raw( 4725 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false, 4726 PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, 4727 PACKET_6BYTE_SEQUENCE_NUMBER)); 4728 scoped_ptr<QuicEncryptedPacket> encrypted( 4729 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); 4730 4731 ASSERT_TRUE(encrypted.get() != NULL); 4732 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); 4733} 4734 4735TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) { 4736 QuicPacketSequenceNumber sequence_number = GG_UINT64_C(0x123456789ABC); 4737 unsigned char packet[] = { 4738 // public flags (version, 8 byte connection_id) 4739 0x3D, 4740 // connection_id 4741 0x10, 0x32, 0x54, 0x76, 4742 0x98, 0xBA, 0xDC, 0xFE, 4743 // version tag 4744 'Q', '.', '1', '0', 4745 // packet sequence number 4746 0xBC, 0x9A, 0x78, 0x56, 4747 0x34, 0x12, 4748 // private flags (fec group & fec flags) 4749 0x06, 4750 // first fec protected packet offset 4751 0x01, 4752 4753 // redundancy 4754 'a', 'b', 'c', 'd', 4755 'e', 'f', 'g', 'h', 4756 'i', 'j', 'k', 'l', 4757 'm', 'n', 'o', 'p', 4758 }; 4759 4760 scoped_ptr<QuicPacket> raw( 4761 QuicPacket::NewDataPacket(AsChars(packet), arraysize(packet), false, 4762 PACKET_8BYTE_CONNECTION_ID, kIncludeVersion, 4763 PACKET_6BYTE_SEQUENCE_NUMBER)); 4764 scoped_ptr<QuicEncryptedPacket> encrypted( 4765 framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number, *raw)); 4766 4767 ASSERT_TRUE(encrypted.get() != NULL); 4768 EXPECT_TRUE(CheckEncryption(sequence_number, raw.get())); 4769} 4770 4771TEST_P(QuicFramerTest, AckTruncationLargePacket) { 4772 QuicPacketHeader header; 4773 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4774 header.public_header.reset_flag = false; 4775 header.public_header.version_flag = false; 4776 header.fec_flag = false; 4777 header.entropy_flag = false; 4778 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4779 header.fec_group = 0; 4780 4781 // Create a packet with just the ack. 4782 QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(300, 0u); 4783 QuicFrame frame; 4784 frame.type = ACK_FRAME; 4785 frame.ack_frame = &ack_frame; 4786 QuicFrames frames; 4787 frames.push_back(frame); 4788 4789 // Build an ack packet with truncation due to limit in number of nack ranges. 4790 scoped_ptr<QuicPacket> raw_ack_packet( 4791 framer_.BuildDataPacket(header, frames, kMaxPacketSize).packet); 4792 ASSERT_TRUE(raw_ack_packet != NULL); 4793 scoped_ptr<QuicEncryptedPacket> ack_packet( 4794 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 4795 *raw_ack_packet)); 4796 // Now make sure we can turn our ack packet back into an ack frame. 4797 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 4798 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 4799 QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0]; 4800 EXPECT_TRUE(processed_ack_frame.is_truncated); 4801 EXPECT_EQ(510u, processed_ack_frame.largest_observed); 4802 ASSERT_EQ(255u, processed_ack_frame.missing_packets.size()); 4803 SequenceNumberSet::const_iterator missing_iter = 4804 processed_ack_frame.missing_packets.begin(); 4805 EXPECT_EQ(1u, *missing_iter); 4806 SequenceNumberSet::const_reverse_iterator last_missing_iter = 4807 processed_ack_frame.missing_packets.rbegin(); 4808 EXPECT_EQ(509u, *last_missing_iter); 4809} 4810 4811TEST_P(QuicFramerTest, AckTruncationSmallPacketv22) { 4812 if (version_ > QUIC_VERSION_22) { 4813 return; 4814 } 4815 QuicPacketHeader header; 4816 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4817 header.public_header.reset_flag = false; 4818 header.public_header.version_flag = false; 4819 header.fec_flag = false; 4820 header.entropy_flag = false; 4821 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4822 header.fec_group = 0; 4823 4824 // Create a packet with just the ack. 4825 QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(300, 0u); 4826 QuicFrame frame; 4827 frame.type = ACK_FRAME; 4828 frame.ack_frame = &ack_frame; 4829 QuicFrames frames; 4830 frames.push_back(frame); 4831 4832 // Build an ack packet with truncation due to limit in number of nack ranges. 4833 scoped_ptr<QuicPacket> raw_ack_packet( 4834 framer_.BuildDataPacket(header, frames, 500).packet); 4835 ASSERT_TRUE(raw_ack_packet != NULL); 4836 scoped_ptr<QuicEncryptedPacket> ack_packet( 4837 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 4838 *raw_ack_packet)); 4839 // Now make sure we can turn our ack packet back into an ack frame. 4840 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 4841 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 4842 QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0]; 4843 EXPECT_TRUE(processed_ack_frame.is_truncated); 4844 EXPECT_EQ(476u, processed_ack_frame.largest_observed); 4845 ASSERT_EQ(238u, processed_ack_frame.missing_packets.size()); 4846 SequenceNumberSet::const_iterator missing_iter = 4847 processed_ack_frame.missing_packets.begin(); 4848 EXPECT_EQ(1u, *missing_iter); 4849 SequenceNumberSet::const_reverse_iterator last_missing_iter = 4850 processed_ack_frame.missing_packets.rbegin(); 4851 EXPECT_EQ(475u, *last_missing_iter); 4852} 4853 4854 4855TEST_P(QuicFramerTest, AckTruncationSmallPacket) { 4856 if (version_ <= QUIC_VERSION_22) { 4857 return; 4858 } 4859 QuicPacketHeader header; 4860 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4861 header.public_header.reset_flag = false; 4862 header.public_header.version_flag = false; 4863 header.fec_flag = false; 4864 header.entropy_flag = false; 4865 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4866 header.fec_group = 0; 4867 4868 // Create a packet with just the ack. 4869 QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(300, 0u); 4870 QuicFrame frame; 4871 frame.type = ACK_FRAME; 4872 frame.ack_frame = &ack_frame; 4873 QuicFrames frames; 4874 frames.push_back(frame); 4875 4876 // Build an ack packet with truncation due to limit in number of nack ranges. 4877 scoped_ptr<QuicPacket> raw_ack_packet( 4878 framer_.BuildDataPacket(header, frames, 500).packet); 4879 ASSERT_TRUE(raw_ack_packet != NULL); 4880 scoped_ptr<QuicEncryptedPacket> ack_packet( 4881 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 4882 *raw_ack_packet)); 4883 // Now make sure we can turn our ack packet back into an ack frame. 4884 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 4885 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 4886 QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0]; 4887 EXPECT_TRUE(processed_ack_frame.is_truncated); 4888 EXPECT_EQ(476u, processed_ack_frame.largest_observed); 4889 ASSERT_EQ(238u, processed_ack_frame.missing_packets.size()); 4890 SequenceNumberSet::const_iterator missing_iter = 4891 processed_ack_frame.missing_packets.begin(); 4892 EXPECT_EQ(1u, *missing_iter); 4893 SequenceNumberSet::const_reverse_iterator last_missing_iter = 4894 processed_ack_frame.missing_packets.rbegin(); 4895 EXPECT_EQ(475u, *last_missing_iter); 4896} 4897 4898TEST_P(QuicFramerTest, CleanTruncation) { 4899 QuicPacketHeader header; 4900 header.public_header.connection_id = GG_UINT64_C(0xFEDCBA9876543210); 4901 header.public_header.reset_flag = false; 4902 header.public_header.version_flag = false; 4903 header.fec_flag = false; 4904 header.entropy_flag = true; 4905 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 4906 header.fec_group = 0; 4907 4908 QuicAckFrame ack_frame; 4909 ack_frame.largest_observed = 201; 4910 for (uint64 i = 1; i < ack_frame.largest_observed; ++i) { 4911 ack_frame.missing_packets.insert(i); 4912 } 4913 4914 // Create a packet with just the ack. 4915 QuicFrame frame; 4916 frame.type = ACK_FRAME; 4917 frame.ack_frame = &ack_frame; 4918 QuicFrames frames; 4919 frames.push_back(frame); 4920 4921 scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames)); 4922 ASSERT_TRUE(raw_ack_packet != NULL); 4923 4924 scoped_ptr<QuicEncryptedPacket> ack_packet( 4925 framer_.EncryptPacket(ENCRYPTION_NONE, header.packet_sequence_number, 4926 *raw_ack_packet)); 4927 4928 // Now make sure we can turn our ack packet back into an ack frame. 4929 ASSERT_TRUE(framer_.ProcessPacket(*ack_packet)); 4930 4931 // Test for clean truncation of the ack by comparing the length of the 4932 // original packets to the re-serialized packets. 4933 frames.clear(); 4934 frame.type = ACK_FRAME; 4935 frame.ack_frame = visitor_.ack_frames_[0]; 4936 frames.push_back(frame); 4937 4938 size_t original_raw_length = raw_ack_packet->length(); 4939 raw_ack_packet.reset(BuildDataPacket(header, frames)); 4940 ASSERT_TRUE(raw_ack_packet != NULL); 4941 EXPECT_EQ(original_raw_length, raw_ack_packet->length()); 4942 ASSERT_TRUE(raw_ack_packet != NULL); 4943} 4944 4945TEST_P(QuicFramerTest, EntropyFlagTest) { 4946 unsigned char packet[] = { 4947 // public flags (8 byte connection_id) 4948 0x3C, 4949 // connection_id 4950 0x10, 0x32, 0x54, 0x76, 4951 0x98, 0xBA, 0xDC, 0xFE, 4952 // packet sequence number 4953 0xBC, 0x9A, 0x78, 0x56, 4954 0x34, 0x12, 4955 // private flags (Entropy) 4956 0x01, 4957 4958 // frame type (stream frame with fin and no length) 4959 0xDF, 4960 // stream id 4961 0x04, 0x03, 0x02, 0x01, 4962 // offset 4963 0x54, 0x76, 0x10, 0x32, 4964 0xDC, 0xFE, 0x98, 0xBA, 4965 // data 4966 'h', 'e', 'l', 'l', 4967 'o', ' ', 'w', 'o', 4968 'r', 'l', 'd', '!', 4969 }; 4970 4971 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 4972 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 4973 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 4974 ASSERT_TRUE(visitor_.header_.get()); 4975 EXPECT_TRUE(visitor_.header_->entropy_flag); 4976 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash); 4977 EXPECT_FALSE(visitor_.header_->fec_flag); 4978}; 4979 4980TEST_P(QuicFramerTest, FecEntropyTest) { 4981 unsigned char packet[] = { 4982 // public flags (8 byte connection_id) 4983 0x3C, 4984 // connection_id 4985 0x10, 0x32, 0x54, 0x76, 4986 0x98, 0xBA, 0xDC, 0xFE, 4987 // packet sequence number 4988 0xBC, 0x9A, 0x78, 0x56, 4989 0x34, 0x12, 4990 // private flags (Entropy & fec group & FEC) 4991 0x07, 4992 // first fec protected packet offset 4993 0xFF, 4994 4995 // frame type (stream frame with fin and no length) 4996 0xDF, 4997 // stream id 4998 0x04, 0x03, 0x02, 0x01, 4999 // offset 5000 0x54, 0x76, 0x10, 0x32, 5001 0xDC, 0xFE, 0x98, 0xBA, 5002 // data 5003 'h', 'e', 'l', 'l', 5004 'o', ' ', 'w', 'o', 5005 'r', 'l', 'd', '!', 5006 }; 5007 5008 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 5009 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 5010 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 5011 ASSERT_TRUE(visitor_.header_.get()); 5012 EXPECT_TRUE(visitor_.header_->fec_flag); 5013 EXPECT_TRUE(visitor_.header_->entropy_flag); 5014 EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash); 5015}; 5016 5017TEST_P(QuicFramerTest, StopPacketProcessing) { 5018 unsigned char packet[] = { 5019 // public flags (8 byte connection_id) 5020 0x3C, 5021 // connection_id 5022 0x10, 0x32, 0x54, 0x76, 5023 0x98, 0xBA, 0xDC, 0xFE, 5024 // packet sequence number 5025 0xBC, 0x9A, 0x78, 0x56, 5026 0x34, 0x12, 5027 // Entropy 5028 0x01, 5029 5030 // frame type (stream frame with fin) 5031 0xFF, 5032 // stream id 5033 0x04, 0x03, 0x02, 0x01, 5034 // offset 5035 0x54, 0x76, 0x10, 0x32, 5036 0xDC, 0xFE, 0x98, 0xBA, 5037 // data length 5038 0x0c, 0x00, 5039 // data 5040 'h', 'e', 'l', 'l', 5041 'o', ' ', 'w', 'o', 5042 'r', 'l', 'd', '!', 5043 5044 // frame type (ack frame) 5045 0x40, 5046 // entropy hash of sent packets till least awaiting - 1. 5047 0x14, 5048 // least packet sequence number awaiting an ack 5049 0xA0, 0x9A, 0x78, 0x56, 5050 0x34, 0x12, 5051 // entropy hash of all received packets. 5052 0x43, 5053 // largest observed packet sequence number 5054 0xBF, 0x9A, 0x78, 0x56, 5055 0x34, 0x12, 5056 // num missing packets 5057 0x01, 5058 // missing packet 5059 0xBE, 0x9A, 0x78, 0x56, 5060 0x34, 0x12, 5061 }; 5062 5063 MockFramerVisitor visitor; 5064 framer_.set_visitor(&visitor); 5065 EXPECT_CALL(visitor, OnPacket()); 5066 EXPECT_CALL(visitor, OnPacketHeader(_)); 5067 EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false)); 5068 EXPECT_CALL(visitor, OnAckFrame(_)).Times(0); 5069 EXPECT_CALL(visitor, OnPacketComplete()); 5070 EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true)); 5071 5072 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 5073 EXPECT_TRUE(framer_.ProcessPacket(encrypted)); 5074 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 5075} 5076 5077} // namespace test 5078} // namespace net 5079