net/quic/quic_framer.cc

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