quic_framer.cc revision e5d81f57cb97b3b6b7fccc9c5610d21eb81db09d
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "net/quic/quic_framer.h" 6 7#include "base/containers/hash_tables.h" 8#include "base/stl_util.h" 9#include "net/quic/crypto/crypto_framer.h" 10#include "net/quic/crypto/crypto_handshake_message.h" 11#include "net/quic/crypto/crypto_protocol.h" 12#include "net/quic/crypto/quic_decrypter.h" 13#include "net/quic/crypto/quic_encrypter.h" 14#include "net/quic/quic_data_reader.h" 15#include "net/quic/quic_data_writer.h" 16#include "net/quic/quic_flags.h" 17#include "net/quic/quic_socket_address_coder.h" 18 19using base::StringPiece; 20using std::make_pair; 21using std::map; 22using std::max; 23using std::min; 24using std::numeric_limits; 25using std::string; 26 27namespace net { 28 29namespace { 30 31// Mask to select the lowest 48 bits of a sequence number. 32const QuicPacketSequenceNumber k6ByteSequenceNumberMask = 33 GG_UINT64_C(0x0000FFFFFFFFFFFF); 34const QuicPacketSequenceNumber k4ByteSequenceNumberMask = 35 GG_UINT64_C(0x00000000FFFFFFFF); 36const QuicPacketSequenceNumber k2ByteSequenceNumberMask = 37 GG_UINT64_C(0x000000000000FFFF); 38const QuicPacketSequenceNumber k1ByteSequenceNumberMask = 39 GG_UINT64_C(0x00000000000000FF); 40 41const QuicConnectionId k1ByteConnectionIdMask = GG_UINT64_C(0x00000000000000FF); 42const QuicConnectionId k4ByteConnectionIdMask = GG_UINT64_C(0x00000000FFFFFFFF); 43 44// Number of bits the sequence number length bits are shifted from the right 45// edge of the public header. 46const uint8 kPublicHeaderSequenceNumberShift = 4; 47 48// New Frame Types, QUIC v. >= 10: 49// There are two interpretations for the Frame Type byte in the QUIC protocol, 50// resulting in two Frame Types: Special Frame Types and Regular Frame Types. 51// 52// Regular Frame Types use the Frame Type byte simply. Currently defined 53// Regular Frame Types are: 54// Padding : 0b 00000000 (0x00) 55// ResetStream : 0b 00000001 (0x01) 56// ConnectionClose : 0b 00000010 (0x02) 57// GoAway : 0b 00000011 (0x03) 58// WindowUpdate : 0b 00000100 (0x04) 59// Blocked : 0b 00000101 (0x05) 60// 61// Special Frame Types encode both a Frame Type and corresponding flags 62// all in the Frame Type byte. Currently defined Special Frame Types are: 63// Stream : 0b 1xxxxxxx 64// Ack : 0b 01xxxxxx 65// CongestionFeedback : 0b 001xxxxx 66// 67// Semantics of the flag bits above (the x bits) depends on the frame type. 68 69// Masks to determine if the frame type is a special use 70// and for specific special frame types. 71const uint8 kQuicFrameTypeSpecialMask = 0xE0; // 0b 11100000 72const uint8 kQuicFrameTypeStreamMask = 0x80; 73const uint8 kQuicFrameTypeAckMask = 0x40; 74const uint8 kQuicFrameTypeCongestionFeedbackMask = 0x20; 75 76// Stream frame relative shifts and masks for interpreting the stream flags. 77// StreamID may be 1, 2, 3, or 4 bytes. 78const uint8 kQuicStreamIdShift = 2; 79const uint8 kQuicStreamIDLengthMask = 0x03; 80 81// Offset may be 0, 2, 3, 4, 5, 6, 7, 8 bytes. 82const uint8 kQuicStreamOffsetShift = 3; 83const uint8 kQuicStreamOffsetMask = 0x07; 84 85// Data length may be 0 or 2 bytes. 86const uint8 kQuicStreamDataLengthShift = 1; 87const uint8 kQuicStreamDataLengthMask = 0x01; 88 89// Fin bit may be set or not. 90const uint8 kQuicStreamFinShift = 1; 91const uint8 kQuicStreamFinMask = 0x01; 92 93// Sequence number size shift used in AckFrames. 94const uint8 kQuicSequenceNumberLengthShift = 2; 95 96// Acks may be truncated. 97const uint8 kQuicAckTruncatedShift = 1; 98const uint8 kQuicAckTruncatedMask = 0x01; 99 100// Acks may not have any nacks. 101const uint8 kQuicHasNacksMask = 0x01; 102 103// Returns the absolute value of the difference between |a| and |b|. 104QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a, 105 QuicPacketSequenceNumber b) { 106 // Since these are unsigned numbers, we can't just return abs(a - b) 107 if (a < b) { 108 return b - a; 109 } 110 return a - b; 111} 112 113QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target, 114 QuicPacketSequenceNumber a, 115 QuicPacketSequenceNumber b) { 116 return (Delta(target, a) < Delta(target, b)) ? a : b; 117} 118 119QuicSequenceNumberLength ReadSequenceNumberLength(uint8 flags) { 120 switch (flags & PACKET_FLAGS_6BYTE_SEQUENCE) { 121 case PACKET_FLAGS_6BYTE_SEQUENCE: 122 return PACKET_6BYTE_SEQUENCE_NUMBER; 123 case PACKET_FLAGS_4BYTE_SEQUENCE: 124 return PACKET_4BYTE_SEQUENCE_NUMBER; 125 case PACKET_FLAGS_2BYTE_SEQUENCE: 126 return PACKET_2BYTE_SEQUENCE_NUMBER; 127 case PACKET_FLAGS_1BYTE_SEQUENCE: 128 return PACKET_1BYTE_SEQUENCE_NUMBER; 129 default: 130 LOG(DFATAL) << "Unreachable case statement."; 131 return PACKET_6BYTE_SEQUENCE_NUMBER; 132 } 133} 134 135bool CanTruncate( 136 QuicVersion version, const QuicFrame& frame, size_t free_bytes) { 137 if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) && 138 free_bytes >= 139 QuicFramer::GetMinAckFrameSize(version, 140 PACKET_6BYTE_SEQUENCE_NUMBER, 141 PACKET_6BYTE_SEQUENCE_NUMBER)) { 142 return true; 143 } 144 return false; 145} 146 147} // namespace 148 149bool QuicFramerVisitorInterface::OnWindowUpdateFrame( 150 const QuicWindowUpdateFrame& frame) { 151 return true; 152} 153 154bool QuicFramerVisitorInterface::OnBlockedFrame(const QuicBlockedFrame& frame) { 155 return true; 156} 157 158QuicFramer::QuicFramer(const QuicVersionVector& supported_versions, 159 QuicTime creation_time, 160 bool is_server) 161 : visitor_(NULL), 162 fec_builder_(NULL), 163 entropy_calculator_(NULL), 164 error_(QUIC_NO_ERROR), 165 last_sequence_number_(0), 166 last_serialized_connection_id_(0), 167 supported_versions_(supported_versions), 168 alternative_decrypter_latch_(false), 169 is_server_(is_server), 170 validate_flags_(true), 171 creation_time_(creation_time) { 172 DCHECK(!supported_versions.empty()); 173 quic_version_ = supported_versions_[0]; 174 decrypter_.reset(QuicDecrypter::Create(kNULL)); 175 encrypter_[ENCRYPTION_NONE].reset( 176 QuicEncrypter::Create(kNULL)); 177} 178 179QuicFramer::~QuicFramer() {} 180 181// static 182size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version, 183 QuicStreamId stream_id, 184 QuicStreamOffset offset, 185 bool last_frame_in_packet) { 186 return kQuicFrameTypeSize + GetStreamIdSize(stream_id) + 187 GetStreamOffsetSize(offset) + 188 (last_frame_in_packet ? 0 : kQuicStreamPayloadLengthSize); 189} 190 191// static 192size_t QuicFramer::GetMinAckFrameSize( 193 QuicVersion version, 194 QuicSequenceNumberLength sequence_number_length, 195 QuicSequenceNumberLength largest_observed_length) { 196 return kQuicFrameTypeSize + kQuicEntropyHashSize + 197 sequence_number_length + kQuicEntropyHashSize + 198 largest_observed_length + kQuicDeltaTimeLargestObservedSize; 199} 200 201// static 202size_t QuicFramer::GetStopWaitingFrameSize( 203 QuicSequenceNumberLength sequence_number_length) { 204 return kQuicFrameTypeSize + kQuicEntropyHashSize + 205 sequence_number_length; 206} 207 208// static 209size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version) { 210 if (quic_version > QUIC_VERSION_13) { 211 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + 212 kQuicMaxStreamOffsetSize + kQuicErrorCodeSize + 213 kQuicErrorDetailsLengthSize; 214 } else { 215 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicErrorCodeSize + 216 kQuicErrorDetailsLengthSize; 217 } 218} 219 220// static 221size_t QuicFramer::GetMinConnectionCloseFrameSize() { 222 return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize; 223} 224 225// static 226size_t QuicFramer::GetMinGoAwayFrameSize() { 227 return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize + 228 kQuicMaxStreamIdSize; 229} 230 231// static 232size_t QuicFramer::GetWindowUpdateFrameSize() { 233 return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize; 234} 235 236// static 237size_t QuicFramer::GetBlockedFrameSize() { 238 return kQuicFrameTypeSize + kQuicMaxStreamIdSize; 239} 240 241// static 242size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) { 243 // Sizes are 1 through 4 bytes. 244 for (int i = 1; i <= 4; ++i) { 245 stream_id >>= 8; 246 if (stream_id == 0) { 247 return i; 248 } 249 } 250 LOG(DFATAL) << "Failed to determine StreamIDSize."; 251 return 4; 252} 253 254// static 255size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) { 256 // 0 is a special case. 257 if (offset == 0) { 258 return 0; 259 } 260 // 2 through 8 are the remaining sizes. 261 offset >>= 8; 262 for (int i = 2; i <= 8; ++i) { 263 offset >>= 8; 264 if (offset == 0) { 265 return i; 266 } 267 } 268 LOG(DFATAL) << "Failed to determine StreamOffsetSize."; 269 return 8; 270} 271 272// static 273size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) { 274 return kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + 275 number_versions * kQuicVersionSize; 276} 277 278bool QuicFramer::IsSupportedVersion(const QuicVersion version) const { 279 for (size_t i = 0; i < supported_versions_.size(); ++i) { 280 if (version == supported_versions_[i]) { 281 return true; 282 } 283 } 284 return false; 285} 286 287size_t QuicFramer::GetSerializedFrameLength( 288 const QuicFrame& frame, 289 size_t free_bytes, 290 bool first_frame, 291 bool last_frame, 292 QuicSequenceNumberLength sequence_number_length) { 293 if (frame.type == PADDING_FRAME) { 294 // PADDING implies end of packet. 295 return free_bytes; 296 } 297 size_t frame_len = 298 ComputeFrameLength(frame, last_frame, sequence_number_length); 299 if (frame_len > free_bytes) { 300 // Only truncate the first frame in a packet, so if subsequent ones go 301 // over, stop including more frames. 302 if (!first_frame) { 303 return 0; 304 } 305 if (CanTruncate(quic_version_, frame, free_bytes)) { 306 // Truncate the frame so the packet will not exceed kMaxPacketSize. 307 // Note that we may not use every byte of the writer in this case. 308 DVLOG(1) << "Truncating large frame"; 309 return free_bytes; 310 } else if (!FLAGS_quic_allow_oversized_packets_for_test) { 311 return 0; 312 } 313 } 314 return frame_len; 315} 316 317QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) { } 318 319QuicFramer::AckFrameInfo::~AckFrameInfo() { } 320 321QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash( 322 const QuicPacketHeader& header) const { 323 return header.entropy_flag << (header.packet_sequence_number % 8); 324} 325 326// Test only. 327SerializedPacket QuicFramer::BuildUnsizedDataPacket( 328 const QuicPacketHeader& header, 329 const QuicFrames& frames) { 330 const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize); 331 size_t packet_size = GetPacketHeaderSize(header); 332 for (size_t i = 0; i < frames.size(); ++i) { 333 DCHECK_LE(packet_size, max_plaintext_size); 334 bool first_frame = i == 0; 335 bool last_frame = i == frames.size() - 1; 336 const size_t frame_size = GetSerializedFrameLength( 337 frames[i], max_plaintext_size - packet_size, first_frame, last_frame, 338 header.public_header.sequence_number_length); 339 DCHECK(frame_size); 340 packet_size += frame_size; 341 } 342 return BuildDataPacket(header, frames, packet_size); 343} 344 345SerializedPacket QuicFramer::BuildDataPacket( 346 const QuicPacketHeader& header, 347 const QuicFrames& frames, 348 size_t packet_size) { 349 QuicDataWriter writer(packet_size); 350 const SerializedPacket kNoPacket( 351 0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL); 352 if (!AppendPacketHeader(header, &writer)) { 353 LOG(DFATAL) << "AppendPacketHeader failed"; 354 return kNoPacket; 355 } 356 357 for (size_t i = 0; i < frames.size(); ++i) { 358 const QuicFrame& frame = frames[i]; 359 360 const bool last_frame_in_packet = i == (frames.size() - 1); 361 if (!AppendTypeByte(frame, last_frame_in_packet, &writer)) { 362 LOG(DFATAL) << "AppendTypeByte failed"; 363 return kNoPacket; 364 } 365 366 switch (frame.type) { 367 case PADDING_FRAME: 368 writer.WritePadding(); 369 break; 370 case STREAM_FRAME: 371 if (!AppendStreamFrame( 372 *frame.stream_frame, last_frame_in_packet, &writer)) { 373 LOG(DFATAL) << "AppendStreamFrame failed"; 374 return kNoPacket; 375 } 376 break; 377 case ACK_FRAME: 378 if (!AppendAckFrameAndTypeByte( 379 header, *frame.ack_frame, &writer)) { 380 LOG(DFATAL) << "AppendAckFrameAndTypeByte failed"; 381 return kNoPacket; 382 } 383 break; 384 case CONGESTION_FEEDBACK_FRAME: 385 if (!AppendCongestionFeedbackFrame( 386 *frame.congestion_feedback_frame, &writer)) { 387 LOG(DFATAL) << "AppendCongestionFeedbackFrame failed"; 388 return kNoPacket; 389 } 390 break; 391 case STOP_WAITING_FRAME: 392 if (quic_version_ <= QUIC_VERSION_15) { 393 LOG(DFATAL) << "Attempt to add a StopWaitingFrame in " 394 << QuicVersionToString(quic_version_); 395 return kNoPacket; 396 } 397 if (!AppendStopWaitingFrame( 398 header, *frame.stop_waiting_frame, &writer)) { 399 LOG(DFATAL) << "AppendStopWaitingFrame failed"; 400 return kNoPacket; 401 } 402 break; 403 case RST_STREAM_FRAME: 404 if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) { 405 LOG(DFATAL) << "AppendRstStreamFrame failed"; 406 return kNoPacket; 407 } 408 break; 409 case CONNECTION_CLOSE_FRAME: 410 if (!AppendConnectionCloseFrame( 411 *frame.connection_close_frame, &writer)) { 412 LOG(DFATAL) << "AppendConnectionCloseFrame failed"; 413 return kNoPacket; 414 } 415 break; 416 case GOAWAY_FRAME: 417 if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) { 418 LOG(DFATAL) << "AppendGoAwayFrame failed"; 419 return kNoPacket; 420 } 421 break; 422 case WINDOW_UPDATE_FRAME: 423 if (quic_version_ > QUIC_VERSION_13) { 424 if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) { 425 LOG(DFATAL) << "AppendWindowUpdateFrame failed"; 426 return kNoPacket; 427 } 428 } else { 429 LOG(DFATAL) << "Attempt to add a WindowUpdateFrame in " 430 << QuicVersionToString(quic_version_); 431 return kNoPacket; 432 } 433 break; 434 case BLOCKED_FRAME: 435 if (quic_version_ > QUIC_VERSION_13) { 436 if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) { 437 LOG(DFATAL) << "AppendBlockedFrame failed"; 438 return kNoPacket; 439 } 440 } else { 441 LOG(DFATAL) << "Attempt to add a BlockedFrame in " 442 << QuicVersionToString(quic_version_); 443 return kNoPacket; 444 } 445 break; 446 default: 447 RaiseError(QUIC_INVALID_FRAME_DATA); 448 LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA"; 449 return kNoPacket; 450 } 451 } 452 453 // Save the length before writing, because take clears it. 454 const size_t len = writer.length(); 455 // Less than or equal because truncated acks end up with max_plaintex_size 456 // length, even though they're typically slightly shorter. 457 DCHECK_LE(len, packet_size); 458 QuicPacket* packet = QuicPacket::NewDataPacket( 459 writer.take(), len, true, header.public_header.connection_id_length, 460 header.public_header.version_flag, 461 header.public_header.sequence_number_length); 462 463 if (fec_builder_) { 464 fec_builder_->OnBuiltFecProtectedPayload(header, 465 packet->FecProtectedData()); 466 } 467 468 return SerializedPacket(header.packet_sequence_number, 469 header.public_header.sequence_number_length, packet, 470 GetPacketEntropyHash(header), NULL); 471} 472 473SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header, 474 const QuicFecData& fec) { 475 DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group); 476 DCHECK_NE(0u, header.fec_group); 477 size_t len = GetPacketHeaderSize(header); 478 len += fec.redundancy.length(); 479 480 QuicDataWriter writer(len); 481 const SerializedPacket kNoPacket( 482 0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL); 483 if (!AppendPacketHeader(header, &writer)) { 484 LOG(DFATAL) << "AppendPacketHeader failed"; 485 return kNoPacket; 486 } 487 488 if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) { 489 LOG(DFATAL) << "Failed to add FEC"; 490 return kNoPacket; 491 } 492 493 return SerializedPacket( 494 header.packet_sequence_number, 495 header.public_header.sequence_number_length, 496 QuicPacket::NewFecPacket(writer.take(), len, true, 497 header.public_header.connection_id_length, 498 header.public_header.version_flag, 499 header.public_header.sequence_number_length), 500 GetPacketEntropyHash(header), NULL); 501} 502 503// static 504QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket( 505 const QuicPublicResetPacket& packet) { 506 DCHECK(packet.public_header.reset_flag); 507 508 CryptoHandshakeMessage reset; 509 reset.set_tag(kPRST); 510 reset.SetValue(kRNON, packet.nonce_proof); 511 reset.SetValue(kRSEQ, packet.rejected_sequence_number); 512 if (!packet.client_address.address().empty()) { 513 // packet.client_address is non-empty. 514 QuicSocketAddressCoder address_coder(packet.client_address); 515 string serialized_address = address_coder.Encode(); 516 if (serialized_address.empty()) { 517 return NULL; 518 } 519 reset.SetStringPiece(kCADR, serialized_address); 520 } 521 const QuicData& reset_serialized = reset.GetSerialized(); 522 523 size_t len = 524 kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length(); 525 QuicDataWriter writer(len); 526 527 uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST | 528 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID); 529 if (!writer.WriteUInt8(flags)) { 530 return NULL; 531 } 532 533 if (!writer.WriteUInt64(packet.public_header.connection_id)) { 534 return NULL; 535 } 536 537 if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) { 538 return NULL; 539 } 540 541 return new QuicEncryptedPacket(writer.take(), len, true); 542} 543 544QuicEncryptedPacket* QuicFramer::BuildVersionNegotiationPacket( 545 const QuicPacketPublicHeader& header, 546 const QuicVersionVector& supported_versions) { 547 DCHECK(header.version_flag); 548 size_t len = GetVersionNegotiationPacketSize(supported_versions.size()); 549 QuicDataWriter writer(len); 550 551 uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION | 552 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID); 553 if (!writer.WriteUInt8(flags)) { 554 return NULL; 555 } 556 557 if (!writer.WriteUInt64(header.connection_id)) { 558 return NULL; 559 } 560 561 for (size_t i = 0; i < supported_versions.size(); ++i) { 562 if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) { 563 return NULL; 564 } 565 } 566 567 return new QuicEncryptedPacket(writer.take(), len, true); 568} 569 570bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) { 571 DCHECK(!reader_.get()); 572 reader_.reset(new QuicDataReader(packet.data(), packet.length())); 573 574 visitor_->OnPacket(); 575 576 // First parse the public header. 577 QuicPacketPublicHeader public_header; 578 if (!ProcessPublicHeader(&public_header)) { 579 DLOG(WARNING) << "Unable to process public header."; 580 DCHECK_NE("", detailed_error_); 581 return RaiseError(QUIC_INVALID_PACKET_HEADER); 582 } 583 584 if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) { 585 // The visitor suppresses further processing of the packet. 586 reader_.reset(NULL); 587 return true; 588 } 589 590 if (is_server_ && public_header.version_flag && 591 public_header.versions[0] != quic_version_) { 592 if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) { 593 reader_.reset(NULL); 594 return true; 595 } 596 } 597 598 bool rv; 599 if (!is_server_ && public_header.version_flag) { 600 rv = ProcessVersionNegotiationPacket(&public_header); 601 } else if (public_header.reset_flag) { 602 rv = ProcessPublicResetPacket(public_header); 603 } else { 604 rv = ProcessDataPacket(public_header, packet); 605 } 606 607 reader_.reset(NULL); 608 return rv; 609} 610 611bool QuicFramer::ProcessVersionNegotiationPacket( 612 QuicPacketPublicHeader* public_header) { 613 DCHECK(!is_server_); 614 // Try reading at least once to raise error if the packet is invalid. 615 do { 616 QuicTag version; 617 if (!reader_->ReadBytes(&version, kQuicVersionSize)) { 618 set_detailed_error("Unable to read supported version in negotiation."); 619 return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET); 620 } 621 public_header->versions.push_back(QuicTagToQuicVersion(version)); 622 } while (!reader_->IsDoneReading()); 623 624 visitor_->OnVersionNegotiationPacket(*public_header); 625 return true; 626} 627 628bool QuicFramer::ProcessDataPacket( 629 const QuicPacketPublicHeader& public_header, 630 const QuicEncryptedPacket& packet) { 631 QuicPacketHeader header(public_header); 632 if (!ProcessPacketHeader(&header, packet)) { 633 DLOG(WARNING) << "Unable to process data packet header."; 634 return false; 635 } 636 637 if (!visitor_->OnPacketHeader(header)) { 638 // The visitor suppresses further processing of the packet. 639 return true; 640 } 641 642 if (packet.length() > kMaxPacketSize) { 643 DLOG(WARNING) << "Packet too large: " << packet.length(); 644 return RaiseError(QUIC_PACKET_TOO_LARGE); 645 } 646 647 // Handle the payload. 648 if (!header.fec_flag) { 649 if (header.is_in_fec_group == IN_FEC_GROUP) { 650 StringPiece payload = reader_->PeekRemainingPayload(); 651 visitor_->OnFecProtectedPayload(payload); 652 } 653 if (!ProcessFrameData(header)) { 654 DCHECK_NE(QUIC_NO_ERROR, error_); // ProcessFrameData sets the error. 655 DLOG(WARNING) << "Unable to process frame data."; 656 return false; 657 } 658 } else { 659 QuicFecData fec_data; 660 fec_data.fec_group = header.fec_group; 661 fec_data.redundancy = reader_->ReadRemainingPayload(); 662 visitor_->OnFecData(fec_data); 663 } 664 665 visitor_->OnPacketComplete(); 666 return true; 667} 668 669bool QuicFramer::ProcessPublicResetPacket( 670 const QuicPacketPublicHeader& public_header) { 671 QuicPublicResetPacket packet(public_header); 672 673 if (public_header.sequence_number_length == PACKET_6BYTE_SEQUENCE_NUMBER) { 674 // An old-style public reset packet has the 675 // PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE bits set in the public flags. 676 // TODO(wtc): remove this when we drop support for QUIC_VERSION_13. 677 if (!reader_->ReadUInt64(&packet.nonce_proof)) { 678 set_detailed_error("Unable to read nonce proof."); 679 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 680 } 681 682 if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) { 683 set_detailed_error("Unable to read rejected sequence number."); 684 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 685 } 686 687 visitor_->OnPublicResetPacket(packet); 688 return true; 689 } 690 691 scoped_ptr<CryptoHandshakeMessage> reset( 692 CryptoFramer::ParseMessage(reader_->ReadRemainingPayload())); 693 if (!reset.get()) { 694 set_detailed_error("Unable to read reset message."); 695 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 696 } 697 if (reset->tag() != kPRST) { 698 set_detailed_error("Incorrect message tag."); 699 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 700 } 701 702 if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) { 703 set_detailed_error("Unable to read nonce proof."); 704 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 705 } 706 // TODO(satyamshekhar): validate nonce to protect against DoS. 707 708 if (reset->GetUint64(kRSEQ, &packet.rejected_sequence_number) != 709 QUIC_NO_ERROR) { 710 set_detailed_error("Unable to read rejected sequence number."); 711 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); 712 } 713 714 StringPiece address; 715 if (reset->GetStringPiece(kCADR, &address)) { 716 QuicSocketAddressCoder address_coder; 717 if (address_coder.Decode(address.data(), address.length())) { 718 packet.client_address = IPEndPoint(address_coder.ip(), 719 address_coder.port()); 720 } 721 } 722 723 visitor_->OnPublicResetPacket(packet); 724 return true; 725} 726 727bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header, 728 StringPiece payload) { 729 DCHECK(!reader_.get()); 730 731 visitor_->OnRevivedPacket(); 732 733 header->entropy_hash = GetPacketEntropyHash(*header); 734 735 if (!visitor_->OnPacketHeader(*header)) { 736 return true; 737 } 738 739 if (payload.length() > kMaxPacketSize) { 740 set_detailed_error("Revived packet too large."); 741 return RaiseError(QUIC_PACKET_TOO_LARGE); 742 } 743 744 reader_.reset(new QuicDataReader(payload.data(), payload.length())); 745 if (!ProcessFrameData(*header)) { 746 DCHECK_NE(QUIC_NO_ERROR, error_); // ProcessFrameData sets the error. 747 DLOG(WARNING) << "Unable to process frame data."; 748 return false; 749 } 750 751 visitor_->OnPacketComplete(); 752 reader_.reset(NULL); 753 return true; 754} 755 756bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header, 757 QuicDataWriter* writer) { 758 DVLOG(1) << "Appending header: " << header; 759 DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP); 760 uint8 public_flags = 0; 761 if (header.public_header.reset_flag) { 762 public_flags |= PACKET_PUBLIC_FLAGS_RST; 763 } 764 if (header.public_header.version_flag) { 765 public_flags |= PACKET_PUBLIC_FLAGS_VERSION; 766 } 767 768 public_flags |= 769 GetSequenceNumberFlags(header.public_header.sequence_number_length) 770 << kPublicHeaderSequenceNumberShift; 771 772 switch (header.public_header.connection_id_length) { 773 case PACKET_0BYTE_CONNECTION_ID: 774 if (!writer->WriteUInt8( 775 public_flags | PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) { 776 return false; 777 } 778 break; 779 case PACKET_1BYTE_CONNECTION_ID: 780 if (!writer->WriteUInt8( 781 public_flags | PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) { 782 return false; 783 } 784 if (!writer->WriteUInt8( 785 header.public_header.connection_id & k1ByteConnectionIdMask)) { 786 return false; 787 } 788 break; 789 case PACKET_4BYTE_CONNECTION_ID: 790 if (!writer->WriteUInt8( 791 public_flags | PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) { 792 return false; 793 } 794 if (!writer->WriteUInt32( 795 header.public_header.connection_id & k4ByteConnectionIdMask)) { 796 return false; 797 } 798 break; 799 case PACKET_8BYTE_CONNECTION_ID: 800 if (!writer->WriteUInt8( 801 public_flags | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) { 802 return false; 803 } 804 if (!writer->WriteUInt64(header.public_header.connection_id)) { 805 return false; 806 } 807 break; 808 } 809 last_serialized_connection_id_ = header.public_header.connection_id; 810 811 if (header.public_header.version_flag) { 812 DCHECK(!is_server_); 813 writer->WriteUInt32(QuicVersionToQuicTag(quic_version_)); 814 } 815 816 if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length, 817 header.packet_sequence_number, writer)) { 818 return false; 819 } 820 821 uint8 private_flags = 0; 822 if (header.entropy_flag) { 823 private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY; 824 } 825 if (header.is_in_fec_group == IN_FEC_GROUP) { 826 private_flags |= PACKET_PRIVATE_FLAGS_FEC_GROUP; 827 } 828 if (header.fec_flag) { 829 private_flags |= PACKET_PRIVATE_FLAGS_FEC; 830 } 831 if (!writer->WriteUInt8(private_flags)) { 832 return false; 833 } 834 835 // The FEC group number is the sequence number of the first fec 836 // protected packet, or 0 if this packet is not protected. 837 if (header.is_in_fec_group == IN_FEC_GROUP) { 838 DCHECK_GE(header.packet_sequence_number, header.fec_group); 839 DCHECK_GT(255u, header.packet_sequence_number - header.fec_group); 840 // Offset from the current packet sequence number to the first fec 841 // protected packet. 842 uint8 first_fec_protected_packet_offset = 843 header.packet_sequence_number - header.fec_group; 844 if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) { 845 return false; 846 } 847 } 848 849 return true; 850} 851 852QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire( 853 QuicSequenceNumberLength sequence_number_length, 854 QuicPacketSequenceNumber packet_sequence_number) const { 855 // The new sequence number might have wrapped to the next epoch, or 856 // it might have reverse wrapped to the previous epoch, or it might 857 // remain in the same epoch. Select the sequence number closest to the 858 // next expected sequence number, the previous sequence number plus 1. 859 860 // epoch_delta is the delta between epochs the sequence number was serialized 861 // with, so the correct value is likely the same epoch as the last sequence 862 // number or an adjacent epoch. 863 const QuicPacketSequenceNumber epoch_delta = 864 GG_UINT64_C(1) << (8 * sequence_number_length); 865 QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1; 866 QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1); 867 QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta; 868 QuicPacketSequenceNumber next_epoch = epoch + epoch_delta; 869 870 return ClosestTo(next_sequence_number, 871 epoch + packet_sequence_number, 872 ClosestTo(next_sequence_number, 873 prev_epoch + packet_sequence_number, 874 next_epoch + packet_sequence_number)); 875} 876 877bool QuicFramer::ProcessPublicHeader( 878 QuicPacketPublicHeader* public_header) { 879 uint8 public_flags; 880 if (!reader_->ReadBytes(&public_flags, 1)) { 881 set_detailed_error("Unable to read public flags."); 882 return false; 883 } 884 885 public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0; 886 public_header->version_flag = 887 (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0; 888 889 if (validate_flags_ && 890 !public_header->version_flag && public_flags > PACKET_PUBLIC_FLAGS_MAX) { 891 set_detailed_error("Illegal public flags value."); 892 return false; 893 } 894 895 if (public_header->reset_flag && public_header->version_flag) { 896 set_detailed_error("Got version flag in reset packet"); 897 return false; 898 } 899 900 switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) { 901 case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID: 902 if (!reader_->ReadUInt64(&public_header->connection_id)) { 903 set_detailed_error("Unable to read ConnectionId."); 904 return false; 905 } 906 public_header->connection_id_length = PACKET_8BYTE_CONNECTION_ID; 907 break; 908 case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID: 909 // If the connection_id is truncated, expect to read the last serialized 910 // connection_id. 911 if (!reader_->ReadBytes(&public_header->connection_id, 912 PACKET_4BYTE_CONNECTION_ID)) { 913 set_detailed_error("Unable to read ConnectionId."); 914 return false; 915 } 916 if ((public_header->connection_id & k4ByteConnectionIdMask) != 917 (last_serialized_connection_id_ & k4ByteConnectionIdMask)) { 918 set_detailed_error("Truncated 4 byte ConnectionId does not match " 919 "previous connection_id."); 920 return false; 921 } 922 public_header->connection_id_length = PACKET_4BYTE_CONNECTION_ID; 923 public_header->connection_id = last_serialized_connection_id_; 924 break; 925 case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID: 926 if (!reader_->ReadBytes(&public_header->connection_id, 927 PACKET_1BYTE_CONNECTION_ID)) { 928 set_detailed_error("Unable to read ConnectionId."); 929 return false; 930 } 931 if ((public_header->connection_id & k1ByteConnectionIdMask) != 932 (last_serialized_connection_id_ & k1ByteConnectionIdMask)) { 933 set_detailed_error("Truncated 1 byte ConnectionId does not match " 934 "previous connection_id."); 935 return false; 936 } 937 public_header->connection_id_length = PACKET_1BYTE_CONNECTION_ID; 938 public_header->connection_id = last_serialized_connection_id_; 939 break; 940 case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID: 941 public_header->connection_id_length = PACKET_0BYTE_CONNECTION_ID; 942 public_header->connection_id = last_serialized_connection_id_; 943 break; 944 } 945 946 public_header->sequence_number_length = 947 ReadSequenceNumberLength( 948 public_flags >> kPublicHeaderSequenceNumberShift); 949 950 // Read the version only if the packet is from the client. 951 // version flag from the server means version negotiation packet. 952 if (public_header->version_flag && is_server_) { 953 QuicTag version_tag; 954 if (!reader_->ReadUInt32(&version_tag)) { 955 set_detailed_error("Unable to read protocol version."); 956 return false; 957 } 958 959 // If the version from the new packet is the same as the version of this 960 // framer, then the public flags should be set to something we understand. 961 // If not, this raises an error. 962 QuicVersion version = QuicTagToQuicVersion(version_tag); 963 if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) { 964 set_detailed_error("Illegal public flags value."); 965 return false; 966 } 967 public_header->versions.push_back(version); 968 } 969 return true; 970} 971 972// static 973QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength( 974 QuicPacketSequenceNumber sequence_number) { 975 if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) { 976 return PACKET_1BYTE_SEQUENCE_NUMBER; 977 } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) { 978 return PACKET_2BYTE_SEQUENCE_NUMBER; 979 } else if (sequence_number < 980 GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) { 981 return PACKET_4BYTE_SEQUENCE_NUMBER; 982 } else { 983 return PACKET_6BYTE_SEQUENCE_NUMBER; 984 } 985} 986 987// static 988uint8 QuicFramer::GetSequenceNumberFlags( 989 QuicSequenceNumberLength sequence_number_length) { 990 switch (sequence_number_length) { 991 case PACKET_1BYTE_SEQUENCE_NUMBER: 992 return PACKET_FLAGS_1BYTE_SEQUENCE; 993 case PACKET_2BYTE_SEQUENCE_NUMBER: 994 return PACKET_FLAGS_2BYTE_SEQUENCE; 995 case PACKET_4BYTE_SEQUENCE_NUMBER: 996 return PACKET_FLAGS_4BYTE_SEQUENCE; 997 case PACKET_6BYTE_SEQUENCE_NUMBER: 998 return PACKET_FLAGS_6BYTE_SEQUENCE; 999 default: 1000 LOG(DFATAL) << "Unreachable case statement."; 1001 return PACKET_FLAGS_6BYTE_SEQUENCE; 1002 } 1003} 1004 1005// static 1006QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo( 1007 const QuicAckFrame& frame) { 1008 const ReceivedPacketInfo& received_info = frame.received_info; 1009 1010 AckFrameInfo ack_info; 1011 if (!received_info.missing_packets.empty()) { 1012 DCHECK_GE(received_info.largest_observed, 1013 *received_info.missing_packets.rbegin()); 1014 size_t cur_range_length = 0; 1015 SequenceNumberSet::const_iterator iter = 1016 received_info.missing_packets.begin(); 1017 QuicPacketSequenceNumber last_missing = *iter; 1018 ++iter; 1019 for (; iter != received_info.missing_packets.end(); ++iter) { 1020 if (cur_range_length != numeric_limits<uint8>::max() && 1021 *iter == (last_missing + 1)) { 1022 ++cur_range_length; 1023 } else { 1024 ack_info.nack_ranges[last_missing - cur_range_length] 1025 = cur_range_length; 1026 cur_range_length = 0; 1027 } 1028 ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing); 1029 last_missing = *iter; 1030 } 1031 // Include the last nack range. 1032 ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length; 1033 // Include the range to the largest observed. 1034 ack_info.max_delta = max(ack_info.max_delta, 1035 received_info.largest_observed - last_missing); 1036 } 1037 return ack_info; 1038} 1039 1040bool QuicFramer::ProcessPacketHeader( 1041 QuicPacketHeader* header, 1042 const QuicEncryptedPacket& packet) { 1043 if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length, 1044 &header->packet_sequence_number)) { 1045 set_detailed_error("Unable to read sequence number."); 1046 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1047 } 1048 1049 if (header->packet_sequence_number == 0u) { 1050 set_detailed_error("Packet sequence numbers cannot be 0."); 1051 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1052 } 1053 1054 if (!visitor_->OnUnauthenticatedHeader(*header)) { 1055 return false; 1056 } 1057 1058 if (!DecryptPayload(*header, packet)) { 1059 set_detailed_error("Unable to decrypt payload."); 1060 return RaiseError(QUIC_DECRYPTION_FAILURE); 1061 } 1062 1063 uint8 private_flags; 1064 if (!reader_->ReadBytes(&private_flags, 1)) { 1065 set_detailed_error("Unable to read private flags."); 1066 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1067 } 1068 1069 if (private_flags > PACKET_PRIVATE_FLAGS_MAX) { 1070 set_detailed_error("Illegal private flags value."); 1071 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1072 } 1073 1074 header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0; 1075 header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0; 1076 1077 if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) { 1078 header->is_in_fec_group = IN_FEC_GROUP; 1079 uint8 first_fec_protected_packet_offset; 1080 if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) { 1081 set_detailed_error("Unable to read first fec protected packet offset."); 1082 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1083 } 1084 if (first_fec_protected_packet_offset >= header->packet_sequence_number) { 1085 set_detailed_error("First fec protected packet offset must be less " 1086 "than the sequence number."); 1087 return RaiseError(QUIC_INVALID_PACKET_HEADER); 1088 } 1089 header->fec_group = 1090 header->packet_sequence_number - first_fec_protected_packet_offset; 1091 } 1092 1093 header->entropy_hash = GetPacketEntropyHash(*header); 1094 // Set the last sequence number after we have decrypted the packet 1095 // so we are confident is not attacker controlled. 1096 last_sequence_number_ = header->packet_sequence_number; 1097 return true; 1098} 1099 1100bool QuicFramer::ProcessPacketSequenceNumber( 1101 QuicSequenceNumberLength sequence_number_length, 1102 QuicPacketSequenceNumber* sequence_number) { 1103 QuicPacketSequenceNumber wire_sequence_number = 0u; 1104 if (!reader_->ReadBytes(&wire_sequence_number, sequence_number_length)) { 1105 return false; 1106 } 1107 1108 // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers 1109 // in case the first guess is incorrect. 1110 *sequence_number = 1111 CalculatePacketSequenceNumberFromWire(sequence_number_length, 1112 wire_sequence_number); 1113 return true; 1114} 1115 1116bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) { 1117 if (reader_->IsDoneReading()) { 1118 set_detailed_error("Packet has no frames."); 1119 return RaiseError(QUIC_MISSING_PAYLOAD); 1120 } 1121 while (!reader_->IsDoneReading()) { 1122 uint8 frame_type; 1123 if (!reader_->ReadBytes(&frame_type, 1)) { 1124 set_detailed_error("Unable to read frame type."); 1125 return RaiseError(QUIC_INVALID_FRAME_DATA); 1126 } 1127 1128 if (frame_type & kQuicFrameTypeSpecialMask) { 1129 // Stream Frame 1130 if (frame_type & kQuicFrameTypeStreamMask) { 1131 QuicStreamFrame frame; 1132 if (!ProcessStreamFrame(frame_type, &frame)) { 1133 return RaiseError(QUIC_INVALID_STREAM_DATA); 1134 } 1135 if (!visitor_->OnStreamFrame(frame)) { 1136 DVLOG(1) << "Visitor asked to stop further processing."; 1137 // Returning true since there was no parsing error. 1138 return true; 1139 } 1140 continue; 1141 } 1142 1143 // Ack Frame 1144 if (frame_type & kQuicFrameTypeAckMask) { 1145 QuicAckFrame frame; 1146 if (!ProcessAckFrame(header, frame_type, &frame)) { 1147 return RaiseError(QUIC_INVALID_ACK_DATA); 1148 } 1149 if (!visitor_->OnAckFrame(frame)) { 1150 DVLOG(1) << "Visitor asked to stop further processing."; 1151 // Returning true since there was no parsing error. 1152 return true; 1153 } 1154 continue; 1155 } 1156 1157 // Congestion Feedback Frame 1158 if (frame_type & kQuicFrameTypeCongestionFeedbackMask) { 1159 QuicCongestionFeedbackFrame frame; 1160 if (!ProcessQuicCongestionFeedbackFrame(&frame)) { 1161 return RaiseError(QUIC_INVALID_CONGESTION_FEEDBACK_DATA); 1162 } 1163 if (!visitor_->OnCongestionFeedbackFrame(frame)) { 1164 DVLOG(1) << "Visitor asked to stop further processing."; 1165 // Returning true since there was no parsing error. 1166 return true; 1167 } 1168 continue; 1169 } 1170 1171 // This was a special frame type that did not match any 1172 // of the known ones. Error. 1173 set_detailed_error("Illegal frame type."); 1174 DLOG(WARNING) << "Illegal frame type: " 1175 << static_cast<int>(frame_type); 1176 return RaiseError(QUIC_INVALID_FRAME_DATA); 1177 } 1178 1179 switch (frame_type) { 1180 case PADDING_FRAME: 1181 // We're done with the packet. 1182 return true; 1183 1184 case RST_STREAM_FRAME: { 1185 QuicRstStreamFrame frame; 1186 if (!ProcessRstStreamFrame(&frame)) { 1187 return RaiseError(QUIC_INVALID_RST_STREAM_DATA); 1188 } 1189 if (!visitor_->OnRstStreamFrame(frame)) { 1190 DVLOG(1) << "Visitor asked to stop further processing."; 1191 // Returning true since there was no parsing error. 1192 return true; 1193 } 1194 continue; 1195 } 1196 1197 case CONNECTION_CLOSE_FRAME: { 1198 QuicConnectionCloseFrame frame; 1199 if (!ProcessConnectionCloseFrame(&frame)) { 1200 return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA); 1201 } 1202 1203 if (!visitor_->OnConnectionCloseFrame(frame)) { 1204 DVLOG(1) << "Visitor asked to stop further processing."; 1205 // Returning true since there was no parsing error. 1206 return true; 1207 } 1208 continue; 1209 } 1210 1211 case GOAWAY_FRAME: { 1212 QuicGoAwayFrame goaway_frame; 1213 if (!ProcessGoAwayFrame(&goaway_frame)) { 1214 return RaiseError(QUIC_INVALID_GOAWAY_DATA); 1215 } 1216 if (!visitor_->OnGoAwayFrame(goaway_frame)) { 1217 DVLOG(1) << "Visitor asked to stop further processing."; 1218 // Returning true since there was no parsing error. 1219 return true; 1220 } 1221 continue; 1222 } 1223 1224 case WINDOW_UPDATE_FRAME: { 1225 if (quic_version_ > QUIC_VERSION_13) { 1226 QuicWindowUpdateFrame window_update_frame; 1227 if (!ProcessWindowUpdateFrame(&window_update_frame)) { 1228 return RaiseError(QUIC_INVALID_WINDOW_UPDATE_DATA); 1229 } 1230 if (!visitor_->OnWindowUpdateFrame(window_update_frame)) { 1231 DVLOG(1) << "Visitor asked to stop further processing."; 1232 // Returning true since there was no parsing error. 1233 return true; 1234 } 1235 } else { 1236 LOG(DFATAL) << "Trying to read a WindowUpdateFrame in " 1237 << QuicVersionToString(quic_version_); 1238 return RaiseError(QUIC_INTERNAL_ERROR); 1239 } 1240 continue; 1241 } 1242 1243 case BLOCKED_FRAME: { 1244 if (quic_version_ > QUIC_VERSION_13) { 1245 QuicBlockedFrame blocked_frame; 1246 if (!ProcessBlockedFrame(&blocked_frame)) { 1247 return RaiseError(QUIC_INVALID_BLOCKED_DATA); 1248 } 1249 if (!visitor_->OnBlockedFrame(blocked_frame)) { 1250 DVLOG(1) << "Visitor asked to stop further processing."; 1251 // Returning true since there was no parsing error. 1252 return true; 1253 } 1254 } else { 1255 LOG(DFATAL) << "Trying to read a BlockedFrame in " 1256 << QuicVersionToString(quic_version_); 1257 return RaiseError(QUIC_INTERNAL_ERROR); 1258 } 1259 continue; 1260 } 1261 1262 case STOP_WAITING_FRAME: { 1263 if (quic_version_ <= QUIC_VERSION_15) { 1264 LOG(DFATAL) << "Trying to read a StopWaiting in " 1265 << QuicVersionToString(quic_version_); 1266 return RaiseError(QUIC_INTERNAL_ERROR); 1267 } 1268 QuicStopWaitingFrame stop_waiting_frame; 1269 if (!ProcessStopWaitingFrame(header, &stop_waiting_frame)) { 1270 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA); 1271 } 1272 if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) { 1273 DVLOG(1) << "Visitor asked to stop further processing."; 1274 // Returning true since there was no parsing error. 1275 return true; 1276 } 1277 continue; 1278 } 1279 1280 default: 1281 set_detailed_error("Illegal frame type."); 1282 DLOG(WARNING) << "Illegal frame type: " 1283 << static_cast<int>(frame_type); 1284 return RaiseError(QUIC_INVALID_FRAME_DATA); 1285 } 1286 } 1287 1288 return true; 1289} 1290 1291bool QuicFramer::ProcessStreamFrame(uint8 frame_type, 1292 QuicStreamFrame* frame) { 1293 uint8 stream_flags = frame_type; 1294 1295 stream_flags &= ~kQuicFrameTypeStreamMask; 1296 1297 // Read from right to left: StreamID, Offset, Data Length, Fin. 1298 const uint8 stream_id_length = (stream_flags & kQuicStreamIDLengthMask) + 1; 1299 stream_flags >>= kQuicStreamIdShift; 1300 1301 uint8 offset_length = (stream_flags & kQuicStreamOffsetMask); 1302 // There is no encoding for 1 byte, only 0 and 2 through 8. 1303 if (offset_length > 0) { 1304 offset_length += 1; 1305 } 1306 stream_flags >>= kQuicStreamOffsetShift; 1307 1308 bool has_data_length = 1309 (stream_flags & kQuicStreamDataLengthMask) == kQuicStreamDataLengthMask; 1310 stream_flags >>= kQuicStreamDataLengthShift; 1311 1312 frame->fin = (stream_flags & kQuicStreamFinMask) == kQuicStreamFinShift; 1313 1314 frame->stream_id = 0; 1315 if (!reader_->ReadBytes(&frame->stream_id, stream_id_length)) { 1316 set_detailed_error("Unable to read stream_id."); 1317 return false; 1318 } 1319 1320 frame->offset = 0; 1321 if (!reader_->ReadBytes(&frame->offset, offset_length)) { 1322 set_detailed_error("Unable to read offset."); 1323 return false; 1324 } 1325 1326 StringPiece frame_data; 1327 if (has_data_length) { 1328 if (!reader_->ReadStringPiece16(&frame_data)) { 1329 set_detailed_error("Unable to read frame data."); 1330 return false; 1331 } 1332 } else { 1333 if (!reader_->ReadStringPiece(&frame_data, reader_->BytesRemaining())) { 1334 set_detailed_error("Unable to read frame data."); 1335 return false; 1336 } 1337 } 1338 // Point frame to the right data. 1339 frame->data.Clear(); 1340 if (!frame_data.empty()) { 1341 frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size()); 1342 } 1343 1344 return true; 1345} 1346 1347bool QuicFramer::ProcessAckFrame(const QuicPacketHeader& header, 1348 uint8 frame_type, 1349 QuicAckFrame* frame) { 1350 if (quic_version_ <= QUIC_VERSION_15) { 1351 if (!ProcessStopWaitingFrame(header, &frame->sent_info)) { 1352 return false; 1353 } 1354 } 1355 if (!ProcessReceivedInfo(frame_type, &frame->received_info)) { 1356 return false; 1357 } 1358 return true; 1359} 1360 1361bool QuicFramer::ProcessReceivedInfo(uint8 frame_type, 1362 ReceivedPacketInfo* received_info) { 1363 // Determine the three lengths from the frame type: largest observed length, 1364 // missing sequence number length, and missing range length. 1365 const QuicSequenceNumberLength missing_sequence_number_length = 1366 ReadSequenceNumberLength(frame_type); 1367 frame_type >>= kQuicSequenceNumberLengthShift; 1368 const QuicSequenceNumberLength largest_observed_sequence_number_length = 1369 ReadSequenceNumberLength(frame_type); 1370 frame_type >>= kQuicSequenceNumberLengthShift; 1371 received_info->is_truncated = frame_type & kQuicAckTruncatedMask; 1372 frame_type >>= kQuicAckTruncatedShift; 1373 bool has_nacks = frame_type & kQuicHasNacksMask; 1374 1375 if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) { 1376 set_detailed_error("Unable to read entropy hash for received packets."); 1377 return false; 1378 } 1379 1380 if (!reader_->ReadBytes(&received_info->largest_observed, 1381 largest_observed_sequence_number_length)) { 1382 set_detailed_error("Unable to read largest observed."); 1383 return false; 1384 } 1385 1386 uint64 delta_time_largest_observed_us; 1387 if (!reader_->ReadUFloat16(&delta_time_largest_observed_us)) { 1388 set_detailed_error("Unable to read delta time largest observed."); 1389 return false; 1390 } 1391 1392 if (delta_time_largest_observed_us == kUFloat16MaxValue) { 1393 received_info->delta_time_largest_observed = QuicTime::Delta::Infinite(); 1394 } else { 1395 received_info->delta_time_largest_observed = 1396 QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us); 1397 } 1398 1399 if (!has_nacks) { 1400 return true; 1401 } 1402 1403 uint8 num_missing_ranges; 1404 if (!reader_->ReadBytes(&num_missing_ranges, 1)) { 1405 set_detailed_error("Unable to read num missing packet ranges."); 1406 return false; 1407 } 1408 1409 QuicPacketSequenceNumber last_sequence_number = 1410 received_info->largest_observed; 1411 for (size_t i = 0; i < num_missing_ranges; ++i) { 1412 QuicPacketSequenceNumber missing_delta = 0; 1413 if (!reader_->ReadBytes(&missing_delta, missing_sequence_number_length)) { 1414 set_detailed_error("Unable to read missing sequence number delta."); 1415 return false; 1416 } 1417 last_sequence_number -= missing_delta; 1418 QuicPacketSequenceNumber range_length = 0; 1419 if (!reader_->ReadBytes(&range_length, PACKET_1BYTE_SEQUENCE_NUMBER)) { 1420 set_detailed_error("Unable to read missing sequence number range."); 1421 return false; 1422 } 1423 for (size_t i = 0; i <= range_length; ++i) { 1424 received_info->missing_packets.insert(last_sequence_number - i); 1425 } 1426 // Subtract an extra 1 to ensure ranges are represented efficiently and 1427 // can't overlap by 1 sequence number. This allows a missing_delta of 0 1428 // to represent an adjacent nack range. 1429 last_sequence_number -= (range_length + 1); 1430 } 1431 1432 if (quic_version_ != QUIC_VERSION_13) { 1433 // Parse the revived packets list. 1434 uint8 num_revived_packets; 1435 if (!reader_->ReadBytes(&num_revived_packets, 1)) { 1436 set_detailed_error("Unable to read num revived packets."); 1437 return false; 1438 } 1439 1440 for (size_t i = 0; i < num_revived_packets; ++i) { 1441 QuicPacketSequenceNumber revived_packet = 0; 1442 if (!reader_->ReadBytes(&revived_packet, 1443 largest_observed_sequence_number_length)) { 1444 set_detailed_error("Unable to read revived packet."); 1445 return false; 1446 } 1447 1448 received_info->revived_packets.insert(revived_packet); 1449 } 1450 } 1451 1452 return true; 1453} 1454 1455bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader& header, 1456 QuicStopWaitingFrame* stop_waiting) { 1457 if (!reader_->ReadBytes(&stop_waiting->entropy_hash, 1)) { 1458 set_detailed_error("Unable to read entropy hash for sent packets."); 1459 return false; 1460 } 1461 1462 QuicPacketSequenceNumber least_unacked_delta = 0; 1463 if (!reader_->ReadBytes(&least_unacked_delta, 1464 header.public_header.sequence_number_length)) { 1465 set_detailed_error("Unable to read least unacked delta."); 1466 return false; 1467 } 1468 DCHECK_GE(header.packet_sequence_number, least_unacked_delta); 1469 stop_waiting->least_unacked = 1470 header.packet_sequence_number - least_unacked_delta; 1471 1472 return true; 1473} 1474 1475bool QuicFramer::ProcessQuicCongestionFeedbackFrame( 1476 QuicCongestionFeedbackFrame* frame) { 1477 uint8 feedback_type; 1478 if (!reader_->ReadBytes(&feedback_type, 1)) { 1479 set_detailed_error("Unable to read congestion feedback type."); 1480 return false; 1481 } 1482 frame->type = 1483 static_cast<CongestionFeedbackType>(feedback_type); 1484 1485 switch (frame->type) { 1486 case kInterArrival: { 1487 CongestionFeedbackMessageInterArrival* inter_arrival = 1488 &frame->inter_arrival; 1489 if (quic_version_ == QUIC_VERSION_13) { 1490 uint16 unused_accumulated_number_of_lost_packets; 1491 if (!reader_->ReadUInt16( 1492 &unused_accumulated_number_of_lost_packets)) { 1493 set_detailed_error( 1494 "Unable to read accumulated number of lost packets."); 1495 return false; 1496 } 1497 } 1498 uint8 num_received_packets; 1499 if (!reader_->ReadBytes(&num_received_packets, 1)) { 1500 set_detailed_error("Unable to read num received packets."); 1501 return false; 1502 } 1503 1504 if (num_received_packets > 0u) { 1505 uint64 smallest_received; 1506 if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER, 1507 &smallest_received)) { 1508 set_detailed_error("Unable to read smallest received."); 1509 return false; 1510 } 1511 1512 uint64 time_received_us; 1513 if (!reader_->ReadUInt64(&time_received_us)) { 1514 set_detailed_error("Unable to read time received."); 1515 return false; 1516 } 1517 QuicTime time_received = creation_time_.Add( 1518 QuicTime::Delta::FromMicroseconds(time_received_us)); 1519 1520 inter_arrival->received_packet_times.insert( 1521 make_pair(smallest_received, time_received)); 1522 1523 for (uint8 i = 0; i < num_received_packets - 1; ++i) { 1524 uint16 sequence_delta; 1525 if (!reader_->ReadUInt16(&sequence_delta)) { 1526 set_detailed_error( 1527 "Unable to read sequence delta in received packets."); 1528 return false; 1529 } 1530 1531 int32 time_delta_us; 1532 if (!reader_->ReadBytes(&time_delta_us, sizeof(time_delta_us))) { 1533 set_detailed_error( 1534 "Unable to read time delta in received packets."); 1535 return false; 1536 } 1537 QuicPacketSequenceNumber packet = smallest_received + sequence_delta; 1538 inter_arrival->received_packet_times.insert( 1539 make_pair(packet, time_received.Add( 1540 QuicTime::Delta::FromMicroseconds(time_delta_us)))); 1541 } 1542 } 1543 break; 1544 } 1545 case kFixRate: { 1546 uint32 bitrate = 0; 1547 if (!reader_->ReadUInt32(&bitrate)) { 1548 set_detailed_error("Unable to read bitrate."); 1549 return false; 1550 } 1551 frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate); 1552 break; 1553 } 1554 case kTCP: { 1555 CongestionFeedbackMessageTCP* tcp = &frame->tcp; 1556 if (quic_version_ == QUIC_VERSION_13) { 1557 uint16 unused_accumulated_number_of_lost_packets; 1558 if (!reader_->ReadUInt16(&unused_accumulated_number_of_lost_packets)) { 1559 set_detailed_error( 1560 "Unable to read accumulated number of lost packets."); 1561 return false; 1562 } 1563 } 1564 // TODO(ianswett): Remove receive window, since it's constant. 1565 uint16 receive_window = 0; 1566 if (!reader_->ReadUInt16(&receive_window)) { 1567 set_detailed_error("Unable to read receive window."); 1568 return false; 1569 } 1570 // Simple bit packing, don't send the 4 least significant bits. 1571 tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4; 1572 break; 1573 } 1574 default: 1575 set_detailed_error("Illegal congestion feedback type."); 1576 DLOG(WARNING) << "Illegal congestion feedback type: " 1577 << frame->type; 1578 return RaiseError(QUIC_INVALID_FRAME_DATA); 1579 } 1580 1581 return true; 1582} 1583 1584bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) { 1585 if (!reader_->ReadUInt32(&frame->stream_id)) { 1586 set_detailed_error("Unable to read stream_id."); 1587 return false; 1588 } 1589 1590 if (quic_version_ > QUIC_VERSION_13) { 1591 if (!reader_->ReadUInt64(&frame->byte_offset)) { 1592 set_detailed_error("Unable to read rst stream sent byte offset."); 1593 return false; 1594 } 1595 } 1596 1597 uint32 error_code; 1598 if (!reader_->ReadUInt32(&error_code)) { 1599 set_detailed_error("Unable to read rst stream error code."); 1600 return false; 1601 } 1602 1603 if (error_code >= QUIC_STREAM_LAST_ERROR || 1604 error_code < QUIC_STREAM_NO_ERROR) { 1605 set_detailed_error("Invalid rst stream error code."); 1606 return false; 1607 } 1608 1609 frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code); 1610 1611 StringPiece error_details; 1612 if (!reader_->ReadStringPiece16(&error_details)) { 1613 set_detailed_error("Unable to read rst stream error details."); 1614 return false; 1615 } 1616 frame->error_details = error_details.as_string(); 1617 1618 return true; 1619} 1620 1621bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) { 1622 uint32 error_code; 1623 if (!reader_->ReadUInt32(&error_code)) { 1624 set_detailed_error("Unable to read connection close error code."); 1625 return false; 1626 } 1627 1628 if (error_code >= QUIC_LAST_ERROR || 1629 error_code < QUIC_NO_ERROR) { 1630 set_detailed_error("Invalid error code."); 1631 return false; 1632 } 1633 1634 frame->error_code = static_cast<QuicErrorCode>(error_code); 1635 1636 StringPiece error_details; 1637 if (!reader_->ReadStringPiece16(&error_details)) { 1638 set_detailed_error("Unable to read connection close error details."); 1639 return false; 1640 } 1641 frame->error_details = error_details.as_string(); 1642 1643 return true; 1644} 1645 1646bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) { 1647 uint32 error_code; 1648 if (!reader_->ReadUInt32(&error_code)) { 1649 set_detailed_error("Unable to read go away error code."); 1650 return false; 1651 } 1652 frame->error_code = static_cast<QuicErrorCode>(error_code); 1653 1654 if (error_code >= QUIC_LAST_ERROR || 1655 error_code < QUIC_NO_ERROR) { 1656 set_detailed_error("Invalid error code."); 1657 return false; 1658 } 1659 1660 uint32 stream_id; 1661 if (!reader_->ReadUInt32(&stream_id)) { 1662 set_detailed_error("Unable to read last good stream id."); 1663 return false; 1664 } 1665 frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id); 1666 1667 StringPiece reason_phrase; 1668 if (!reader_->ReadStringPiece16(&reason_phrase)) { 1669 set_detailed_error("Unable to read goaway reason."); 1670 return false; 1671 } 1672 frame->reason_phrase = reason_phrase.as_string(); 1673 1674 return true; 1675} 1676 1677bool QuicFramer::ProcessWindowUpdateFrame(QuicWindowUpdateFrame* frame) { 1678 if (!reader_->ReadUInt32(&frame->stream_id)) { 1679 set_detailed_error("Unable to read stream_id."); 1680 return false; 1681 } 1682 1683 if (!reader_->ReadUInt64(&frame->byte_offset)) { 1684 set_detailed_error("Unable to read window byte_offset."); 1685 return false; 1686 } 1687 1688 return true; 1689} 1690 1691bool QuicFramer::ProcessBlockedFrame(QuicBlockedFrame* frame) { 1692 if (!reader_->ReadUInt32(&frame->stream_id)) { 1693 set_detailed_error("Unable to read stream_id."); 1694 return false; 1695 } 1696 1697 return true; 1698} 1699 1700// static 1701StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket( 1702 const QuicEncryptedPacket& encrypted, 1703 QuicConnectionIdLength connection_id_length, 1704 bool includes_version, 1705 QuicSequenceNumberLength sequence_number_length) { 1706 return StringPiece( 1707 encrypted.data() + kStartOfHashData, GetStartOfEncryptedData( 1708 connection_id_length, includes_version, sequence_number_length) 1709 - kStartOfHashData); 1710} 1711 1712void QuicFramer::SetDecrypter(QuicDecrypter* decrypter) { 1713 DCHECK(alternative_decrypter_.get() == NULL); 1714 decrypter_.reset(decrypter); 1715} 1716 1717void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter, 1718 bool latch_once_used) { 1719 alternative_decrypter_.reset(decrypter); 1720 alternative_decrypter_latch_ = latch_once_used; 1721} 1722 1723const QuicDecrypter* QuicFramer::decrypter() const { 1724 return decrypter_.get(); 1725} 1726 1727const QuicDecrypter* QuicFramer::alternative_decrypter() const { 1728 return alternative_decrypter_.get(); 1729} 1730 1731void QuicFramer::SetEncrypter(EncryptionLevel level, 1732 QuicEncrypter* encrypter) { 1733 DCHECK_GE(level, 0); 1734 DCHECK_LT(level, NUM_ENCRYPTION_LEVELS); 1735 encrypter_[level].reset(encrypter); 1736} 1737 1738const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const { 1739 DCHECK_GE(level, 0); 1740 DCHECK_LT(level, NUM_ENCRYPTION_LEVELS); 1741 DCHECK(encrypter_[level].get() != NULL); 1742 return encrypter_[level].get(); 1743} 1744 1745void QuicFramer::SwapCryptersForTest(QuicFramer* other) { 1746 for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; i++) { 1747 encrypter_[i].swap(other->encrypter_[i]); 1748 } 1749 decrypter_.swap(other->decrypter_); 1750 alternative_decrypter_.swap(other->alternative_decrypter_); 1751 1752 const bool other_latch = other->alternative_decrypter_latch_; 1753 other->alternative_decrypter_latch_ = alternative_decrypter_latch_; 1754 alternative_decrypter_latch_ = other_latch; 1755} 1756 1757QuicEncryptedPacket* QuicFramer::EncryptPacket( 1758 EncryptionLevel level, 1759 QuicPacketSequenceNumber packet_sequence_number, 1760 const QuicPacket& packet) { 1761 DCHECK(encrypter_[level].get() != NULL); 1762 1763 scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket( 1764 packet_sequence_number, packet.AssociatedData(), packet.Plaintext())); 1765 if (out.get() == NULL) { 1766 RaiseError(QUIC_ENCRYPTION_FAILURE); 1767 return NULL; 1768 } 1769 StringPiece header_data = packet.BeforePlaintext(); 1770 size_t len = header_data.length() + out->length(); 1771 char* buffer = new char[len]; 1772 // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt(). 1773 memcpy(buffer, header_data.data(), header_data.length()); 1774 memcpy(buffer + header_data.length(), out->data(), out->length()); 1775 return new QuicEncryptedPacket(buffer, len, true); 1776} 1777 1778size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) { 1779 // In order to keep the code simple, we don't have the current encryption 1780 // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12. 1781 size_t min_plaintext_size = ciphertext_size; 1782 1783 for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; i++) { 1784 if (encrypter_[i].get() != NULL) { 1785 size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size); 1786 if (size < min_plaintext_size) { 1787 min_plaintext_size = size; 1788 } 1789 } 1790 } 1791 1792 return min_plaintext_size; 1793} 1794 1795bool QuicFramer::DecryptPayload(const QuicPacketHeader& header, 1796 const QuicEncryptedPacket& packet) { 1797 StringPiece encrypted; 1798 if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) { 1799 return false; 1800 } 1801 DCHECK(decrypter_.get() != NULL); 1802 decrypted_.reset(decrypter_->DecryptPacket( 1803 header.packet_sequence_number, 1804 GetAssociatedDataFromEncryptedPacket( 1805 packet, 1806 header.public_header.connection_id_length, 1807 header.public_header.version_flag, 1808 header.public_header.sequence_number_length), 1809 encrypted)); 1810 if (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) { 1811 decrypted_.reset(alternative_decrypter_->DecryptPacket( 1812 header.packet_sequence_number, 1813 GetAssociatedDataFromEncryptedPacket( 1814 packet, 1815 header.public_header.connection_id_length, 1816 header.public_header.version_flag, 1817 header.public_header.sequence_number_length), 1818 encrypted)); 1819 if (decrypted_.get() != NULL) { 1820 if (alternative_decrypter_latch_) { 1821 // Switch to the alternative decrypter and latch so that we cannot 1822 // switch back. 1823 decrypter_.reset(alternative_decrypter_.release()); 1824 } else { 1825 // Switch the alternative decrypter so that we use it first next time. 1826 decrypter_.swap(alternative_decrypter_); 1827 } 1828 } 1829 } 1830 1831 if (decrypted_.get() == NULL) { 1832 DLOG(WARNING) << "DecryptPacket failed"; 1833 return false; 1834 } 1835 1836 reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length())); 1837 return true; 1838} 1839 1840size_t QuicFramer::GetAckFrameSize( 1841 const QuicAckFrame& ack, 1842 QuicSequenceNumberLength sequence_number_length) { 1843 AckFrameInfo ack_info = GetAckFrameInfo(ack); 1844 QuicSequenceNumberLength largest_observed_length = 1845 GetMinSequenceNumberLength(ack.received_info.largest_observed); 1846 QuicSequenceNumberLength missing_sequence_number_length = 1847 GetMinSequenceNumberLength(ack_info.max_delta); 1848 1849 size_t ack_size = GetMinAckFrameSize(quic_version_, 1850 sequence_number_length, 1851 largest_observed_length); 1852 if (!ack_info.nack_ranges.empty()) { 1853 ack_size += kNumberOfMissingPacketsSize + 1854 (quic_version_ == QUIC_VERSION_13 ? 0 : kNumberOfRevivedPacketsSize); 1855 ack_size += ack_info.nack_ranges.size() * 1856 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); 1857 ack_size += 1858 ack.received_info.revived_packets.size() * largest_observed_length; 1859 } 1860 return ack_size; 1861} 1862 1863size_t QuicFramer::ComputeFrameLength( 1864 const QuicFrame& frame, 1865 bool last_frame_in_packet, 1866 QuicSequenceNumberLength sequence_number_length) { 1867 switch (frame.type) { 1868 case STREAM_FRAME: 1869 return GetMinStreamFrameSize(quic_version_, 1870 frame.stream_frame->stream_id, 1871 frame.stream_frame->offset, 1872 last_frame_in_packet) + 1873 frame.stream_frame->data.TotalBufferSize(); 1874 case ACK_FRAME: { 1875 return GetAckFrameSize(*frame.ack_frame, sequence_number_length); 1876 } 1877 case CONGESTION_FEEDBACK_FRAME: { 1878 size_t len = kQuicFrameTypeSize; 1879 const QuicCongestionFeedbackFrame& congestion_feedback = 1880 *frame.congestion_feedback_frame; 1881 len += 1; // Congestion feedback type. 1882 1883 switch (congestion_feedback.type) { 1884 case kInterArrival: { 1885 const CongestionFeedbackMessageInterArrival& inter_arrival = 1886 congestion_feedback.inter_arrival; 1887 if (quic_version_ == QUIC_VERSION_13) { 1888 len += 2; // Accumulated number of lost packets. 1889 } 1890 len += 1; // Number received packets. 1891 if (inter_arrival.received_packet_times.size() > 0) { 1892 len += PACKET_6BYTE_SEQUENCE_NUMBER; // Smallest received. 1893 len += 8; // Time. 1894 // 2 bytes per sequence number delta plus 4 bytes per delta time. 1895 len += PACKET_6BYTE_SEQUENCE_NUMBER * 1896 (inter_arrival.received_packet_times.size() - 1); 1897 } 1898 break; 1899 } 1900 case kFixRate: 1901 len += 4; // Bitrate. 1902 break; 1903 case kTCP: 1904 if (quic_version_ == QUIC_VERSION_13) { 1905 len += 2; // Accumulated number of lost packets. 1906 } 1907 len += 2; // Receive window. 1908 break; 1909 default: 1910 set_detailed_error("Illegal feedback type."); 1911 DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type; 1912 break; 1913 } 1914 return len; 1915 } 1916 case STOP_WAITING_FRAME: 1917 return GetStopWaitingFrameSize(sequence_number_length); 1918 case RST_STREAM_FRAME: 1919 return GetMinRstStreamFrameSize(quic_version_) + 1920 frame.rst_stream_frame->error_details.size(); 1921 case CONNECTION_CLOSE_FRAME: 1922 return GetMinConnectionCloseFrameSize() + 1923 frame.connection_close_frame->error_details.size(); 1924 case GOAWAY_FRAME: 1925 return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size(); 1926 case WINDOW_UPDATE_FRAME: 1927 return GetWindowUpdateFrameSize(); 1928 case BLOCKED_FRAME: 1929 return GetBlockedFrameSize(); 1930 case PADDING_FRAME: 1931 DCHECK(false); 1932 return 0; 1933 case NUM_FRAME_TYPES: 1934 DCHECK(false); 1935 return 0; 1936 } 1937 1938 // Not reachable, but some Chrome compilers can't figure that out. *sigh* 1939 DCHECK(false); 1940 return 0; 1941} 1942 1943bool QuicFramer::AppendTypeByte(const QuicFrame& frame, 1944 bool last_frame_in_packet, 1945 QuicDataWriter* writer) { 1946 uint8 type_byte = 0; 1947 switch (frame.type) { 1948 case STREAM_FRAME: { 1949 if (frame.stream_frame == NULL) { 1950 LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame."; 1951 } 1952 // Fin bit. 1953 type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0; 1954 1955 // Data Length bit. 1956 type_byte <<= kQuicStreamDataLengthShift; 1957 type_byte |= last_frame_in_packet ? 0 : kQuicStreamDataLengthMask; 1958 1959 // Offset 3 bits. 1960 type_byte <<= kQuicStreamOffsetShift; 1961 const size_t offset_len = GetStreamOffsetSize(frame.stream_frame->offset); 1962 if (offset_len > 0) { 1963 type_byte |= offset_len - 1; 1964 } 1965 1966 // stream id 2 bits. 1967 type_byte <<= kQuicStreamIdShift; 1968 type_byte |= GetStreamIdSize(frame.stream_frame->stream_id) - 1; 1969 type_byte |= kQuicFrameTypeStreamMask; // Set Stream Frame Type to 1. 1970 break; 1971 } 1972 case ACK_FRAME: 1973 return true; 1974 case CONGESTION_FEEDBACK_FRAME: { 1975 // TODO(ianswett): Use extra 5 bits in the congestion feedback framing. 1976 type_byte = kQuicFrameTypeCongestionFeedbackMask; 1977 break; 1978 } 1979 default: 1980 type_byte = frame.type; 1981 break; 1982 } 1983 1984 return writer->WriteUInt8(type_byte); 1985} 1986 1987// static 1988bool QuicFramer::AppendPacketSequenceNumber( 1989 QuicSequenceNumberLength sequence_number_length, 1990 QuicPacketSequenceNumber packet_sequence_number, 1991 QuicDataWriter* writer) { 1992 // Ensure the entire sequence number can be written. 1993 if (writer->capacity() - writer->length() < 1994 static_cast<size_t>(sequence_number_length)) { 1995 return false; 1996 } 1997 switch (sequence_number_length) { 1998 case PACKET_1BYTE_SEQUENCE_NUMBER: 1999 return writer->WriteUInt8( 2000 packet_sequence_number & k1ByteSequenceNumberMask); 2001 break; 2002 case PACKET_2BYTE_SEQUENCE_NUMBER: 2003 return writer->WriteUInt16( 2004 packet_sequence_number & k2ByteSequenceNumberMask); 2005 break; 2006 case PACKET_4BYTE_SEQUENCE_NUMBER: 2007 return writer->WriteUInt32( 2008 packet_sequence_number & k4ByteSequenceNumberMask); 2009 break; 2010 case PACKET_6BYTE_SEQUENCE_NUMBER: 2011 return writer->WriteUInt48( 2012 packet_sequence_number & k6ByteSequenceNumberMask); 2013 break; 2014 default: 2015 DCHECK(false) << "sequence_number_length: " << sequence_number_length; 2016 return false; 2017 } 2018} 2019 2020bool QuicFramer::AppendStreamFrame( 2021 const QuicStreamFrame& frame, 2022 bool last_frame_in_packet, 2023 QuicDataWriter* writer) { 2024 if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) { 2025 return false; 2026 } 2027 if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) { 2028 return false; 2029 } 2030 if (!last_frame_in_packet) { 2031 if (!writer->WriteUInt16(frame.data.TotalBufferSize())) { 2032 return false; 2033 } 2034 } 2035 2036 if (!writer->WriteIOVector(frame.data)) { 2037 return false; 2038 } 2039 return true; 2040} 2041 2042// static 2043void QuicFramer::set_version(const QuicVersion version) { 2044 DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version); 2045 quic_version_ = version; 2046} 2047 2048bool QuicFramer::AppendAckFrameAndTypeByte( 2049 const QuicPacketHeader& header, 2050 const QuicAckFrame& frame, 2051 QuicDataWriter* writer) { 2052 AckFrameInfo ack_info = GetAckFrameInfo(frame); 2053 QuicPacketSequenceNumber ack_largest_observed = 2054 frame.received_info.largest_observed; 2055 QuicSequenceNumberLength largest_observed_length = 2056 GetMinSequenceNumberLength(ack_largest_observed); 2057 QuicSequenceNumberLength missing_sequence_number_length = 2058 GetMinSequenceNumberLength(ack_info.max_delta); 2059 // Determine whether we need to truncate ranges. 2060 size_t available_range_bytes = writer->capacity() - writer->length() - 2061 GetMinAckFrameSize(quic_version_, 2062 header.public_header.sequence_number_length, 2063 largest_observed_length) - 2064 (quic_version_ == QUIC_VERSION_13 ? 0 : kNumberOfRevivedPacketsSize); 2065 size_t max_num_ranges = available_range_bytes / 2066 (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); 2067 max_num_ranges = 2068 min(static_cast<size_t>(numeric_limits<uint8>::max()), max_num_ranges); 2069 bool truncated = ack_info.nack_ranges.size() > max_num_ranges; 2070 DVLOG_IF(1, truncated) << "Truncating ack from " 2071 << ack_info.nack_ranges.size() << " ranges to " 2072 << max_num_ranges; 2073 2074 // Write out the type byte by setting the low order bits and doing shifts 2075 // to make room for the next bit flags to be set. 2076 // Whether there are any nacks. 2077 uint8 type_byte = ack_info.nack_ranges.empty() ? 0 : kQuicHasNacksMask; 2078 2079 // truncating bit. 2080 type_byte <<= kQuicAckTruncatedShift; 2081 type_byte |= truncated ? kQuicAckTruncatedMask : 0; 2082 2083 // Largest observed sequence number length. 2084 type_byte <<= kQuicSequenceNumberLengthShift; 2085 type_byte |= GetSequenceNumberFlags(largest_observed_length); 2086 2087 // Missing sequence number length. 2088 type_byte <<= kQuicSequenceNumberLengthShift; 2089 type_byte |= GetSequenceNumberFlags(missing_sequence_number_length); 2090 2091 type_byte |= kQuicFrameTypeAckMask; 2092 2093 if (!writer->WriteUInt8(type_byte)) { 2094 return false; 2095 } 2096 2097 if (quic_version_ <= QUIC_VERSION_15) { 2098 if (!AppendStopWaitingFrame(header, frame.sent_info, writer)) { 2099 return false; 2100 } 2101 } 2102 2103 const ReceivedPacketInfo& received_info = frame.received_info; 2104 QuicPacketEntropyHash ack_entropy_hash = received_info.entropy_hash; 2105 NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin(); 2106 if (truncated) { 2107 // Skip the nack ranges which the truncated ack won't include and set 2108 // a correct largest observed for the truncated ack. 2109 for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges); 2110 ++i) { 2111 ++ack_iter; 2112 } 2113 // If the last range is followed by acks, include them. 2114 // If the last range is followed by another range, specify the end of the 2115 // range as the largest_observed. 2116 ack_largest_observed = ack_iter->first - 1; 2117 // Also update the entropy so it matches the largest observed. 2118 ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed); 2119 ++ack_iter; 2120 } 2121 2122 if (!writer->WriteUInt8(ack_entropy_hash)) { 2123 return false; 2124 } 2125 2126 if (!AppendPacketSequenceNumber(largest_observed_length, 2127 ack_largest_observed, writer)) { 2128 return false; 2129 } 2130 2131 uint64 delta_time_largest_observed_us = kUFloat16MaxValue; 2132 if (!received_info.delta_time_largest_observed.IsInfinite()) { 2133 DCHECK_LE(0u, 2134 frame.received_info.delta_time_largest_observed.ToMicroseconds()); 2135 delta_time_largest_observed_us = 2136 received_info.delta_time_largest_observed.ToMicroseconds(); 2137 } 2138 2139 if (!writer->WriteUFloat16(delta_time_largest_observed_us)) { 2140 return false; 2141 } 2142 2143 if (ack_info.nack_ranges.empty()) { 2144 return true; 2145 } 2146 2147 const uint8 num_missing_ranges = 2148 min(ack_info.nack_ranges.size(), max_num_ranges); 2149 if (!writer->WriteBytes(&num_missing_ranges, 1)) { 2150 return false; 2151 } 2152 2153 int num_ranges_written = 0; 2154 QuicPacketSequenceNumber last_sequence_written = ack_largest_observed; 2155 for (; ack_iter != ack_info.nack_ranges.rend(); ++ack_iter) { 2156 // Calculate the delta to the last number in the range. 2157 QuicPacketSequenceNumber missing_delta = 2158 last_sequence_written - (ack_iter->first + ack_iter->second); 2159 if (!AppendPacketSequenceNumber(missing_sequence_number_length, 2160 missing_delta, writer)) { 2161 return false; 2162 } 2163 if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER, 2164 ack_iter->second, writer)) { 2165 return false; 2166 } 2167 // Subtract 1 so a missing_delta of 0 means an adjacent range. 2168 last_sequence_written = ack_iter->first - 1; 2169 ++num_ranges_written; 2170 } 2171 DCHECK_EQ(num_missing_ranges, num_ranges_written); 2172 2173 if (quic_version_ != QUIC_VERSION_13) { 2174 // Append revived packets. 2175 // If not all the revived packets fit, only mention the ones that do. 2176 uint8 num_revived_packets = 2177 min(received_info.revived_packets.size(), 2178 static_cast<size_t>(numeric_limits<uint8>::max())); 2179 num_revived_packets = min( 2180 static_cast<size_t>(num_revived_packets), 2181 (writer->capacity() - writer->length()) / largest_observed_length); 2182 if (!writer->WriteBytes(&num_revived_packets, 1)) { 2183 return false; 2184 } 2185 2186 SequenceNumberSet::const_iterator iter = 2187 received_info.revived_packets.begin(); 2188 for (int i = 0; i < num_revived_packets; ++i, ++iter) { 2189 LOG_IF(DFATAL, !ContainsKey(received_info.missing_packets, *iter)); 2190 if (!AppendPacketSequenceNumber(largest_observed_length, 2191 *iter, writer)) { 2192 return false; 2193 } 2194 } 2195 } 2196 2197 return true; 2198} 2199 2200bool QuicFramer::AppendCongestionFeedbackFrame( 2201 const QuicCongestionFeedbackFrame& frame, 2202 QuicDataWriter* writer) { 2203 if (!writer->WriteBytes(&frame.type, 1)) { 2204 return false; 2205 } 2206 2207 switch (frame.type) { 2208 case kInterArrival: { 2209 const CongestionFeedbackMessageInterArrival& inter_arrival = 2210 frame.inter_arrival; 2211 if (quic_version_ == QUIC_VERSION_13) { 2212 // accumulated_number_of_lost_packets is removed. Always write 0. 2213 if (!writer->WriteUInt16(0)) { 2214 return false; 2215 } 2216 } 2217 DCHECK_GE(numeric_limits<uint8>::max(), 2218 inter_arrival.received_packet_times.size()); 2219 if (inter_arrival.received_packet_times.size() > 2220 numeric_limits<uint8>::max()) { 2221 return false; 2222 } 2223 // TODO(ianswett): Make num_received_packets a varint. 2224 uint8 num_received_packets = 2225 inter_arrival.received_packet_times.size(); 2226 if (!writer->WriteBytes(&num_received_packets, 1)) { 2227 return false; 2228 } 2229 if (num_received_packets > 0) { 2230 TimeMap::const_iterator it = 2231 inter_arrival.received_packet_times.begin(); 2232 2233 QuicPacketSequenceNumber lowest_sequence = it->first; 2234 if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER, 2235 lowest_sequence, writer)) { 2236 return false; 2237 } 2238 2239 QuicTime lowest_time = it->second; 2240 if (!writer->WriteUInt64( 2241 lowest_time.Subtract(creation_time_).ToMicroseconds())) { 2242 return false; 2243 } 2244 2245 for (++it; it != inter_arrival.received_packet_times.end(); ++it) { 2246 QuicPacketSequenceNumber sequence_delta = it->first - lowest_sequence; 2247 DCHECK_GE(numeric_limits<uint16>::max(), sequence_delta); 2248 if (sequence_delta > numeric_limits<uint16>::max()) { 2249 return false; 2250 } 2251 if (!writer->WriteUInt16(static_cast<uint16>(sequence_delta))) { 2252 return false; 2253 } 2254 2255 int32 time_delta_us = 2256 it->second.Subtract(lowest_time).ToMicroseconds(); 2257 if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) { 2258 return false; 2259 } 2260 } 2261 } 2262 break; 2263 } 2264 case kFixRate: { 2265 const CongestionFeedbackMessageFixRate& fix_rate = 2266 frame.fix_rate; 2267 if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) { 2268 return false; 2269 } 2270 break; 2271 } 2272 case kTCP: { 2273 const CongestionFeedbackMessageTCP& tcp = frame.tcp; 2274 DCHECK_LE(tcp.receive_window, 1u << 20); 2275 // Simple bit packing, don't send the 4 least significant bits. 2276 uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4); 2277 if (quic_version_ == QUIC_VERSION_13) { 2278 // accumulated_number_of_lost_packets is removed. Always write 0. 2279 if (!writer->WriteUInt16(0)) { 2280 return false; 2281 } 2282 } 2283 if (!writer->WriteUInt16(receive_window)) { 2284 return false; 2285 } 2286 break; 2287 } 2288 default: 2289 return false; 2290 } 2291 2292 return true; 2293} 2294 2295bool QuicFramer::AppendStopWaitingFrame( 2296 const QuicPacketHeader& header, 2297 const QuicStopWaitingFrame& frame, 2298 QuicDataWriter* writer) { 2299 DCHECK_GE(header.packet_sequence_number, frame.least_unacked); 2300 const QuicPacketSequenceNumber least_unacked_delta = 2301 header.packet_sequence_number - frame.least_unacked; 2302 const QuicPacketSequenceNumber length_shift = 2303 header.public_header.sequence_number_length * 8; 2304 if (!writer->WriteUInt8(frame.entropy_hash)) { 2305 LOG(DFATAL) << " hash failed"; 2306 return false; 2307 } 2308 2309 if (least_unacked_delta >> length_shift > 0) { 2310 LOG(DFATAL) << "sequence_number_length " 2311 << header.public_header.sequence_number_length 2312 << " is too small for least_unacked_delta: " 2313 << least_unacked_delta; 2314 return false; 2315 } 2316 if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length, 2317 least_unacked_delta, writer)) { 2318 LOG(DFATAL) << " seq failed: " 2319 << header.public_header.sequence_number_length; 2320 return false; 2321 } 2322 2323 return true; 2324} 2325 2326bool QuicFramer::AppendRstStreamFrame( 2327 const QuicRstStreamFrame& frame, 2328 QuicDataWriter* writer) { 2329 if (!writer->WriteUInt32(frame.stream_id)) { 2330 return false; 2331 } 2332 2333 if (quic_version_ > QUIC_VERSION_13) { 2334 if (!writer->WriteUInt64(frame.byte_offset)) { 2335 return false; 2336 } 2337 } 2338 2339 uint32 error_code = static_cast<uint32>(frame.error_code); 2340 if (!writer->WriteUInt32(error_code)) { 2341 return false; 2342 } 2343 2344 if (!writer->WriteStringPiece16(frame.error_details)) { 2345 return false; 2346 } 2347 return true; 2348} 2349 2350bool QuicFramer::AppendConnectionCloseFrame( 2351 const QuicConnectionCloseFrame& frame, 2352 QuicDataWriter* writer) { 2353 uint32 error_code = static_cast<uint32>(frame.error_code); 2354 if (!writer->WriteUInt32(error_code)) { 2355 return false; 2356 } 2357 if (!writer->WriteStringPiece16(frame.error_details)) { 2358 return false; 2359 } 2360 return true; 2361} 2362 2363bool QuicFramer::AppendGoAwayFrame(const QuicGoAwayFrame& frame, 2364 QuicDataWriter* writer) { 2365 uint32 error_code = static_cast<uint32>(frame.error_code); 2366 if (!writer->WriteUInt32(error_code)) { 2367 return false; 2368 } 2369 uint32 stream_id = static_cast<uint32>(frame.last_good_stream_id); 2370 if (!writer->WriteUInt32(stream_id)) { 2371 return false; 2372 } 2373 if (!writer->WriteStringPiece16(frame.reason_phrase)) { 2374 return false; 2375 } 2376 return true; 2377} 2378 2379bool QuicFramer::AppendWindowUpdateFrame(const QuicWindowUpdateFrame& frame, 2380 QuicDataWriter* writer) { 2381 uint32 stream_id = static_cast<uint32>(frame.stream_id); 2382 if (!writer->WriteUInt32(stream_id)) { 2383 return false; 2384 } 2385 if (!writer->WriteUInt64(frame.byte_offset)) { 2386 return false; 2387 } 2388 return true; 2389} 2390 2391bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame& frame, 2392 QuicDataWriter* writer) { 2393 uint32 stream_id = static_cast<uint32>(frame.stream_id); 2394 if (!writer->WriteUInt32(stream_id)) { 2395 return false; 2396 } 2397 return true; 2398} 2399 2400bool QuicFramer::RaiseError(QuicErrorCode error) { 2401 DVLOG(1) << "Error detail: " << detailed_error_; 2402 set_error(error); 2403 visitor_->OnError(this); 2404 reader_.reset(NULL); 2405 return false; 2406} 2407 2408} // namespace net 2409