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