quic_framer_test.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include <algorithm> 6#include <vector> 7 8#include "base/hash_tables.h" 9#include "base/logging.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/port.h" 12#include "base/stl_util.h" 13#include "net/quic/quic_framer.h" 14#include "net/quic/quic_protocol.h" 15#include "net/quic/quic_utils.h" 16#include "net/quic/test_tools/quic_test_utils.h" 17 18using base::hash_set; 19using base::StringPiece; 20using std::string; 21using std::vector; 22 23namespace net { 24 25namespace test { 26 27class TestEncrypter : public QuicEncrypter { 28 public: 29 virtual ~TestEncrypter() {} 30 virtual QuicData* Encrypt(StringPiece associated_data, 31 StringPiece plaintext) { 32 associated_data_ = associated_data.as_string(); 33 plaintext_ = plaintext.as_string(); 34 return new QuicData(plaintext.data(), plaintext.length()); 35 } 36 virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) { 37 return ciphertext_size; 38 } 39 virtual size_t GetCiphertextSize(size_t plaintext_size) { 40 return plaintext_size; 41 } 42 string associated_data_; 43 string plaintext_; 44}; 45 46class TestDecrypter : public QuicDecrypter { 47 public: 48 virtual ~TestDecrypter() {} 49 virtual QuicData* Decrypt(StringPiece associated_data, 50 StringPiece ciphertext) { 51 associated_data_ = associated_data.as_string(); 52 ciphertext_ = ciphertext.as_string(); 53 return new QuicData(ciphertext.data(), ciphertext.length()); 54 } 55 string associated_data_; 56 string ciphertext_; 57}; 58 59// The offset of congestion info in our tests, given the size of our usual ack 60// frame. This does NOT work for all packets. 61const int kCongestionInfoOffset = kPacketHeaderSize + 54; 62 63class TestQuicVisitor : public ::net::QuicFramerVisitorInterface { 64 public: 65 TestQuicVisitor() 66 : error_count_(0), 67 packet_count_(0), 68 frame_count_(0), 69 fec_count_(0), 70 complete_packets_(0), 71 revived_packets_(0), 72 accept_packet_(true) { 73 } 74 75 ~TestQuicVisitor() { 76 STLDeleteElements(&stream_frames_); 77 STLDeleteElements(&ack_frames_); 78 STLDeleteElements(&fec_data_); 79 } 80 81 virtual void OnError(QuicFramer* f) { 82 DLOG(INFO) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error()) 83 << " (" << f->error() << ")"; 84 error_count_++; 85 } 86 87 virtual void OnPacket(const IPEndPoint& self_address, 88 const IPEndPoint& peer_address) { 89 self_address_ = self_address; 90 peer_address_ = peer_address; 91 } 92 93 virtual void OnRevivedPacket() { 94 revived_packets_++; 95 } 96 97 virtual bool OnPacketHeader(const QuicPacketHeader& header) { 98 packet_count_++; 99 header_.reset(new QuicPacketHeader(header)); 100 return accept_packet_; 101 } 102 103 virtual void OnStreamFrame(const QuicStreamFrame& frame) { 104 frame_count_++; 105 stream_frames_.push_back(new QuicStreamFrame(frame)); 106 } 107 108 virtual void OnFecProtectedPayload(StringPiece payload) { 109 fec_protected_payload_ = payload.as_string(); 110 } 111 112 virtual void OnAckFrame(const QuicAckFrame& frame) { 113 frame_count_++; 114 ack_frames_.push_back(new QuicAckFrame(frame)); 115 } 116 117 virtual void OnFecData(const QuicFecData& fec) { 118 fec_count_++; 119 fec_data_.push_back(new QuicFecData(fec)); 120 } 121 122 virtual void OnPacketComplete() { 123 complete_packets_++; 124 } 125 126 virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) { 127 rst_stream_frame_ = frame; 128 } 129 130 virtual void OnConnectionCloseFrame( 131 const QuicConnectionCloseFrame& frame) { 132 connection_close_frame_ = frame; 133 } 134 135 // Counters from the visitor_ callbacks. 136 int error_count_; 137 int packet_count_; 138 int frame_count_; 139 int fec_count_; 140 int complete_packets_; 141 int revived_packets_; 142 bool accept_packet_; 143 144 IPEndPoint self_address_; 145 IPEndPoint peer_address_; 146 scoped_ptr<QuicPacketHeader> header_; 147 vector<QuicStreamFrame*> stream_frames_; 148 vector<QuicAckFrame*> ack_frames_; 149 vector<QuicFecData*> fec_data_; 150 string fec_protected_payload_; 151 QuicRstStreamFrame rst_stream_frame_; 152 QuicConnectionCloseFrame connection_close_frame_; 153}; 154 155class QuicFramerTest : public ::testing::Test { 156 public: 157 QuicFramerTest() 158 : encrypter_(new test::TestEncrypter()), 159 decrypter_(new test::TestDecrypter()), 160 framer_(decrypter_, encrypter_), 161 self_address_(IPAddressNumber(), 1), 162 peer_address_(IPAddressNumber(), 2) { 163 framer_.set_visitor(&visitor_); 164 } 165 166 bool CheckEncryption(StringPiece packet) { 167 StringPiece associated_data( 168 packet.substr(kStartOfHashData, 169 kStartOfEncryptedData - kStartOfHashData)); 170 if (associated_data != encrypter_->associated_data_) { 171 LOG(ERROR) << "Encrypted incorrect associated data. expected " 172 << associated_data << " actual: " 173 << encrypter_->associated_data_; 174 return false; 175 } 176 StringPiece plaintext(packet.substr(kStartOfEncryptedData)); 177 if (plaintext != encrypter_->plaintext_) { 178 LOG(ERROR) << "Encrypted incorrect plaintext data. expected " 179 << plaintext << " actual: " 180 << encrypter_->plaintext_; 181 return false; 182 } 183 return true; 184 } 185 186 bool CheckDecryption(StringPiece packet) { 187 StringPiece associated_data( 188 packet.substr(kStartOfHashData, 189 kStartOfEncryptedData - kStartOfHashData)); 190 if (associated_data != decrypter_->associated_data_) { 191 LOG(ERROR) << "Decrypted incorrect associated data. expected " 192 << associated_data << " actual: " 193 << decrypter_->associated_data_; 194 return false; 195 } 196 StringPiece plaintext(packet.substr(kStartOfEncryptedData)); 197 if (plaintext != decrypter_->ciphertext_) { 198 LOG(ERROR) << "Decrypted incorrect chipertext data. expected " 199 << plaintext << " actual: " 200 << decrypter_->ciphertext_; 201 return false; 202 } 203 return true; 204 } 205 206 char* AsChars(unsigned char* data) { 207 return reinterpret_cast<char*>(data); 208 } 209 210 test::TestEncrypter* encrypter_; 211 test::TestDecrypter* decrypter_; 212 QuicFramer framer_; 213 test::TestQuicVisitor visitor_; 214 IPEndPoint self_address_; 215 IPEndPoint peer_address_; 216}; 217 218TEST_F(QuicFramerTest, EmptyPacket) { 219 char packet[] = { 0x00 }; 220 QuicEncryptedPacket encrypted(packet, 0, false); 221 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 222 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error()); 223} 224 225TEST_F(QuicFramerTest, LargePacket) { 226 unsigned char packet[kMaxPacketSize + 1] = { 227 // guid 228 0x10, 0x32, 0x54, 0x76, 229 0x98, 0xBA, 0xDC, 0xFE, 230 // packet id 231 0xBC, 0x9A, 0x78, 0x56, 232 0x34, 0x12, 233 // flags 234 0x00, 235 // fec group 236 0x00, 237 // frame count 238 0x01, 239 }; 240 241 memset(packet + kPacketHeaderSize, 0, kMaxPacketSize - kPacketHeaderSize + 1); 242 243 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 244 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 245 246 ASSERT_TRUE(visitor_.header_.get()); 247 // Make sure we've parsed the packet header, so we can send an error. 248 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), visitor_.header_->guid); 249 // Make sure the correct error is propogated. 250 EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error()); 251} 252 253TEST_F(QuicFramerTest, PacketHeader) { 254 unsigned char packet[] = { 255 // guid 256 0x10, 0x32, 0x54, 0x76, 257 0x98, 0xBA, 0xDC, 0xFE, 258 // packet id 259 0xBC, 0x9A, 0x78, 0x56, 260 0x34, 0x12, 261 // flags 262 0x00, 263 // fec group 264 0x00, 265 }; 266 267 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 268 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 269 270 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 271 ASSERT_TRUE(visitor_.header_.get()); 272 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), visitor_.header_->guid); 273 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 274 visitor_.header_->packet_sequence_number); 275 EXPECT_EQ(0x00, visitor_.header_->flags); 276 EXPECT_EQ(0x00, visitor_.header_->fec_group); 277 278 // Now test framing boundaries 279 for (int i = 0; i < 16; ++i) { 280 string expected_error; 281 if (i < 8) { 282 expected_error = "Unable to read GUID."; 283 } else if (i < 14) { 284 expected_error = "Unable to read sequence number."; 285 } else if (i < 15) { 286 expected_error = "Unable to read flags."; 287 } else if (i < 16) { 288 expected_error = "Unable to read fec group."; 289 } 290 291 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 292 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 293 encrypted)); 294 EXPECT_EQ(expected_error, framer_.detailed_error()); 295 EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error()); 296 } 297} 298 299TEST_F(QuicFramerTest, StreamFrame) { 300 unsigned char packet[] = { 301 // guid 302 0x10, 0x32, 0x54, 0x76, 303 0x98, 0xBA, 0xDC, 0xFE, 304 // packet id 305 0xBC, 0x9A, 0x78, 0x56, 306 0x34, 0x12, 307 // flags 308 0x00, 309 // fec group 310 0x00, 311 312 // frame count 313 0x01, 314 // frame type (stream frame) 315 0x00, 316 // stream id 317 0x04, 0x03, 0x02, 0x01, 318 // fin 319 0x01, 320 // offset 321 0x54, 0x76, 0x10, 0x32, 322 0xDC, 0xFE, 0x98, 0xBA, 323 // data length 324 0x0c, 0x00, 325 // data 326 'h', 'e', 'l', 'l', 327 'o', ' ', 'w', 'o', 328 'r', 'l', 'd', '!', 329 }; 330 331 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 332 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 333 334 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 335 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 336 ASSERT_TRUE(visitor_.header_.get()); 337 ASSERT_EQ(peer_address_, visitor_.peer_address_); 338 ASSERT_EQ(self_address_, visitor_.self_address_); 339 340 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 341 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 342 EXPECT_EQ(static_cast<uint64>(0x01020304), 343 visitor_.stream_frames_[0]->stream_id); 344 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 345 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 346 visitor_.stream_frames_[0]->offset); 347 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 348 349 // Now test framing boundaries 350 for (size_t i = kPacketHeaderSize; i < kPacketHeaderSize + 29; ++i) { 351 string expected_error; 352 if (i < kPacketHeaderSize + 1) { 353 expected_error = "Unable to read frame count."; 354 } else if (i < kPacketHeaderSize + 2) { 355 expected_error = "Unable to read frame type."; 356 } else if (i < kPacketHeaderSize + 6) { 357 expected_error = "Unable to read stream_id."; 358 } else if (i < kPacketHeaderSize + 7) { 359 expected_error = "Unable to read fin."; 360 } else if (i < kPacketHeaderSize + 15) { 361 expected_error = "Unable to read offset."; 362 } else if (i < kPacketHeaderSize + 29) { 363 expected_error = "Unable to read frame data."; 364 } 365 366 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 367 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 368 encrypted)); 369 EXPECT_EQ(expected_error, framer_.detailed_error()); 370 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 371 } 372} 373 374TEST_F(QuicFramerTest, RejectPacket) { 375 visitor_.accept_packet_ = false; 376 377 unsigned char packet[] = { 378 // guid 379 0x10, 0x32, 0x54, 0x76, 380 0x98, 0xBA, 0xDC, 0xFE, 381 // packet id 382 0xBC, 0x9A, 0x78, 0x56, 383 0x34, 0x12, 384 // flags 385 0x00, 386 // fec group 387 0x00, 388 389 // frame count 390 0x01, 391 // frame type (stream frame) 392 0x00, 393 // stream id 394 0x04, 0x03, 0x02, 0x01, 395 // fin 396 0x01, 397 // offset 398 0x54, 0x76, 0x10, 0x32, 399 0xDC, 0xFE, 0x98, 0xBA, 400 // data length 401 0x0c, 0x00, 402 // data 403 'h', 'e', 'l', 'l', 404 'o', ' ', 'w', 'o', 405 'r', 'l', 'd', '!', 406 }; 407 408 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 409 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 410 411 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 412 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 413 ASSERT_TRUE(visitor_.header_.get()); 414 ASSERT_EQ(peer_address_, visitor_.peer_address_); 415 416 ASSERT_EQ(0u, visitor_.stream_frames_.size()); 417 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 418} 419 420TEST_F(QuicFramerTest, RevivedStreamFrame) { 421 unsigned char payload[] = { 422 // frame count 423 0x01, 424 // frame type (stream frame) 425 0x00, 426 // stream id 427 0x04, 0x03, 0x02, 0x01, 428 // fin 429 0x01, 430 // offset 431 0x54, 0x76, 0x10, 0x32, 432 0xDC, 0xFE, 0x98, 0xBA, 433 // data length 434 0x0c, 0x00, 435 // data 436 'h', 'e', 'l', 'l', 437 'o', ' ', 'w', 'o', 438 'r', 'l', 'd', '!', 439 }; 440 441 QuicPacketHeader header; 442 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 443 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 444 header.flags = PACKET_FLAGS_NONE; 445 header.fec_group = 0; 446 447 // Do not encrypt the payload because the revived payload is post-encryption. 448 EXPECT_TRUE(framer_.ProcessRevivedPacket(header, 449 StringPiece(AsChars(payload), 450 arraysize(payload)))); 451 452 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 453 ASSERT_EQ(1, visitor_.revived_packets_); 454 ASSERT_TRUE(visitor_.header_.get()); 455 EXPECT_EQ(GG_UINT64_C(0xFEDCBA9876543210), visitor_.header_->guid); 456 EXPECT_EQ(GG_UINT64_C(0x123456789ABC), 457 visitor_.header_->packet_sequence_number); 458 EXPECT_EQ(0x00, visitor_.header_->flags); 459 EXPECT_EQ(0x00, visitor_.header_->fec_group); 460 461 462 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 463 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 464 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 465 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 466 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 467 visitor_.stream_frames_[0]->offset); 468 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 469} 470 471TEST_F(QuicFramerTest, StreamFrameInFecGroup) { 472 unsigned char packet[] = { 473 // guid 474 0x10, 0x32, 0x54, 0x76, 475 0x98, 0xBA, 0xDC, 0xFE, 476 // packet id 477 0xBC, 0x9A, 0x78, 0x56, 478 0x12, 0x34, 479 // flags 480 0x00, 481 // fec group 482 0x02, 483 484 // frame count 485 0x01, 486 // frame type (stream frame) 487 0x00, 488 // stream id 489 0x04, 0x03, 0x02, 0x01, 490 // fin 491 0x01, 492 // offset 493 0x54, 0x76, 0x10, 0x32, 494 0xDC, 0xFE, 0x98, 0xBA, 495 // data length 496 0x0c, 0x00, 497 // data 498 'h', 'e', 'l', 'l', 499 'o', ' ', 'w', 'o', 500 'r', 'l', 'd', '!', 501 }; 502 503 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 504 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 505 506 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 507 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 508 ASSERT_TRUE(visitor_.header_.get()); 509 EXPECT_EQ(2, visitor_.header_->fec_group); 510 EXPECT_EQ(string(AsChars(packet) + kStartOfFecProtectedData, 511 arraysize(packet) - kStartOfFecProtectedData), 512 visitor_.fec_protected_payload_); 513 ASSERT_EQ(peer_address_, visitor_.peer_address_); 514 515 ASSERT_EQ(1u, visitor_.stream_frames_.size()); 516 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 517 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id); 518 EXPECT_TRUE(visitor_.stream_frames_[0]->fin); 519 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 520 visitor_.stream_frames_[0]->offset); 521 EXPECT_EQ("hello world!", visitor_.stream_frames_[0]->data); 522} 523 524TEST_F(QuicFramerTest, AckFrame) { 525 unsigned char packet[] = { 526 // guid 527 0x10, 0x32, 0x54, 0x76, 528 0x98, 0xBA, 0xDC, 0xFE, 529 // packet id 530 0xBC, 0x9A, 0x78, 0x56, 531 0x34, 0x12, 532 // flags 533 0x00, 534 // fec group 535 0x00, 536 537 // frame count 538 0x01, 539 // frame type (ack frame) 540 0x02, 541 // largest received packet sequence number 542 0xBC, 0x9A, 0x78, 0x56, 543 0x34, 0x12, 544 // time delta 545 0x87, 0x96, 0xA5, 0xB4, 546 0xC3, 0xD2, 0xE1, 0x07, 547 // num_unacked_packets 548 0x02, 549 // unacked packet sequence number 550 0xBA, 0x9A, 0x78, 0x56, 551 0x34, 0x12, 552 // unacked packet sequence number 553 0xBB, 0x9A, 0x78, 0x56, 554 0x34, 0x12, 555 // least packet sequence number awaiting an ack 556 0xA0, 0x9A, 0x78, 0x56, 557 0x34, 0x12, 558 // num non retransmitting packets 559 0x03, 560 // non retransmitting packet sequence number 561 0xAE, 0x9A, 0x78, 0x56, 562 0x34, 0x12, 563 // non retransmitting packet sequence number 564 0xAF, 0x9A, 0x78, 0x56, 565 0x34, 0x12, 566 // non retransmitting packet sequence number 567 0xB0, 0x9A, 0x78, 0x56, 568 0x34, 0x12, 569 // congestion feedback type (none) 570 0x00, 571 }; 572 573 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 574 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 575 576 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 577 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 578 ASSERT_TRUE(visitor_.header_.get()); 579 580 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 581 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 582 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 583 EXPECT_EQ(GG_UINT64_C(0x0123456789ABC), 584 frame.received_info.largest_received); 585 EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)), 586 frame.received_info.time_received); 587 588 const hash_set<QuicPacketSequenceNumber>* sequence_nums = 589 &frame.received_info.missing_packets; 590 ASSERT_EQ(2u, sequence_nums->size()); 591 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABB))); 592 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABA))); 593 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 594 ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size()); 595 const hash_set<QuicPacketSequenceNumber>* non_retrans = 596 &frame.sent_info.non_retransmiting; 597 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AB0))); 598 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAF))); 599 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAE))); 600 ASSERT_EQ(kNone, frame.congestion_info.type); 601 602 // Now test framing boundaries 603 for (size_t i = kPacketHeaderSize; i < kPacketHeaderSize + 55; ++i) { 604 string expected_error; 605 if (i < kPacketHeaderSize + 1) { 606 expected_error = "Unable to read frame count."; 607 } else if (i < kPacketHeaderSize + 2) { 608 expected_error = "Unable to read frame type."; 609 } else if (i < kPacketHeaderSize + 8) { 610 expected_error = "Unable to read largest received."; 611 } else if (i < kPacketHeaderSize + 16) { 612 expected_error = "Unable to read time received."; 613 } else if (i < kPacketHeaderSize + 17) { 614 expected_error = "Unable to read num unacked packets."; 615 } else if (i < kPacketHeaderSize + 29) { 616 expected_error = "Unable to read sequence number in unacked packets."; 617 } else if (i < kPacketHeaderSize + 35) { 618 expected_error = "Unable to read least unacked."; 619 } else if (i < kPacketHeaderSize + 36) { 620 expected_error = "Unable to read num non-retransmitting."; 621 } else if (i < kPacketHeaderSize + 54) { 622 expected_error = "Unable to read sequence number in non-retransmitting."; 623 } else if (i < kPacketHeaderSize + 55) { 624 expected_error = "Unable to read congestion info type."; 625 } 626 627 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 628 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 629 encrypted)); 630 EXPECT_EQ(expected_error, framer_.detailed_error()); 631 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 632 } 633} 634 635TEST_F(QuicFramerTest, AckFrameTCP) { 636 unsigned char packet[] = { 637 // guid 638 0x10, 0x32, 0x54, 0x76, 639 0x98, 0xBA, 0xDC, 0xFE, 640 // packet id 641 0xBC, 0x9A, 0x78, 0x56, 642 0x34, 0x12, 643 // flags 644 0x00, 645 // fec group 646 0x00, 647 648 // frame count 649 0x01, 650 // frame type (ack frame) 651 0x02, 652 // largest received packet sequence number 653 0xBC, 0x9A, 0x78, 0x56, 654 0x34, 0x12, 655 // time delta 656 0x87, 0x96, 0xA5, 0xB4, 657 0xC3, 0xD2, 0xE1, 0x07, 658 // num_unacked_packets 659 0x02, 660 // unacked packet sequence number 661 0xBA, 0x9A, 0x78, 0x56, 662 0x34, 0x12, 663 // unacked packet sequence number 664 0xBB, 0x9A, 0x78, 0x56, 665 0x34, 0x12, 666 // least packet sequence number awaiting an ack 667 0xA0, 0x9A, 0x78, 0x56, 668 0x34, 0x12, 669 // num non retransmitting packets 670 0x03, 671 // non retransmitting packet sequence number 672 0xAE, 0x9A, 0x78, 0x56, 673 0x34, 0x12, 674 // non retransmitting packet sequence number 675 0xAF, 0x9A, 0x78, 0x56, 676 0x34, 0x12, 677 // non retransmitting packet sequence number 678 0xB0, 0x9A, 0x78, 0x56, 679 0x34, 0x12, 680 // congestion feedback type (tcp) 681 0x01, 682 // ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets 683 0x01, 0x02, 684 // ack_frame.congestion_info.tcp.receive_window 685 0x03, 0x04, 686 }; 687 688 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 689 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 690 691 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 692 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 693 ASSERT_TRUE(visitor_.header_.get()); 694 695 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 696 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 697 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 698 EXPECT_EQ(GG_UINT64_C(0x0123456789ABC), 699 frame.received_info.largest_received); 700 EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)), 701 frame.received_info.time_received); 702 703 const hash_set<QuicPacketSequenceNumber>* sequence_nums = 704 &frame.received_info.missing_packets; 705 ASSERT_EQ(2u, sequence_nums->size()); 706 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABB))); 707 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABA))); 708 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 709 ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size()); 710 const hash_set<QuicPacketSequenceNumber>* non_retrans = 711 &frame.sent_info.non_retransmiting; 712 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AB0))); 713 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAF))); 714 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAE))); 715 ASSERT_EQ(kTCP, frame.congestion_info.type); 716 EXPECT_EQ(0x0201, 717 frame.congestion_info.tcp.accumulated_number_of_lost_packets); 718 EXPECT_EQ(0x0403, frame.congestion_info.tcp.receive_window); 719 720 // Now test framing boundaries 721 for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) { 722 string expected_error; 723 if (i < kCongestionInfoOffset + 1) { 724 expected_error = "Unable to read congestion info type."; 725 } else if (i < kCongestionInfoOffset + 3) { 726 expected_error = "Unable to read accumulated number of lost packets."; 727 } else if (i < kCongestionInfoOffset + 5) { 728 expected_error = "Unable to read receive window."; 729 } 730 731 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 732 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 733 encrypted)); 734 EXPECT_EQ(expected_error, framer_.detailed_error()); 735 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 736 } 737} 738 739TEST_F(QuicFramerTest, AckFrameInterArrival) { 740 unsigned char packet[] = { 741 // guid 742 0x10, 0x32, 0x54, 0x76, 743 0x98, 0xBA, 0xDC, 0xFE, 744 // packet id 745 0xBC, 0x9A, 0x78, 0x56, 746 0x34, 0x12, 747 // flags 748 0x00, 749 // fec group 750 0x00, 751 752 // frame count 753 0x01, 754 // frame type (ack frame) 755 0x02, 756 // largest received packet sequence number 757 0xBC, 0x9A, 0x78, 0x56, 758 0x34, 0x12, 759 // time delta 760 0x87, 0x96, 0xA5, 0xB4, 761 0xC3, 0xD2, 0xE1, 0x07, 762 // num_unacked_packets 763 0x02, 764 // unacked packet sequence number 765 0xBA, 0x9A, 0x78, 0x56, 766 0x34, 0x12, 767 // unacked packet sequence number 768 0xBB, 0x9A, 0x78, 0x56, 769 0x34, 0x12, 770 // least packet sequence number awaiting an ack 771 0xA0, 0x9A, 0x78, 0x56, 772 0x34, 0x12, 773 // num non retransmitting packets 774 0x03, 775 // non retransmitting packet sequence number 776 0xAE, 0x9A, 0x78, 0x56, 777 0x34, 0x12, 778 // non retransmitting packet sequence number 779 0xAF, 0x9A, 0x78, 0x56, 780 0x34, 0x12, 781 // non retransmitting packet sequence number 782 0xB0, 0x9A, 0x78, 0x56, 783 0x34, 0x12, 784 // congestion feedback type (inter arrival) 785 0x02, 786 // accumulated_number_of_lost_packets 787 0x02, 0x03, 788 // offset_time 789 0x04, 0x05, 790 // delta_time 791 0x06, 0x07, 792 }; 793 794 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 795 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 796 797 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 798 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 799 ASSERT_TRUE(visitor_.header_.get()); 800 801 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 802 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 803 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 804 EXPECT_EQ(GG_UINT64_C(0x0123456789ABC), 805 frame.received_info.largest_received); 806 EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)), 807 frame.received_info.time_received); 808 809 const hash_set<QuicPacketSequenceNumber>* sequence_nums = 810 &frame.received_info.missing_packets; 811 ASSERT_EQ(2u, sequence_nums->size()); 812 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABB))); 813 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABA))); 814 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 815 ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size()); 816 const hash_set<QuicPacketSequenceNumber>* non_retrans = 817 &frame.sent_info.non_retransmiting; 818 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AB0))); 819 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAF))); 820 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAE))); 821 ASSERT_EQ(kInterArrival, frame.congestion_info.type); 822 EXPECT_EQ(0x0302, frame.congestion_info.inter_arrival. 823 accumulated_number_of_lost_packets); 824 EXPECT_EQ(0x0504, frame.congestion_info.inter_arrival.offset_time); 825 EXPECT_EQ(0x0706, frame.congestion_info.inter_arrival.delta_time); 826 827 // Now test framing boundaries 828 for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) { 829 string expected_error; 830 if (i < kCongestionInfoOffset + 1) { 831 expected_error = "Unable to read congestion info type."; 832 } else if (i < kCongestionInfoOffset + 3) { 833 expected_error = "Unable to read accumulated number of lost packets."; 834 } else if (i < kCongestionInfoOffset + 5) { 835 expected_error = "Unable to read offset time."; 836 } else if (i < kCongestionInfoOffset + 7) { 837 expected_error = "Unable to read delta time."; 838 } 839 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 840 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 841 encrypted)); 842 EXPECT_EQ(expected_error, framer_.detailed_error()); 843 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 844 } 845} 846 847TEST_F(QuicFramerTest, AckFrameFixRate) { 848 unsigned char packet[] = { 849 // guid 850 0x10, 0x32, 0x54, 0x76, 851 0x98, 0xBA, 0xDC, 0xFE, 852 // packet id 853 0xBC, 0x9A, 0x78, 0x56, 854 0x34, 0x12, 855 // flags 856 0x00, 857 // fec group 858 0x00, 859 860 // frame count 861 0x01, 862 // frame type (ack frame) 863 0x02, 864 // largest received packet sequence number 865 0xBC, 0x9A, 0x78, 0x56, 866 0x34, 0x12, 867 // time delta 868 0x87, 0x96, 0xA5, 0xB4, 869 0xC3, 0xD2, 0xE1, 0x07, 870 // num_unacked_packets 871 0x02, 872 // unacked packet sequence number 873 0xBA, 0x9A, 0x78, 0x56, 874 0x34, 0x12, 875 // unacked packet sequence number 876 0xBB, 0x9A, 0x78, 0x56, 877 0x34, 0x12, 878 // least packet sequence number awaiting an ack 879 0xA0, 0x9A, 0x78, 0x56, 880 0x34, 0x12, 881 // num non retransmitting packets 882 0x03, 883 // non retransmitting packet sequence number 884 0xAE, 0x9A, 0x78, 0x56, 885 0x34, 0x12, 886 // non retransmitting packet sequence number 887 0xAF, 0x9A, 0x78, 0x56, 888 0x34, 0x12, 889 // non retransmitting packet sequence number 890 0xB0, 0x9A, 0x78, 0x56, 891 0x34, 0x12, 892 // congestion feedback type (fix rate) 893 0x03, 894 // bitrate_in_bytes_per_second; 895 0x01, 0x02, 0x03, 0x04, 896 }; 897 898 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 899 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 900 901 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 902 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 903 ASSERT_TRUE(visitor_.header_.get()); 904 905 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 906 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 907 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 908 EXPECT_EQ(GG_UINT64_C(0x0123456789ABC), 909 frame.received_info.largest_received); 910 EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)), 911 frame.received_info.time_received); 912 913 const hash_set<QuicPacketSequenceNumber>* sequence_nums = 914 &frame.received_info.missing_packets; 915 ASSERT_EQ(2u, sequence_nums->size()); 916 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABB))); 917 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABA))); 918 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 919 ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size()); 920 const hash_set<QuicPacketSequenceNumber>* non_retrans = 921 &frame.sent_info.non_retransmiting; 922 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AB0))); 923 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAF))); 924 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAE))); 925 ASSERT_EQ(kFixRate, frame.congestion_info.type); 926 EXPECT_EQ(static_cast<uint32>(0x04030201), 927 frame.congestion_info.fix_rate.bitrate_in_bytes_per_second); 928 929 // Now test framing boundaries 930 for (size_t i = kCongestionInfoOffset; i < kCongestionInfoOffset + 5; ++i) { 931 string expected_error; 932 if (i < kCongestionInfoOffset + 1) { 933 expected_error = "Unable to read congestion info type."; 934 } else if (i < kCongestionInfoOffset + 5) { 935 expected_error = "Unable to read bitrate."; 936 } 937 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 938 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 939 encrypted)); 940 EXPECT_EQ(expected_error, framer_.detailed_error()); 941 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 942 } 943} 944 945 946TEST_F(QuicFramerTest, AckFrameInvalidFeedback) { 947 unsigned char packet[] = { 948 // guid 949 0x10, 0x32, 0x54, 0x76, 950 0x98, 0xBA, 0xDC, 0xFE, 951 // packet id 952 0xBC, 0x9A, 0x78, 0x56, 953 0x34, 0x12, 954 // flags 955 0x00, 956 // fec group 957 0x00, 958 959 // frame count 960 0x01, 961 // frame type (ack frame) 962 0x02, 963 // largest received packet sequence number 964 0xBC, 0x9A, 0x78, 0x56, 965 0x34, 0x12, 966 // time delta 967 0x87, 0x96, 0xA5, 0xB4, 968 0xC3, 0xD2, 0xE1, 0x07, 969 // num_unacked_packets 970 0x02, 971 // unacked packet sequence number 972 0xBA, 0x9A, 0x78, 0x56, 973 0x34, 0x12, 974 // unacked packet sequence number 975 0xBB, 0x9A, 0x78, 0x56, 976 0x34, 0x12, 977 // least packet sequence number awaiting an ack 978 0xA0, 0x9A, 0x78, 0x56, 979 0x34, 0x12, 980 // num non retransmitting packets 981 0x03, 982 // non retransmitting packet sequence number 983 0xAE, 0x9A, 0x78, 0x56, 984 0x34, 0x12, 985 // non retransmitting packet sequence number 986 0xAF, 0x9A, 0x78, 0x56, 987 0x34, 0x12, 988 // non retransmitting packet sequence number 989 0xB0, 0x9A, 0x78, 0x56, 990 0x34, 0x12, 991 // congestion feedback type (invalid) 992 0x04, 993 }; 994 995 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 996 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 997 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 998 EXPECT_EQ(QUIC_INVALID_FRAME_DATA, framer_.error()); 999} 1000 1001TEST_F(QuicFramerTest, RstStreamFrame) { 1002 unsigned char packet[] = { 1003 // guid 1004 0x10, 0x32, 0x54, 0x76, 1005 0x98, 0xBA, 0xDC, 0xFE, 1006 // packet id 1007 0xBC, 0x9A, 0x78, 0x56, 1008 0x34, 0x12, 1009 // flags 1010 0x00, 1011 // fec group 1012 0x00, 1013 1014 // frame count 1015 0x01, 1016 // frame type (rst stream frame) 1017 0x03, 1018 // stream id 1019 0x04, 0x03, 0x02, 0x01, 1020 // offset 1021 0x54, 0x76, 0x10, 0x32, 1022 0xDC, 0xFE, 0x98, 0xBA, 1023 // error code 1024 0x08, 0x07, 0x06, 0x05, 1025 1026 // error details length 1027 0x0d, 0x00, 1028 // error details 1029 'b', 'e', 'c', 'a', 1030 'u', 's', 'e', ' ', 1031 'I', ' ', 'c', 'a', 1032 'n', 1033 }; 1034 1035 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1036 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 1037 1038 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 1039 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1040 ASSERT_TRUE(visitor_.header_.get()); 1041 ASSERT_EQ(peer_address_, visitor_.peer_address_); 1042 1043 EXPECT_EQ(GG_UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id); 1044 EXPECT_EQ(0x05060708, visitor_.rst_stream_frame_.error_code); 1045 EXPECT_EQ(GG_UINT64_C(0xBA98FEDC32107654), 1046 visitor_.rst_stream_frame_.offset); 1047 EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details); 1048 1049 // Now test framing boundaries 1050 for (size_t i = kPacketHeaderSize + 3; i < kPacketHeaderSize + 33; ++i) { 1051 string expected_error; 1052 if (i < kPacketHeaderSize + 6) { 1053 expected_error = "Unable to read stream_id."; 1054 } else if (i < kPacketHeaderSize + 14) { 1055 expected_error = "Unable to read offset in rst frame."; 1056 } else if (i < kPacketHeaderSize + 18) { 1057 expected_error = "Unable to read rst stream error code."; 1058 } else if (i < kPacketHeaderSize + 33) { 1059 expected_error = "Unable to read rst stream error details."; 1060 } 1061 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 1062 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 1063 encrypted)); 1064 EXPECT_EQ(expected_error, framer_.detailed_error()); 1065 EXPECT_EQ(QUIC_INVALID_RST_STREAM_DATA, framer_.error()); 1066 } 1067} 1068 1069TEST_F(QuicFramerTest, ConnectionCloseFrame) { 1070 unsigned char packet[] = { 1071 // guid 1072 0x10, 0x32, 0x54, 0x76, 1073 0x98, 0xBA, 0xDC, 0xFE, 1074 // packet id 1075 0xBC, 0x9A, 0x78, 0x56, 1076 0x34, 0x12, 1077 // flags 1078 0x00, 1079 // fec group 1080 0x00, 1081 1082 1083 // frame count 1084 0x01, 1085 // frame type (connection close frame) 1086 0x04, 1087 // error code 1088 0x08, 0x07, 0x06, 0x05, 1089 1090 // error details length 1091 0x0d, 0x00, 1092 // error details 1093 'b', 'e', 'c', 'a', 1094 'u', 's', 'e', ' ', 1095 'I', ' ', 'c', 'a', 1096 'n', 1097 1098 // Ack frame. 1099 1100 // largest received packet sequence number 1101 0xBC, 0x9A, 0x78, 0x56, 1102 0x34, 0x12, 1103 // time delta 1104 0x87, 0x96, 0xA5, 0xB4, 1105 0xC3, 0xD2, 0xE1, 0x07, 1106 // num_unacked_packets 1107 0x02, 1108 // unacked packet sequence number 1109 0xBA, 0x9A, 0x78, 0x56, 1110 0x34, 0x12, 1111 // unacked packet sequence number 1112 0xBB, 0x9A, 0x78, 0x56, 1113 0x34, 0x12, 1114 // least packet sequence number awaiting an ack 1115 0xA0, 0x9A, 0x78, 0x56, 1116 0x34, 0x12, 1117 // num non retransmitting packets 1118 0x03, 1119 // non retransmitting packet sequence number 1120 0xAE, 0x9A, 0x78, 0x56, 1121 0x34, 0x12, 1122 // non retransmitting packet sequence number 1123 0xAF, 0x9A, 0x78, 0x56, 1124 0x34, 0x12, 1125 // non retransmitting packet sequence number 1126 0xB0, 0x9A, 0x78, 0x56, 1127 0x34, 0x12, 1128 // congestion feedback type (inter arrival) 1129 0x02, 1130 // accumulated_number_of_lost_packets 1131 0x02, 0x03, 1132 // offset_time 1133 0x04, 0x05, 1134 // delta_time 1135 0x06, 0x07, 1136 }; 1137 1138 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1139 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 1140 1141 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 1142 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1143 ASSERT_TRUE(visitor_.header_.get()); 1144 1145 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1146 1147 EXPECT_EQ(0x05060708, visitor_.connection_close_frame_.error_code); 1148 EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details); 1149 1150 ASSERT_EQ(1u, visitor_.ack_frames_.size()); 1151 const QuicAckFrame& frame = *visitor_.ack_frames_[0]; 1152 EXPECT_EQ(GG_UINT64_C(0x0123456789ABC), 1153 frame.received_info.largest_received); 1154 EXPECT_EQ(QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)), 1155 frame.received_info.time_received); 1156 1157 const hash_set<QuicPacketSequenceNumber>* sequence_nums = 1158 &frame.received_info.missing_packets; 1159 ASSERT_EQ(2u, sequence_nums->size()); 1160 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABB))); 1161 EXPECT_EQ(1u, sequence_nums->count(GG_UINT64_C(0x0123456789ABA))); 1162 EXPECT_EQ(GG_UINT64_C(0x0123456789AA0), frame.sent_info.least_unacked); 1163 ASSERT_EQ(3u, frame.sent_info.non_retransmiting.size()); 1164 const hash_set<QuicPacketSequenceNumber>* non_retrans = 1165 &frame.sent_info.non_retransmiting; 1166 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AB0))); 1167 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAF))); 1168 EXPECT_EQ(1u, non_retrans->count(GG_UINT64_C(0x0123456789AAE))); 1169 ASSERT_EQ(kInterArrival, frame.congestion_info.type); 1170 EXPECT_EQ(0x0302, frame.congestion_info.inter_arrival. 1171 accumulated_number_of_lost_packets); 1172 EXPECT_EQ(0x0504, 1173 frame.congestion_info.inter_arrival.offset_time); 1174 EXPECT_EQ(0x0706, 1175 frame.congestion_info.inter_arrival.delta_time); 1176 1177 // Now test framing boundaries 1178 for (size_t i = kPacketHeaderSize + 3; i < kPacketHeaderSize + 21; ++i) { 1179 string expected_error; 1180 if (i < kPacketHeaderSize + 6) { 1181 expected_error = "Unable to read connection close error code."; 1182 } else if (i < kPacketHeaderSize + 21) { 1183 expected_error = "Unable to read connection close error details."; 1184 } 1185 1186 QuicEncryptedPacket encrypted(AsChars(packet), i, false); 1187 EXPECT_FALSE(framer_.ProcessPacket(self_address_, peer_address_, 1188 encrypted)); 1189 EXPECT_EQ(expected_error, framer_.detailed_error()); 1190 EXPECT_EQ(QUIC_INVALID_CONNECTION_CLOSE_DATA, framer_.error()); 1191 } 1192} 1193 1194TEST_F(QuicFramerTest, FecPacket) { 1195 unsigned char packet[] = { 1196 // guid 1197 0x10, 0x32, 0x54, 0x76, 1198 0x98, 0xBA, 0xDC, 0xFE, 1199 // packet id 1200 0xBC, 0x9A, 0x78, 0x56, 1201 0x34, 0x12, 1202 // flags (FEC) 1203 0x01, 1204 // fec group 1205 0x01, 1206 1207 // first protected packet 1208 0xBB, 0x9A, 0x78, 0x56, 1209 0x34, 0x12, 1210 // redundancy 1211 'a', 'b', 'c', 'd', 1212 'e', 'f', 'g', 'h', 1213 'i', 'j', 'k', 'l', 1214 'm', 'n', 'o', 'p', 1215 }; 1216 1217 QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false); 1218 EXPECT_TRUE(framer_.ProcessPacket(self_address_, peer_address_, encrypted)); 1219 1220 EXPECT_TRUE(CheckDecryption(StringPiece(AsChars(packet), arraysize(packet)))); 1221 EXPECT_EQ(QUIC_NO_ERROR, framer_.error()); 1222 ASSERT_TRUE(visitor_.header_.get()); 1223 1224 EXPECT_EQ(0u, visitor_.stream_frames_.size()); 1225 EXPECT_EQ(0u, visitor_.ack_frames_.size()); 1226 ASSERT_EQ(1, visitor_.fec_count_); 1227 const QuicFecData& fec_data = *visitor_.fec_data_[0]; 1228 EXPECT_EQ(GG_UINT64_C(0x0123456789ABB), 1229 fec_data.min_protected_packet_sequence_number); 1230 EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy); 1231} 1232 1233TEST_F(QuicFramerTest, ConstructStreamFramePacket) { 1234 QuicPacketHeader header; 1235 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1236 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1237 header.flags = PACKET_FLAGS_NONE; 1238 header.fec_group = 0; 1239 1240 QuicStreamFrame stream_frame; 1241 stream_frame.stream_id = 0x01020304; 1242 stream_frame.fin = true; 1243 stream_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 1244 stream_frame.data = "hello world!"; 1245 1246 QuicFrame frame; 1247 frame.type = STREAM_FRAME; 1248 frame.stream_frame = &stream_frame; 1249 1250 QuicFrames frames; 1251 frames.push_back(frame); 1252 1253 unsigned char packet[] = { 1254 // guid 1255 0x10, 0x32, 0x54, 0x76, 1256 0x98, 0xBA, 0xDC, 0xFE, 1257 // packet id 1258 0xBC, 0x9A, 0x78, 0x56, 1259 0x34, 0x12, 1260 // flags 1261 0x00, 1262 // fec group 1263 0x00, 1264 1265 // frame count 1266 0x01, 1267 // frame type (stream frame) 1268 0x00, 1269 // stream id 1270 0x04, 0x03, 0x02, 0x01, 1271 // fin 1272 0x01, 1273 // offset 1274 0x54, 0x76, 0x10, 0x32, 1275 0xDC, 0xFE, 0x98, 0xBA, 1276 // data length 1277 0x0c, 0x00, 1278 // data 1279 'h', 'e', 'l', 'l', 1280 'o', ' ', 'w', 'o', 1281 'r', 'l', 'd', '!', 1282 }; 1283 1284 QuicPacket* data; 1285 ASSERT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1286 1287 test::CompareCharArraysWithHexError("constructed packet", 1288 data->data(), data->length(), 1289 AsChars(packet), arraysize(packet)); 1290 1291 delete data; 1292} 1293 1294TEST_F(QuicFramerTest, ConstructAckFramePacket) { 1295 QuicPacketHeader header; 1296 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1297 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1298 header.flags = PACKET_FLAGS_NONE; 1299 header.fec_group = 0; 1300 1301 QuicAckFrame ack_frame; 1302 ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1303 ack_frame.received_info.time_received = 1304 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1305 ack_frame.received_info.missing_packets.insert( 1306 GG_UINT64_C(0x0123456789ABB)); 1307 ack_frame.received_info.missing_packets.insert( 1308 GG_UINT64_C(0x0123456789ABA)); 1309 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1310 ack_frame.sent_info.non_retransmiting.insert( 1311 GG_UINT64_C(0x0123456789AB0)); 1312 ack_frame.sent_info.non_retransmiting.insert( 1313 GG_UINT64_C(0x0123456789AAF)); 1314 ack_frame.sent_info.non_retransmiting.insert( 1315 GG_UINT64_C(0x0123456789AAE)); 1316 ack_frame.congestion_info.type = kNone; 1317 1318 QuicFrame frame; 1319 frame.type = ACK_FRAME; 1320 frame.ack_frame = &ack_frame; 1321 1322 QuicFrames frames; 1323 frames.push_back(frame); 1324 1325 unsigned char packet[] = { 1326 // guid 1327 0x10, 0x32, 0x54, 0x76, 1328 0x98, 0xBA, 0xDC, 0xFE, 1329 // packet id 1330 0xBC, 0x9A, 0x78, 0x56, 1331 0x34, 0x12, 1332 // flags 1333 0x00, 1334 // fec group 1335 0x00, 1336 1337 // frame count 1338 0x01, 1339 // frame type (ack frame) 1340 0x02, 1341 // largest received packet sequence number 1342 0xBC, 0x9A, 0x78, 0x56, 1343 0x34, 0x12, 1344 // time delta 1345 0x87, 0x96, 0xA5, 0xB4, 1346 0xC3, 0xD2, 0xE1, 0x07, 1347 // num_unacked_packets 1348 0x02, 1349#if defined(OS_WIN) 1350 // unacked packet sequence number 1351 0xBB, 0x9A, 0x78, 0x56, 1352 0x34, 0x12, 1353 // unacked packet sequence number 1354 0xBA, 0x9A, 0x78, 0x56, 1355 0x34, 0x12, 1356#else 1357 // unacked packet sequence number 1358 0xBA, 0x9A, 0x78, 0x56, 1359 0x34, 0x12, 1360 // unacked packet sequence number 1361 0xBB, 0x9A, 0x78, 0x56, 1362 0x34, 0x12, 1363#endif 1364 // least packet sequence number awaiting an ack 1365 0xA0, 0x9A, 0x78, 0x56, 1366 0x34, 0x12, 1367 // num non retransmitting packets 1368 0x03, 1369#if defined(OS_WIN) 1370 // non retransmitting packet sequence number 1371 0xB0, 0x9A, 0x78, 0x56, 1372 0x34, 0x12, 1373 // non retransmitting packet sequence number 1374 0xAF, 0x9A, 0x78, 0x56, 1375 0x34, 0x12, 1376 // non retransmitting packet sequence number 1377 0xAE, 0x9A, 0x78, 0x56, 1378 0x34, 0x12, 1379#else 1380 // non retransmitting packet sequence number 1381 0xAE, 0x9A, 0x78, 0x56, 1382 0x34, 0x12, 1383 // non retransmitting packet sequence number 1384 0xAF, 0x9A, 0x78, 0x56, 1385 0x34, 0x12, 1386 // non retransmitting packet sequence number 1387 0xB0, 0x9A, 0x78, 0x56, 1388 0x34, 0x12, 1389#endif 1390 // congestion feedback type (none) 1391 0x00, 1392 }; 1393 1394 QuicPacket* data; 1395 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1396 1397 test::CompareCharArraysWithHexError("constructed packet", 1398 data->data(), data->length(), 1399 AsChars(packet), arraysize(packet)); 1400 1401 delete data; 1402} 1403 1404TEST_F(QuicFramerTest, ConstructAckFramePacketTCP) { 1405 QuicPacketHeader header; 1406 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1407 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1408 header.flags = PACKET_FLAGS_NONE; 1409 header.fec_group = 0; 1410 1411 QuicAckFrame ack_frame; 1412 ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1413 ack_frame.received_info.time_received = 1414 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1415 ack_frame.received_info.missing_packets.insert( 1416 GG_UINT64_C(0x0123456789ABB)); 1417 ack_frame.received_info.missing_packets.insert( 1418 GG_UINT64_C(0x0123456789ABA)); 1419 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1420 ack_frame.sent_info.non_retransmiting.insert( 1421 GG_UINT64_C(0x0123456789AB0)); 1422 ack_frame.sent_info.non_retransmiting.insert( 1423 GG_UINT64_C(0x0123456789AAF)); 1424 ack_frame.sent_info.non_retransmiting.insert( 1425 GG_UINT64_C(0x0123456789AAE)); 1426 ack_frame.congestion_info.type = kTCP; 1427 ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets = 0x0201; 1428 ack_frame.congestion_info.tcp.receive_window = 0x0403; 1429 1430 QuicFrame frame; 1431 frame.type = ACK_FRAME; 1432 frame.ack_frame = &ack_frame; 1433 1434 QuicFrames frames; 1435 frames.push_back(frame); 1436 1437 unsigned char packet[] = { 1438 // guid 1439 0x10, 0x32, 0x54, 0x76, 1440 0x98, 0xBA, 0xDC, 0xFE, 1441 // packet id 1442 0xBC, 0x9A, 0x78, 0x56, 1443 0x34, 0x12, 1444 // flags 1445 0x00, 1446 // fec group 1447 0x00, 1448 1449 // frame count 1450 0x01, 1451 // frame type (ack frame) 1452 0x02, 1453 // largest received packet sequence number 1454 0xBC, 0x9A, 0x78, 0x56, 1455 0x34, 0x12, 1456 // time delta 1457 0x87, 0x96, 0xA5, 0xB4, 1458 0xC3, 0xD2, 0xE1, 0x07, 1459 // num_unacked_packets 1460 0x02, 1461#if defined(OS_WIN) 1462 // unacked packet sequence number 1463 0xBB, 0x9A, 0x78, 0x56, 1464 0x34, 0x12, 1465 // unacked packet sequence number 1466 0xBA, 0x9A, 0x78, 0x56, 1467 0x34, 0x12, 1468#else 1469 // unacked packet sequence number 1470 0xBA, 0x9A, 0x78, 0x56, 1471 0x34, 0x12, 1472 // unacked packet sequence number 1473 0xBB, 0x9A, 0x78, 0x56, 1474 0x34, 0x12, 1475#endif 1476 // least packet sequence number awaiting an ack 1477 0xA0, 0x9A, 0x78, 0x56, 1478 0x34, 0x12, 1479 // num non retransmitting packets 1480 0x03, 1481#if defined(OS_WIN) 1482 // non retransmitting packet sequence number 1483 0xB0, 0x9A, 0x78, 0x56, 1484 0x34, 0x12, 1485 // non retransmitting packet sequence number 1486 0xAF, 0x9A, 0x78, 0x56, 1487 0x34, 0x12, 1488 // non retransmitting packet sequence number 1489 0xAE, 0x9A, 0x78, 0x56, 1490 0x34, 0x12, 1491#else 1492 // non retransmitting packet sequence number 1493 0xAE, 0x9A, 0x78, 0x56, 1494 0x34, 0x12, 1495 // non retransmitting packet sequence number 1496 0xAF, 0x9A, 0x78, 0x56, 1497 0x34, 0x12, 1498 // non retransmitting packet sequence number 1499 0xB0, 0x9A, 0x78, 0x56, 1500 0x34, 0x12, 1501#endif 1502 // congestion feedback type (tcp) 1503 0x01, 1504 // ack_frame.congestion_info.tcp.accumulated_number_of_lost_packets 1505 0x01, 0x02, 1506 // ack_frame.congestion_info.tcp.receive_window 1507 0x03, 0x04, 1508 }; 1509 1510 QuicPacket* data; 1511 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1512 1513 test::CompareCharArraysWithHexError("constructed packet", 1514 data->data(), data->length(), 1515 AsChars(packet), arraysize(packet)); 1516 1517 delete data; 1518} 1519 1520TEST_F(QuicFramerTest, ConstructAckFramePacketInterArrival) { 1521 QuicPacketHeader header; 1522 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1523 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1524 header.flags = PACKET_FLAGS_NONE; 1525 header.fec_group = 0; 1526 1527 QuicAckFrame ack_frame; 1528 ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1529 ack_frame.received_info.time_received = 1530 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1531 ack_frame.received_info.missing_packets.insert( 1532 GG_UINT64_C(0x0123456789ABB)); 1533 ack_frame.received_info.missing_packets.insert( 1534 GG_UINT64_C(0x0123456789ABA)); 1535 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1536 ack_frame.sent_info.non_retransmiting.insert( 1537 GG_UINT64_C(0x0123456789AB0)); 1538 ack_frame.sent_info.non_retransmiting.insert( 1539 GG_UINT64_C(0x0123456789AAF)); 1540 ack_frame.sent_info.non_retransmiting.insert( 1541 GG_UINT64_C(0x0123456789AAE)); 1542 ack_frame.congestion_info.type = kInterArrival; 1543 ack_frame.congestion_info.inter_arrival.accumulated_number_of_lost_packets 1544 = 0x0302; 1545 ack_frame.congestion_info.inter_arrival.offset_time = 0x0504; 1546 ack_frame.congestion_info.inter_arrival.delta_time = 0x0706; 1547 1548 QuicFrame frame; 1549 frame.type = ACK_FRAME; 1550 frame.ack_frame = &ack_frame; 1551 1552 QuicFrames frames; 1553 frames.push_back(frame); 1554 1555 unsigned char packet[] = { 1556 // guid 1557 0x10, 0x32, 0x54, 0x76, 1558 0x98, 0xBA, 0xDC, 0xFE, 1559 // packet id 1560 0xBC, 0x9A, 0x78, 0x56, 1561 0x34, 0x12, 1562 // flags 1563 0x00, 1564 // fec group 1565 0x00, 1566 1567 // frame count 1568 0x01, 1569 // frame type (ack frame) 1570 0x02, 1571 // largest received packet sequence number 1572 0xBC, 0x9A, 0x78, 0x56, 1573 0x34, 0x12, 1574 // time delta 1575 0x87, 0x96, 0xA5, 0xB4, 1576 0xC3, 0xD2, 0xE1, 0x07, 1577 // num_unacked_packets 1578 0x02, 1579#if defined(OS_WIN) 1580 // unacked packet sequence number 1581 0xBB, 0x9A, 0x78, 0x56, 1582 0x34, 0x12, 1583 // unacked packet sequence number 1584 0xBA, 0x9A, 0x78, 0x56, 1585 0x34, 0x12, 1586#else 1587 // unacked packet sequence number 1588 0xBA, 0x9A, 0x78, 0x56, 1589 0x34, 0x12, 1590 // unacked packet sequence number 1591 0xBB, 0x9A, 0x78, 0x56, 1592 0x34, 0x12, 1593#endif 1594 // least packet sequence number awaiting an ack 1595 0xA0, 0x9A, 0x78, 0x56, 1596 0x34, 0x12, 1597 // num non retransmitting packets 1598 0x03, 1599#if defined(OS_WIN) 1600 // non retransmitting packet sequence number 1601 0xB0, 0x9A, 0x78, 0x56, 1602 0x34, 0x12, 1603 // non retransmitting packet sequence number 1604 0xAF, 0x9A, 0x78, 0x56, 1605 0x34, 0x12, 1606 // non retransmitting packet sequence number 1607 0xAE, 0x9A, 0x78, 0x56, 1608 0x34, 0x12, 1609#else 1610 // non retransmitting packet sequence number 1611 0xAE, 0x9A, 0x78, 0x56, 1612 0x34, 0x12, 1613 // non retransmitting packet sequence number 1614 0xAF, 0x9A, 0x78, 0x56, 1615 0x34, 0x12, 1616 // non retransmitting packet sequence number 1617 0xB0, 0x9A, 0x78, 0x56, 1618 0x34, 0x12, 1619#endif 1620 // congestion feedback type (inter arrival) 1621 0x02, 1622 // accumulated_number_of_lost_packets 1623 0x02, 0x03, 1624 // offset_time 1625 0x04, 0x05, 1626 // delta_time 1627 0x06, 0x07, 1628 }; 1629 1630 QuicPacket* data; 1631 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1632 1633 test::CompareCharArraysWithHexError("constructed packet", 1634 data->data(), data->length(), 1635 AsChars(packet), arraysize(packet)); 1636 1637 delete data; 1638} 1639 1640TEST_F(QuicFramerTest, ConstructAckFramePacketFixRate) { 1641 QuicPacketHeader header; 1642 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1643 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1644 header.flags = PACKET_FLAGS_NONE; 1645 header.fec_group = 0; 1646 1647 QuicAckFrame ack_frame; 1648 ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1649 ack_frame.received_info.time_received = 1650 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1651 ack_frame.received_info.missing_packets.insert( 1652 GG_UINT64_C(0x0123456789ABB)); 1653 ack_frame.received_info.missing_packets.insert( 1654 GG_UINT64_C(0x0123456789ABA)); 1655 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1656 ack_frame.sent_info.non_retransmiting.insert( 1657 GG_UINT64_C(0x0123456789AB0)); 1658 ack_frame.sent_info.non_retransmiting.insert( 1659 GG_UINT64_C(0x0123456789AAF)); 1660 ack_frame.sent_info.non_retransmiting.insert( 1661 GG_UINT64_C(0x0123456789AAE)); 1662 ack_frame.congestion_info.type = kFixRate; 1663 ack_frame.congestion_info.fix_rate.bitrate_in_bytes_per_second 1664 = 0x04030201; 1665 1666 QuicFrame frame; 1667 frame.type = ACK_FRAME; 1668 frame.ack_frame = &ack_frame; 1669 1670 QuicFrames frames; 1671 frames.push_back(frame); 1672 1673 unsigned char packet[] = { 1674 // guid 1675 0x10, 0x32, 0x54, 0x76, 1676 0x98, 0xBA, 0xDC, 0xFE, 1677 // packet id 1678 0xBC, 0x9A, 0x78, 0x56, 1679 0x34, 0x12, 1680 // flags 1681 0x00, 1682 // fec group 1683 0x00, 1684 1685 // frame count 1686 0x01, 1687 // frame type (ack frame) 1688 0x02, 1689 // largest received packet sequence number 1690 0xBC, 0x9A, 0x78, 0x56, 1691 0x34, 0x12, 1692 // time delta 1693 0x87, 0x96, 0xA5, 0xB4, 1694 0xC3, 0xD2, 0xE1, 0x07, 1695 // num_unacked_packets 1696 0x02, 1697#if defined(OS_WIN) 1698 // unacked packet sequence number 1699 0xBB, 0x9A, 0x78, 0x56, 1700 0x34, 0x12, 1701 // unacked packet sequence number 1702 0xBA, 0x9A, 0x78, 0x56, 1703 0x34, 0x12, 1704#else 1705 // unacked packet sequence number 1706 0xBA, 0x9A, 0x78, 0x56, 1707 0x34, 0x12, 1708 // unacked packet sequence number 1709 0xBB, 0x9A, 0x78, 0x56, 1710 0x34, 0x12, 1711#endif 1712 // least packet sequence number awaiting an ack 1713 0xA0, 0x9A, 0x78, 0x56, 1714 0x34, 0x12, 1715 // num non retransmitting packets 1716 0x03, 1717#if defined(OS_WIN) 1718 // non retransmitting packet sequence number 1719 0xB0, 0x9A, 0x78, 0x56, 1720 0x34, 0x12, 1721 // non retransmitting packet sequence number 1722 0xAF, 0x9A, 0x78, 0x56, 1723 0x34, 0x12, 1724 // non retransmitting packet sequence number 1725 0xAE, 0x9A, 0x78, 0x56, 1726 0x34, 0x12, 1727#else 1728 // non retransmitting packet sequence number 1729 0xAE, 0x9A, 0x78, 0x56, 1730 0x34, 0x12, 1731 // non retransmitting packet sequence number 1732 0xAF, 0x9A, 0x78, 0x56, 1733 0x34, 0x12, 1734 // non retransmitting packet sequence number 1735 0xB0, 0x9A, 0x78, 0x56, 1736 0x34, 0x12, 1737#endif 1738 // congestion feedback type (fix rate) 1739 0x03, 1740 // bitrate_in_bytes_per_second; 1741 0x01, 0x02, 0x03, 0x04, 1742 }; 1743 1744 QuicPacket* data; 1745 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1746 1747 test::CompareCharArraysWithHexError("constructed packet", 1748 data->data(), data->length(), 1749 AsChars(packet), arraysize(packet)); 1750 1751 delete data; 1752} 1753 1754TEST_F(QuicFramerTest, ConstructAckFramePacketInvalidFeedback) { 1755 QuicPacketHeader header; 1756 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1757 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1758 header.flags = PACKET_FLAGS_NONE; 1759 header.fec_group = 0; 1760 1761 QuicAckFrame ack_frame; 1762 ack_frame.received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1763 ack_frame.received_info.time_received = 1764 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1765 ack_frame.received_info.missing_packets.insert( 1766 GG_UINT64_C(0x0123456789ABB)); 1767 ack_frame.received_info.missing_packets.insert( 1768 GG_UINT64_C(0x0123456789ABA)); 1769 ack_frame.sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1770 ack_frame.sent_info.non_retransmiting.insert( 1771 GG_UINT64_C(0x0123456789AB0)); 1772 ack_frame.sent_info.non_retransmiting.insert( 1773 GG_UINT64_C(0x0123456789AAF)); 1774 ack_frame.sent_info.non_retransmiting.insert( 1775 GG_UINT64_C(0x0123456789AAE)); 1776 ack_frame.congestion_info.type = 1777 static_cast<CongestionFeedbackType>(kFixRate + 1); 1778 1779 QuicFrame frame; 1780 frame.type = ACK_FRAME; 1781 frame.ack_frame = &ack_frame; 1782 1783 QuicFrames frames; 1784 frames.push_back(frame); 1785 1786 QuicPacket* data; 1787 EXPECT_FALSE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1788} 1789 1790TEST_F(QuicFramerTest, ConstructRstFramePacket) { 1791 QuicPacketHeader header; 1792 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1793 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1794 header.flags = PACKET_FLAGS_NONE; 1795 header.fec_group = 0; 1796 1797 QuicRstStreamFrame rst_frame; 1798 rst_frame.stream_id = 0x01020304; 1799 rst_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 1800 rst_frame.offset = GG_UINT64_C(0xBA98FEDC32107654); 1801 rst_frame.error_details = "because I can"; 1802 1803 unsigned char packet[] = { 1804 // guid 1805 0x10, 0x32, 0x54, 0x76, 1806 0x98, 0xBA, 0xDC, 0xFE, 1807 // packet id 1808 0xBC, 0x9A, 0x78, 0x56, 1809 0x34, 0x12, 1810 // flags 1811 0x00, 1812 // fec group 1813 0x00, 1814 1815 // frame count 1816 0x01, 1817 // frame type (rst stream frame) 1818 0x03, 1819 // stream id 1820 0x04, 0x03, 0x02, 0x01, 1821 // offset 1822 0x54, 0x76, 0x10, 0x32, 1823 0xDC, 0xFE, 0x98, 0xBA, 1824 // error code 1825 0x08, 0x07, 0x06, 0x05, 1826 // error details length 1827 0x0d, 0x00, 1828 // error details 1829 'b', 'e', 'c', 'a', 1830 'u', 's', 'e', ' ', 1831 'I', ' ', 'c', 'a', 1832 'n', 1833 }; 1834 1835 QuicFrame frame(&rst_frame); 1836 1837 QuicFrames frames; 1838 frames.push_back(frame); 1839 1840 QuicPacket* data; 1841 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1842 1843 test::CompareCharArraysWithHexError("constructed packet", 1844 data->data(), data->length(), 1845 AsChars(packet), arraysize(packet)); 1846 1847 delete data; 1848} 1849 1850TEST_F(QuicFramerTest, ConstructCloseFramePacket) { 1851 QuicPacketHeader header; 1852 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1853 header.packet_sequence_number = GG_UINT64_C(0x123456789ABC); 1854 header.flags = PACKET_FLAGS_NONE; 1855 header.fec_group = 0; 1856 1857 QuicConnectionCloseFrame close_frame; 1858 close_frame.error_code = static_cast<QuicErrorCode>(0x05060708); 1859 close_frame.error_details = "because I can"; 1860 1861 QuicAckFrame* ack_frame = &close_frame.ack_frame; 1862 ack_frame->received_info.largest_received = GG_UINT64_C(0x0123456789ABC); 1863 ack_frame->received_info.time_received = 1864 QuicTime::FromMicroseconds(GG_UINT64_C(0x07E1D2C3B4A59687)); 1865 ack_frame->received_info.missing_packets.insert( 1866 GG_UINT64_C(0x0123456789ABB)); 1867 ack_frame->received_info.missing_packets.insert( 1868 GG_UINT64_C(0x0123456789ABA)); 1869 ack_frame->sent_info.least_unacked = GG_UINT64_C(0x0123456789AA0); 1870 ack_frame->sent_info.non_retransmiting.insert( 1871 GG_UINT64_C(0x0123456789AB0)); 1872 ack_frame->sent_info.non_retransmiting.insert( 1873 GG_UINT64_C(0x0123456789AAF)); 1874 ack_frame->sent_info.non_retransmiting.insert( 1875 GG_UINT64_C(0x0123456789AAE)); 1876 ack_frame->congestion_info.type = kInterArrival; 1877 ack_frame->congestion_info.inter_arrival.accumulated_number_of_lost_packets 1878 = 0x0302; 1879 ack_frame->congestion_info.inter_arrival.offset_time = 0x0504; 1880 ack_frame->congestion_info.inter_arrival.delta_time = 0x0706; 1881 1882 QuicFrame frame(&close_frame); 1883 1884 QuicFrames frames; 1885 frames.push_back(frame); 1886 1887 unsigned char packet[] = { 1888 // guid 1889 0x10, 0x32, 0x54, 0x76, 1890 0x98, 0xBA, 0xDC, 0xFE, 1891 // packet id 1892 0xBC, 0x9A, 0x78, 0x56, 1893 0x34, 0x12, 1894 // flags 1895 0x00, 1896 // fec group 1897 0x00, 1898 1899 // frame count 1900 0x01, 1901 // frame type (connection close frame) 1902 0x04, 1903 // error code 1904 0x08, 0x07, 0x06, 0x05, 1905 // error details length 1906 0x0d, 0x00, 1907 // error details 1908 'b', 'e', 'c', 'a', 1909 'u', 's', 'e', ' ', 1910 'I', ' ', 'c', 'a', 1911 'n', 1912 1913 // Ack frame. 1914 1915 // largest received packet sequence number 1916 0xBC, 0x9A, 0x78, 0x56, 1917 0x34, 0x12, 1918 // time delta 1919 0x87, 0x96, 0xA5, 0xB4, 1920 0xC3, 0xD2, 0xE1, 0x07, 1921 // num_unacked_packets 1922 0x02, 1923#if defined(OS_WIN) 1924 // unacked packet sequence number 1925 0xBB, 0x9A, 0x78, 0x56, 1926 0x34, 0x12, 1927 // unacked packet sequence number 1928 0xBA, 0x9A, 0x78, 0x56, 1929 0x34, 0x12, 1930#else 1931 // unacked packet sequence number 1932 0xBA, 0x9A, 0x78, 0x56, 1933 0x34, 0x12, 1934 // unacked packet sequence number 1935 0xBB, 0x9A, 0x78, 0x56, 1936 0x34, 0x12, 1937#endif 1938 // least packet sequence number awaiting an ack 1939 0xA0, 0x9A, 0x78, 0x56, 1940 0x34, 0x12, 1941 // num non retransmitting packets 1942 0x03, 1943#if defined(OS_WIN) 1944 // non retransmitting packet sequence number 1945 0xB0, 0x9A, 0x78, 0x56, 1946 0x34, 0x12, 1947 // non retransmitting packet sequence number 1948 0xAF, 0x9A, 0x78, 0x56, 1949 0x34, 0x12, 1950 // non retransmitting packet sequence number 1951 0xAE, 0x9A, 0x78, 0x56, 1952 0x34, 0x12, 1953#else 1954 // non retransmitting packet sequence number 1955 0xAE, 0x9A, 0x78, 0x56, 1956 0x34, 0x12, 1957 // non retransmitting packet sequence number 1958 0xAF, 0x9A, 0x78, 0x56, 1959 0x34, 0x12, 1960 // non retransmitting packet sequence number 1961 0xB0, 0x9A, 0x78, 0x56, 1962 0x34, 0x12, 1963#endif 1964 // congestion feedback type (inter arrival) 1965 0x02, 1966 // accumulated_number_of_lost_packets 1967 0x02, 0x03, 1968 // offset_time 1969 0x04, 0x05, 1970 // delta_time 1971 0x06, 0x07, 1972 }; 1973 1974 QuicPacket* data; 1975 EXPECT_TRUE(framer_.ConstructFrameDataPacket(header, frames, &data)); 1976 1977 test::CompareCharArraysWithHexError("constructed packet", 1978 data->data(), data->length(), 1979 AsChars(packet), arraysize(packet)); 1980 1981 delete data; 1982} 1983 1984TEST_F(QuicFramerTest, ConstructFecPacket) { 1985 QuicPacketHeader header; 1986 header.guid = GG_UINT64_C(0xFEDCBA9876543210); 1987 header.packet_sequence_number = (GG_UINT64_C(0x123456789ABC)); 1988 header.flags = PACKET_FLAGS_FEC; 1989 header.fec_group = 1; 1990 1991 QuicFecData fec_data; 1992 fec_data.fec_group = 1; 1993 fec_data.min_protected_packet_sequence_number = 1994 GG_UINT64_C(0x123456789ABB); 1995 fec_data.redundancy = "abcdefghijklmnop"; 1996 1997 unsigned char packet[] = { 1998 // guid 1999 0x10, 0x32, 0x54, 0x76, 2000 0x98, 0xBA, 0xDC, 0xFE, 2001 // packet id 2002 0xBC, 0x9A, 0x78, 0x56, 2003 0x34, 0x12, 2004 // flags 2005 0x01, 2006 // fec group 2007 0x01, 2008 // first protected packet 2009 0xBB, 0x9A, 0x78, 0x56, 2010 0x34, 0x12, 2011 // redundancy 2012 'a', 'b', 'c', 'd', 2013 'e', 'f', 'g', 'h', 2014 'i', 'j', 'k', 'l', 2015 'm', 'n', 'o', 'p', 2016 }; 2017 2018 QuicPacket* data; 2019 EXPECT_TRUE(framer_.ConstructFecPacket(header, fec_data, &data)); 2020 2021 test::CompareCharArraysWithHexError("constructed packet", 2022 data->data(), data->length(), 2023 AsChars(packet), arraysize(packet)); 2024 2025 delete data; 2026} 2027 2028TEST_F(QuicFramerTest, EncryptPacket) { 2029 unsigned char packet[] = { 2030 // guid 2031 0x10, 0x32, 0x54, 0x76, 2032 0x98, 0xBA, 0xDC, 0xFE, 2033 // packet id 2034 0xBC, 0x9A, 0x78, 0x56, 2035 0x34, 0x12, 2036 // flags 2037 0x01, 2038 // fec group 2039 0x01, 2040 // first protected packet 2041 0xBB, 0x9A, 0x78, 0x56, 2042 0x34, 0x12, 2043 // redundancy 2044 'a', 'b', 'c', 'd', 2045 'e', 'f', 'g', 'h', 2046 'i', 'j', 'k', 'l', 2047 'm', 'n', 'o', 'p', 2048 }; 2049 2050 QuicPacket raw(AsChars(packet), arraysize(packet), false, PACKET_FLAGS_NONE); 2051 scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(raw)); 2052 2053 ASSERT_TRUE(encrypted.get() != NULL); 2054 EXPECT_TRUE(CheckEncryption(StringPiece(AsChars(packet), arraysize(packet)))); 2055} 2056 2057} // namespace test 2058 2059} // namespace net 2060