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