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