quic_framer.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
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/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#include "net/quic/quic_utils.h"
13
14using base::StringPiece;
15using std::make_pair;
16using std::map;
17using std::numeric_limits;
18using std::string;
19
20namespace net {
21
22namespace {
23
24// Mask to select the lowest 48 bits of a sequence number.
25const QuicPacketSequenceNumber kSequenceNumberMask =
26    GG_UINT64_C(0x0000FFFFFFFFFFFF);
27
28const uint32 kInvalidDeltaTime = 0xffffffff;
29
30// Returns the absolute value of the difference between |a| and |b|.
31QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a,
32                               QuicPacketSequenceNumber b) {
33  // Since these are unsigned numbers, we can't just return abs(a - b)
34  if (a < b) {
35    return b - a;
36  }
37  return a - b;
38}
39
40QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
41                                   QuicPacketSequenceNumber a,
42                                   QuicPacketSequenceNumber b) {
43  return (Delta(target, a) < Delta(target, b)) ? a : b;
44}
45
46}  // namespace
47
48QuicFramer::QuicFramer(QuicVersionTag version,
49                       QuicTime creation_time,
50                       bool is_server)
51    : visitor_(NULL),
52      fec_builder_(NULL),
53      error_(QUIC_NO_ERROR),
54      last_sequence_number_(0),
55      quic_version_(version),
56      decrypter_(QuicDecrypter::Create(kNULL)),
57      is_server_(is_server),
58      creation_time_(creation_time) {
59  DCHECK(IsSupportedVersion(version));
60  encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
61}
62
63QuicFramer::~QuicFramer() {}
64
65bool CanTruncate(const QuicFrame& frame) {
66  if (frame.type == ACK_FRAME ||
67      frame.type == CONNECTION_CLOSE_FRAME) {
68    return true;
69  }
70  return false;
71}
72
73// static
74size_t QuicFramer::GetMinStreamFrameSize() {
75  return kQuicFrameTypeSize + kQuicStreamIdSize +
76      kQuicStreamFinSize + kQuicStreamOffsetSize + kQuicStreamPayloadLengthSize;
77}
78
79// static
80size_t QuicFramer::GetMinAckFrameSize() {
81  return kQuicFrameTypeSize + kQuicEntropyHashSize + kSequenceNumberSize +
82      kQuicEntropyHashSize + kSequenceNumberSize +
83      kQuicDeltaTimeLargestObservedSize + kNumberOfMissingPacketsSize;
84}
85
86// static
87size_t QuicFramer::GetMinRstStreamFrameSize() {
88  return kQuicFrameTypeSize + kQuicStreamIdSize + kQuicErrorCodeSize +
89      kQuicErrorDetailsLengthSize;
90}
91
92// static
93size_t QuicFramer::GetMinConnectionCloseFrameSize() {
94  return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
95      GetMinAckFrameSize();
96}
97
98// static
99size_t QuicFramer::GetMinGoAwayFrameSize() {
100  return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
101      kQuicStreamIdSize;
102}
103
104bool QuicFramer::IsSupportedVersion(QuicVersionTag version) {
105  return version == kQuicVersion1;
106}
107
108size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
109  return kQuicGuidSize + kPublicFlagsSize +
110      number_versions * kQuicVersionSize;
111}
112
113size_t QuicFramer::GetSerializedFrameLength(
114    const QuicFrame& frame, size_t free_bytes, bool first_frame) {
115  if (frame.type == PADDING_FRAME) {
116    // PADDING implies end of packet.
117    return free_bytes;
118  }
119  size_t frame_len = ComputeFrameLength(frame);
120  if (frame_len > free_bytes) {
121    // Only truncate the first frame in a packet, so if subsequent ones go
122    // over, stop including more frames.
123    if (!first_frame) {
124      return 0;
125    }
126    if (CanTruncate(frame)) {
127      // Truncate the frame so the packet will not exceed kMaxPacketSize.
128      // Note that we may not use every byte of the writer in this case.
129      if (free_bytes >= GetMinAckFrameSize()) {
130        DLOG(INFO) << "Truncating large frame";
131        return free_bytes;
132      }
133      return 0;
134    }
135  }
136  return frame_len;
137}
138
139QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
140    const QuicPacketHeader& header) const {
141  if (!header.entropy_flag) {
142    // TODO(satyamshekhar): Return some more better value here (something that
143    // is not a constant).
144    return 0;
145  }
146  return 1 << (header.packet_sequence_number % 8);
147}
148
149SerializedPacket QuicFramer::ConstructFrameDataPacket(
150    const QuicPacketHeader& header,
151    const QuicFrames& frames) {
152  const size_t max_plaintext_size = GetMaxPlaintextSize(kMaxPacketSize);
153  size_t packet_size = GetPacketHeaderSize(header.public_header.version_flag);
154  for (size_t i = 0; i < frames.size(); ++i) {
155    DCHECK_LE(packet_size, max_plaintext_size);
156    const size_t frame_size = GetSerializedFrameLength(
157        frames[i], max_plaintext_size - packet_size, i == 0);
158    DCHECK(frame_size);
159    packet_size += frame_size;
160  }
161  return ConstructFrameDataPacket(header, frames, packet_size);
162}
163
164SerializedPacket QuicFramer::ConstructFrameDataPacket(
165    const QuicPacketHeader& header,
166    const QuicFrames& frames,
167    size_t packet_size) {
168  QuicDataWriter writer(packet_size);
169  SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
170  if (!WritePacketHeader(header, &writer)) {
171    return kNoPacket;
172  }
173
174  for (size_t i = 0; i < frames.size(); ++i) {
175    const QuicFrame& frame = frames[i];
176    if (!writer.WriteUInt8(frame.type)) {
177      return kNoPacket;
178    }
179
180    switch (frame.type) {
181      case PADDING_FRAME:
182        writer.WritePadding();
183        break;
184      case STREAM_FRAME:
185        if (!AppendStreamFramePayload(*frame.stream_frame, &writer)) {
186          return kNoPacket;
187        }
188        break;
189      case ACK_FRAME:
190        if (!AppendAckFramePayload(*frame.ack_frame, &writer)) {
191          return kNoPacket;
192        }
193        break;
194      case CONGESTION_FEEDBACK_FRAME:
195        if (!AppendQuicCongestionFeedbackFramePayload(
196                *frame.congestion_feedback_frame, &writer)) {
197          return kNoPacket;
198        }
199        break;
200      case RST_STREAM_FRAME:
201        if (!AppendRstStreamFramePayload(*frame.rst_stream_frame, &writer)) {
202          return kNoPacket;
203        }
204        break;
205      case CONNECTION_CLOSE_FRAME:
206        if (!AppendConnectionCloseFramePayload(
207                *frame.connection_close_frame, &writer)) {
208          return kNoPacket;
209        }
210        break;
211      case GOAWAY_FRAME:
212        if (!AppendGoAwayFramePayload(*frame.goaway_frame, &writer)) {
213          return kNoPacket;
214        }
215        break;
216      default:
217        RaiseError(QUIC_INVALID_FRAME_DATA);
218        return kNoPacket;
219    }
220  }
221
222  // Save the length before writing, because take clears it.
223  const size_t len = writer.length();
224  // Less than or equal because truncated acks end up with max_plaintex_size
225  // length, even though they're typically slightly shorter.
226  DCHECK_LE(len, packet_size);
227  QuicPacket* packet = QuicPacket::NewDataPacket(
228      writer.take(), len, true, header.public_header.version_flag);
229
230  if (fec_builder_) {
231    fec_builder_->OnBuiltFecProtectedPayload(header,
232                                             packet->FecProtectedData());
233  }
234
235  return SerializedPacket(header.packet_sequence_number, packet,
236                          GetPacketEntropyHash(header), NULL);
237}
238
239SerializedPacket QuicFramer::ConstructFecPacket(const QuicPacketHeader& header,
240                                                const QuicFecData& fec) {
241  size_t len = GetPacketHeaderSize(header.public_header.version_flag);
242  len += fec.redundancy.length();
243
244  QuicDataWriter writer(len);
245  SerializedPacket kNoPacket = SerializedPacket(0, NULL, 0, NULL);
246  if (!WritePacketHeader(header, &writer)) {
247    return kNoPacket;
248  }
249
250  if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
251    return kNoPacket;
252  }
253
254  return SerializedPacket(header.packet_sequence_number,
255                          QuicPacket::NewFecPacket(
256                              writer.take(), len, true,
257                              header.public_header.version_flag),
258                          GetPacketEntropyHash(header), NULL);
259}
260
261// static
262QuicEncryptedPacket* QuicFramer::ConstructPublicResetPacket(
263    const QuicPublicResetPacket& packet) {
264  DCHECK(packet.public_header.reset_flag);
265  size_t len = GetPublicResetPacketSize();
266  QuicDataWriter writer(len);
267
268  if (!writer.WriteUInt64(packet.public_header.guid)) {
269    return NULL;
270  }
271
272  uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST);
273  if (!writer.WriteUInt8(flags)) {
274    return NULL;
275  }
276
277  if (!writer.WriteUInt64(packet.nonce_proof)) {
278    return NULL;
279  }
280
281  if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
282                                  &writer)) {
283    return NULL;
284  }
285
286  return new QuicEncryptedPacket(writer.take(), len, true);
287}
288
289QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
290    const QuicPacketPublicHeader& header,
291    const QuicVersionTagList& supported_versions) {
292  DCHECK(header.version_flag);
293  size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
294  QuicDataWriter writer(len);
295
296  if (!writer.WriteUInt64(header.guid)) {
297    return NULL;
298  }
299
300  uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION);
301  if (!writer.WriteUInt8(flags)) {
302    return NULL;
303  }
304
305  for (size_t i = 0; i < supported_versions.size(); ++i) {
306    if (!writer.WriteUInt32(supported_versions[i])) {
307      return NULL;
308    }
309  }
310
311  return new QuicEncryptedPacket(writer.take(), len, true);
312}
313
314bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
315  DCHECK(!reader_.get());
316  reader_.reset(new QuicDataReader(packet.data(), packet.length()));
317
318  visitor_->OnPacket();
319
320  // First parse the public header.
321  QuicPacketPublicHeader public_header;
322  if (!ProcessPublicHeader(&public_header)) {
323    DLOG(WARNING) << "Unable to process public header.";
324    return RaiseError(QUIC_INVALID_PACKET_HEADER);
325  }
326
327  if (is_server_ && public_header.version_flag &&
328      public_header.versions[0] != quic_version_) {
329    if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
330      reader_.reset(NULL);
331      return true;
332    }
333  }
334
335  bool rv;
336  if (!is_server_ && public_header.version_flag) {
337    rv = ProcessVersionNegotiationPacket(&public_header);
338  } else if (public_header.reset_flag) {
339    rv = ProcessPublicResetPacket(public_header);
340  } else {
341    rv = ProcessDataPacket(public_header, packet);
342  }
343
344  reader_.reset(NULL);
345  return rv;
346}
347
348bool QuicFramer::ProcessVersionNegotiationPacket(
349    QuicPacketPublicHeader* public_header) {
350  DCHECK(!is_server_);
351  // Try reading at least once to raise error if the packet is invalid.
352  do {
353    QuicVersionTag version;
354    if (!reader_->ReadBytes(&version, kQuicVersionSize)) {
355      set_detailed_error("Unable to read supported version in negotiation.");
356      return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
357    }
358    public_header->versions.push_back(version);
359  } while (!reader_->IsDoneReading());
360
361  visitor_->OnVersionNegotiationPacket(*public_header);
362  return true;
363}
364
365bool QuicFramer::ProcessDataPacket(
366    const QuicPacketPublicHeader& public_header,
367    const QuicEncryptedPacket& packet) {
368  QuicPacketHeader header(public_header);
369  if (!ProcessPacketHeader(&header, packet)) {
370    DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessPacketHeader sets the error.
371    DLOG(WARNING) << "Unable to process data packet header.";
372    return false;
373  }
374
375  if (!visitor_->OnPacketHeader(header)) {
376    // The visitor suppresses further processing of the packet.
377    return true;
378  }
379
380  if (packet.length() > kMaxPacketSize) {
381    DLOG(WARNING) << "Packet too large: " << packet.length();
382    return RaiseError(QUIC_PACKET_TOO_LARGE);
383  }
384
385  // Handle the payload.
386  if (!header.fec_flag) {
387    if (header.fec_group != 0) {
388      StringPiece payload = reader_->PeekRemainingPayload();
389      visitor_->OnFecProtectedPayload(payload);
390    }
391    if (!ProcessFrameData()) {
392      DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
393      DLOG(WARNING) << "Unable to process frame data.";
394      return false;
395    }
396  } else {
397    QuicFecData fec_data;
398    fec_data.fec_group = header.fec_group;
399    fec_data.redundancy = reader_->ReadRemainingPayload();
400    visitor_->OnFecData(fec_data);
401  }
402
403  visitor_->OnPacketComplete();
404  return true;
405}
406
407bool QuicFramer::ProcessPublicResetPacket(
408    const QuicPacketPublicHeader& public_header) {
409  QuicPublicResetPacket packet(public_header);
410  if (!reader_->ReadUInt64(&packet.nonce_proof)) {
411    // TODO(satyamshekhar): Raise error.
412    set_detailed_error("Unable to read nonce proof.");
413    return false;
414  }
415  // TODO(satyamshekhar): validate nonce to protect against DoS.
416
417  if (!reader_->ReadUInt48(&packet.rejected_sequence_number)) {
418    set_detailed_error("Unable to read rejected sequence number.");
419    return false;
420  }
421  visitor_->OnPublicResetPacket(packet);
422  return true;
423}
424
425bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
426                                      StringPiece payload) {
427  DCHECK(!reader_.get());
428
429  visitor_->OnRevivedPacket();
430
431  header->entropy_hash = GetPacketEntropyHash(*header);
432
433  // TODO(satyamshekhar): Don't process if the visitor refuses the header.
434  visitor_->OnPacketHeader(*header);
435
436  if (payload.length() > kMaxPacketSize) {
437    set_detailed_error("Revived packet too large.");
438    return RaiseError(QUIC_PACKET_TOO_LARGE);
439  }
440
441  reader_.reset(new QuicDataReader(payload.data(), payload.length()));
442  if (!ProcessFrameData()) {
443    DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
444    DLOG(WARNING) << "Unable to process frame data.";
445    return false;
446  }
447
448  visitor_->OnPacketComplete();
449  reader_.reset(NULL);
450  return true;
451}
452
453bool QuicFramer::WritePacketHeader(const QuicPacketHeader& header,
454                                   QuicDataWriter* writer) {
455  if (!writer->WriteUInt64(header.public_header.guid)) {
456    return false;
457  }
458
459  uint8 flags = 0;
460  if (header.public_header.reset_flag) {
461    flags |= PACKET_PUBLIC_FLAGS_RST;
462  }
463  if (header.public_header.version_flag) {
464    flags |= PACKET_PUBLIC_FLAGS_VERSION;
465  }
466  if (!writer->WriteUInt8(flags)) {
467    return false;
468  }
469
470  if (header.public_header.version_flag) {
471    DCHECK(!is_server_);
472    writer->WriteUInt32(quic_version_);
473  }
474
475  if (!AppendPacketSequenceNumber(header.packet_sequence_number, writer)) {
476    return false;
477  }
478
479  flags = 0;
480  if (header.fec_flag) {
481    flags |= PACKET_PRIVATE_FLAGS_FEC;
482  }
483  if (header.entropy_flag) {
484    flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
485  }
486  if (header.fec_entropy_flag) {
487    flags |= PACKET_PRIVATE_FLAGS_FEC_ENTROPY;
488  }
489  if (!writer->WriteUInt8(flags)) {
490    return false;
491  }
492
493  // Offset from the current packet sequence number to the first fec
494  // protected packet, or kNoFecOffset to signal no FEC protection.
495  uint8 first_fec_protected_packet_offset = kNoFecOffset;
496
497  // The FEC group number is the sequence number of the first fec
498  // protected packet, or 0 if this packet is not protected.
499  if (header.fec_group != 0) {
500    DCHECK_GE(header.packet_sequence_number, header.fec_group);
501    DCHECK_GT(255u, header.packet_sequence_number - header.fec_group);
502    first_fec_protected_packet_offset =
503        header.packet_sequence_number - header.fec_group;
504  }
505  if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
506    return false;
507  }
508
509  return true;
510}
511
512QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
513    QuicPacketSequenceNumber packet_sequence_number) const {
514  // The new sequence number might have wrapped to the next epoch, or
515  // it might have reverse wrapped to the previous epoch, or it might
516  // remain in the same epoch.  Select the sequence number closest to the
517  // previous sequence number.
518  QuicPacketSequenceNumber epoch = last_sequence_number_ & ~kSequenceNumberMask;
519  QuicPacketSequenceNumber prev_epoch = epoch - (GG_UINT64_C(1) << 48);
520  QuicPacketSequenceNumber next_epoch = epoch + (GG_UINT64_C(1) << 48);
521
522  return ClosestTo(last_sequence_number_,
523                   epoch + packet_sequence_number,
524                   ClosestTo(last_sequence_number_,
525                             prev_epoch + packet_sequence_number,
526                             next_epoch + packet_sequence_number));
527}
528
529bool QuicFramer::ProcessPublicHeader(QuicPacketPublicHeader* public_header) {
530  if (!reader_->ReadUInt64(&public_header->guid)) {
531    set_detailed_error("Unable to read GUID.");
532    return false;
533  }
534
535  uint8 public_flags;
536  if (!reader_->ReadBytes(&public_flags, 1)) {
537    set_detailed_error("Unable to read public flags.");
538    return false;
539  }
540
541  if (public_flags > PACKET_PUBLIC_FLAGS_MAX) {
542    set_detailed_error("Illegal public flags value.");
543    return false;
544  }
545
546  public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
547  public_header->version_flag =
548      (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
549
550  if (public_header->reset_flag && public_header->version_flag) {
551    set_detailed_error("Got version flag in reset packet");
552    return false;
553  }
554
555  if (public_header->version_flag && is_server_) {
556    QuicVersionTag version;
557    if (!reader_->ReadUInt32(&version)) {
558      // Read the version only if the packet is from the client.
559      // version flag from the server means version negotiation packet.
560      set_detailed_error("Unable to read protocol version.");
561      return false;
562    }
563    public_header->versions.push_back(version);
564  }
565  return true;
566}
567
568// static
569bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
570                                    QuicGuid* guid) {
571  QuicDataReader reader(packet.data(), packet.length());
572  return reader.ReadUInt64(guid);
573}
574
575bool QuicFramer::ProcessPacketHeader(
576    QuicPacketHeader* header,
577    const QuicEncryptedPacket& packet) {
578  if (!ProcessPacketSequenceNumber(&header->packet_sequence_number)) {
579    set_detailed_error("Unable to read sequence number.");
580    return RaiseError(QUIC_INVALID_PACKET_HEADER);
581  }
582
583  if (header->packet_sequence_number == 0u) {
584    set_detailed_error("Packet sequence numbers cannot be 0.");
585    return RaiseError(QUIC_INVALID_PACKET_HEADER);
586  }
587
588  if (!DecryptPayload(header->packet_sequence_number,
589                      header->public_header.version_flag,
590                      packet)) {
591    set_detailed_error("Unable to decrypt payload.");
592    return RaiseError(QUIC_DECRYPTION_FAILURE);
593  }
594
595  uint8 private_flags;
596  if (!reader_->ReadBytes(&private_flags, 1)) {
597    set_detailed_error("Unable to read private flags.");
598    return RaiseError(QUIC_INVALID_PACKET_HEADER);
599  }
600
601  if (private_flags > PACKET_PRIVATE_FLAGS_MAX) {
602    set_detailed_error("Illegal private flags value.");
603    return RaiseError(QUIC_INVALID_PACKET_HEADER);
604  }
605
606  header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0;
607  header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0;
608  header->fec_entropy_flag =
609      (private_flags & PACKET_PRIVATE_FLAGS_FEC_ENTROPY) != 0;
610
611  uint8 first_fec_protected_packet_offset;
612  if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) {
613    set_detailed_error("Unable to read first fec protected packet offset.");
614    return RaiseError(QUIC_INVALID_PACKET_HEADER);
615  }
616  header->fec_group = first_fec_protected_packet_offset == kNoFecOffset ? 0 :
617      header->packet_sequence_number - first_fec_protected_packet_offset;
618
619  header->entropy_hash = GetPacketEntropyHash(*header);
620  // Set the last sequence number after we have decrypted the packet
621  // so we are confident is not attacker controlled.
622  last_sequence_number_ = header->packet_sequence_number;
623  return true;
624}
625
626bool QuicFramer::ProcessPacketSequenceNumber(
627    QuicPacketSequenceNumber* sequence_number) {
628  QuicPacketSequenceNumber wire_sequence_number;
629  if (!reader_->ReadUInt48(&wire_sequence_number)) {
630    return false;
631  }
632
633  *sequence_number =
634      CalculatePacketSequenceNumberFromWire(wire_sequence_number);
635  return true;
636}
637
638bool QuicFramer::ProcessFrameData() {
639  if (reader_->IsDoneReading()) {
640    set_detailed_error("Unable to read frame type.");
641    return RaiseError(QUIC_INVALID_FRAME_DATA);
642  }
643  while (!reader_->IsDoneReading()) {
644    uint8 frame_type;
645    if (!reader_->ReadBytes(&frame_type, 1)) {
646      set_detailed_error("Unable to read frame type.");
647      return RaiseError(QUIC_INVALID_FRAME_DATA);
648    }
649    switch (frame_type) {
650      case PADDING_FRAME:
651        // We're done with the packet
652        return true;
653      case STREAM_FRAME: {
654        QuicStreamFrame frame;
655        if (!ProcessStreamFrame(&frame)) {
656          return RaiseError(QUIC_INVALID_FRAME_DATA);
657        }
658        if (!visitor_->OnStreamFrame(frame)) {
659          DLOG(INFO) << "Visitor asked to stopped further processing.";
660          // Returning true since there was no parsing error.
661          return true;
662        }
663        break;
664      }
665      case ACK_FRAME: {
666        QuicAckFrame frame;
667        if (!ProcessAckFrame(&frame)) {
668          return RaiseError(QUIC_INVALID_FRAME_DATA);
669        }
670        if (!visitor_->OnAckFrame(frame)) {
671          DLOG(INFO) << "Visitor asked to stopped further processing.";
672          // Returning true since there was no parsing error.
673          return true;
674        }
675        break;
676      }
677      case CONGESTION_FEEDBACK_FRAME: {
678        QuicCongestionFeedbackFrame frame;
679        if (!ProcessQuicCongestionFeedbackFrame(&frame)) {
680          return RaiseError(QUIC_INVALID_FRAME_DATA);
681        }
682        if (!visitor_->OnCongestionFeedbackFrame(frame)) {
683          DLOG(INFO) << "Visitor asked to stopped further processing.";
684          // Returning true since there was no parsing error.
685          return true;
686        }
687        break;
688      }
689      case RST_STREAM_FRAME: {
690        QuicRstStreamFrame frame;
691        if (!ProcessRstStreamFrame(&frame)) {
692          return RaiseError(QUIC_INVALID_RST_STREAM_DATA);
693        }
694        if (!visitor_->OnRstStreamFrame(frame)) {
695          DLOG(INFO) << "Visitor asked to stopped further processing.";
696          // Returning true since there was no parsing error.
697          return true;
698        }
699        break;
700      }
701      case CONNECTION_CLOSE_FRAME: {
702        QuicConnectionCloseFrame frame;
703        if (!ProcessConnectionCloseFrame(&frame)) {
704          return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA);
705        }
706        if (!visitor_->OnConnectionCloseFrame(frame)) {
707          DLOG(INFO) << "Visitor asked to stopped further processing.";
708          // Returning true since there was no parsing error.
709          return true;
710        }
711        break;
712      }
713      case GOAWAY_FRAME: {
714        QuicGoAwayFrame goaway_frame;
715        if (!ProcessGoAwayFrame(&goaway_frame)) {
716          return RaiseError(QUIC_INVALID_GOAWAY_DATA);
717        }
718        if (!visitor_->OnGoAwayFrame(goaway_frame)) {
719          DLOG(INFO) << "Visitor asked to stopped further processing.";
720          // Returning true since there was no parsing error.
721          return true;
722        }
723        break;
724      }
725      default:
726        set_detailed_error("Illegal frame type.");
727        DLOG(WARNING) << "Illegal frame type: "
728                      << static_cast<int>(frame_type);
729        return RaiseError(QUIC_INVALID_FRAME_DATA);
730    }
731  }
732
733  return true;
734}
735
736bool QuicFramer::ProcessStreamFrame(QuicStreamFrame* frame) {
737  if (!reader_->ReadUInt32(&frame->stream_id)) {
738    set_detailed_error("Unable to read stream_id.");
739    return false;
740  }
741
742  uint8 fin;
743  if (!reader_->ReadBytes(&fin, 1)) {
744    set_detailed_error("Unable to read fin.");
745    return false;
746  }
747  if (fin > 1) {
748    set_detailed_error("Invalid fin value.");
749    return false;
750  }
751  frame->fin = (fin == 1);
752
753  if (!reader_->ReadUInt64(&frame->offset)) {
754    set_detailed_error("Unable to read offset.");
755    return false;
756  }
757
758  if (!reader_->ReadStringPiece16(&frame->data)) {
759    set_detailed_error("Unable to read frame data.");
760    return false;
761  }
762
763  return true;
764}
765
766bool QuicFramer::ProcessAckFrame(QuicAckFrame* frame) {
767  if (!ProcessSentInfo(&frame->sent_info)) {
768    return false;
769  }
770  if (!ProcessReceivedInfo(&frame->received_info)) {
771    return false;
772  }
773  return true;
774}
775
776bool QuicFramer::ProcessReceivedInfo(ReceivedPacketInfo* received_info) {
777  if (!reader_->ReadBytes(&received_info->entropy_hash, 1)) {
778    set_detailed_error("Unable to read entropy hash for received packets.");
779    return false;
780  }
781
782  if (!ProcessPacketSequenceNumber(&received_info->largest_observed)) {
783     set_detailed_error("Unable to read largest observed.");
784     return false;
785  }
786
787  uint32 delta_time_largest_observed_us;
788  if (!reader_->ReadUInt32(&delta_time_largest_observed_us)) {
789    set_detailed_error("Unable to read delta time largest observed.");
790    return false;
791  }
792
793  if (delta_time_largest_observed_us == kInvalidDeltaTime) {
794    received_info->delta_time_largest_observed = QuicTime::Delta::Infinite();
795  } else {
796    received_info->delta_time_largest_observed =
797        QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us);
798  }
799
800  uint8 num_missing_packets;
801  if (!reader_->ReadBytes(&num_missing_packets, 1)) {
802    set_detailed_error("Unable to read num missing packets.");
803    return false;
804  }
805
806  for (int i = 0; i < num_missing_packets; ++i) {
807    QuicPacketSequenceNumber sequence_number;
808    if (!ProcessPacketSequenceNumber(&sequence_number)) {
809      set_detailed_error("Unable to read sequence number in missing packets.");
810      return false;
811    }
812    received_info->missing_packets.insert(sequence_number);
813  }
814
815  return true;
816}
817
818bool QuicFramer::ProcessSentInfo(SentPacketInfo* sent_info) {
819  if (!reader_->ReadBytes(&sent_info->entropy_hash, 1)) {
820    set_detailed_error("Unable to read entropy hash for sent packets.");
821    return false;
822  }
823
824  if (!ProcessPacketSequenceNumber(&sent_info->least_unacked)) {
825    set_detailed_error("Unable to read least unacked.");
826    return false;
827  }
828
829  return true;
830}
831
832bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
833    QuicCongestionFeedbackFrame* frame) {
834  uint8 feedback_type;
835  if (!reader_->ReadBytes(&feedback_type, 1)) {
836    set_detailed_error("Unable to read congestion feedback type.");
837    return false;
838  }
839  frame->type =
840      static_cast<CongestionFeedbackType>(feedback_type);
841
842  switch (frame->type) {
843    case kInterArrival: {
844      CongestionFeedbackMessageInterArrival* inter_arrival =
845          &frame->inter_arrival;
846      if (!reader_->ReadUInt16(
847              &inter_arrival->accumulated_number_of_lost_packets)) {
848        set_detailed_error(
849            "Unable to read accumulated number of lost packets.");
850        return false;
851      }
852      uint8 num_received_packets;
853      if (!reader_->ReadBytes(&num_received_packets, 1)) {
854        set_detailed_error("Unable to read num received packets.");
855        return false;
856      }
857
858      if (num_received_packets > 0u) {
859        uint64 smallest_received;
860        if (!ProcessPacketSequenceNumber(&smallest_received)) {
861          set_detailed_error("Unable to read smallest received.");
862          return false;
863        }
864
865        uint64 time_received_us;
866        if (!reader_->ReadUInt64(&time_received_us)) {
867          set_detailed_error("Unable to read time received.");
868          return false;
869        }
870        QuicTime time_received = creation_time_.Add(
871            QuicTime::Delta::FromMicroseconds(time_received_us));
872
873        inter_arrival->received_packet_times.insert(
874            make_pair(smallest_received, time_received));
875
876        for (int i = 0; i < num_received_packets - 1; ++i) {
877          uint16 sequence_delta;
878          if (!reader_->ReadUInt16(&sequence_delta)) {
879            set_detailed_error(
880                "Unable to read sequence delta in received packets.");
881            return false;
882          }
883
884          int32 time_delta_us;
885          if (!reader_->ReadBytes(&time_delta_us, sizeof(time_delta_us))) {
886            set_detailed_error(
887                "Unable to read time delta in received packets.");
888            return false;
889          }
890          QuicPacketSequenceNumber packet = smallest_received + sequence_delta;
891          inter_arrival->received_packet_times.insert(
892              make_pair(packet, time_received.Add(
893                  QuicTime::Delta::FromMicroseconds(time_delta_us))));
894        }
895      }
896      break;
897    }
898    case kFixRate: {
899      uint32 bitrate = 0;
900      if (!reader_->ReadUInt32(&bitrate)) {
901        set_detailed_error("Unable to read bitrate.");
902        return false;
903      }
904      frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(bitrate);
905      break;
906    }
907    case kTCP: {
908      CongestionFeedbackMessageTCP* tcp = &frame->tcp;
909      if (!reader_->ReadUInt16(&tcp->accumulated_number_of_lost_packets)) {
910        set_detailed_error(
911            "Unable to read accumulated number of lost packets.");
912        return false;
913      }
914      uint16 receive_window = 0;
915      if (!reader_->ReadUInt16(&receive_window)) {
916        set_detailed_error("Unable to read receive window.");
917        return false;
918      }
919      // Simple bit packing, don't send the 4 least significant bits.
920      tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4;
921      break;
922    }
923    default:
924      set_detailed_error("Illegal congestion feedback type.");
925      DLOG(WARNING) << "Illegal congestion feedback type: "
926                    << frame->type;
927      return RaiseError(QUIC_INVALID_FRAME_DATA);
928  }
929
930  return true;
931}
932
933bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) {
934  if (!reader_->ReadUInt32(&frame->stream_id)) {
935    set_detailed_error("Unable to read stream_id.");
936    return false;
937  }
938
939  uint32 error_code;
940  if (!reader_->ReadUInt32(&error_code)) {
941    set_detailed_error("Unable to read rst stream error code.");
942    return false;
943  }
944
945  if (error_code >= QUIC_STREAM_LAST_ERROR ||
946      error_code < QUIC_STREAM_NO_ERROR) {
947    set_detailed_error("Invalid rst stream error code.");
948    return false;
949  }
950
951  frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code);
952
953  StringPiece error_details;
954  if (!reader_->ReadStringPiece16(&error_details)) {
955    set_detailed_error("Unable to read rst stream error details.");
956    return false;
957  }
958  frame->error_details = error_details.as_string();
959
960  return true;
961}
962
963bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) {
964  uint32 error_code;
965  if (!reader_->ReadUInt32(&error_code)) {
966    set_detailed_error("Unable to read connection close error code.");
967    return false;
968  }
969
970  if (error_code >= QUIC_LAST_ERROR ||
971         error_code < QUIC_NO_ERROR) {
972    set_detailed_error("Invalid error code.");
973    return false;
974  }
975
976  frame->error_code = static_cast<QuicErrorCode>(error_code);
977
978  StringPiece error_details;
979  if (!reader_->ReadStringPiece16(&error_details)) {
980    set_detailed_error("Unable to read connection close error details.");
981    return false;
982  }
983  frame->error_details = error_details.as_string();
984
985  if (!ProcessAckFrame(&frame->ack_frame)) {
986    DLOG(WARNING) << "Unable to process ack frame.";
987    return false;
988  }
989
990  if (!visitor_->OnAckFrame(frame->ack_frame)) {
991    DLOG(INFO) << "Visitor asked to stopped further processing.";
992    // Returning true since there was no parsing error.
993    return true;
994  }
995
996  return true;
997}
998
999bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) {
1000  uint32 error_code;
1001  if (!reader_->ReadUInt32(&error_code)) {
1002    set_detailed_error("Unable to read go away error code.");
1003    return false;
1004  }
1005  frame->error_code = static_cast<QuicErrorCode>(error_code);
1006
1007  if (error_code >= QUIC_LAST_ERROR ||
1008      error_code < QUIC_NO_ERROR) {
1009    set_detailed_error("Invalid error code.");
1010    return false;
1011  }
1012
1013  uint32 stream_id;
1014  if (!reader_->ReadUInt32(&stream_id)) {
1015    set_detailed_error("Unable to read last good stream id.");
1016    return false;
1017  }
1018  frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id);
1019
1020  StringPiece reason_phrase;
1021  if (!reader_->ReadStringPiece16(&reason_phrase)) {
1022    set_detailed_error("Unable to read goaway reason.");
1023    return false;
1024  }
1025  frame->reason_phrase = reason_phrase.as_string();
1026
1027  return true;
1028}
1029
1030// static
1031StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket(
1032    const QuicEncryptedPacket& encrypted, bool includes_version) {
1033  return StringPiece(encrypted.data() + kStartOfHashData,
1034                     GetStartOfEncryptedData(includes_version) -
1035                         kStartOfHashData);
1036}
1037
1038void QuicFramer::SetDecrypter(QuicDecrypter* decrypter) {
1039  DCHECK(alternative_decrypter_.get() == NULL);
1040  decrypter_.reset(decrypter);
1041}
1042
1043void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter,
1044                                         bool latch_once_used) {
1045  alternative_decrypter_.reset(decrypter);
1046  alternative_decrypter_latch_ = latch_once_used;
1047}
1048
1049const QuicDecrypter* QuicFramer::decrypter() const {
1050  return decrypter_.get();
1051}
1052
1053const QuicDecrypter* QuicFramer::alternative_decrypter() const {
1054  return alternative_decrypter_.get();
1055}
1056
1057void QuicFramer::SetEncrypter(EncryptionLevel level,
1058                              QuicEncrypter* encrypter) {
1059  DCHECK_GE(level, 0);
1060  DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
1061  encrypter_[level].reset(encrypter);
1062}
1063
1064const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const {
1065  DCHECK_GE(level, 0);
1066  DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
1067  DCHECK(encrypter_[level].get() != NULL);
1068  return encrypter_[level].get();
1069}
1070
1071QuicEncryptedPacket* QuicFramer::EncryptPacket(
1072    EncryptionLevel level,
1073    QuicPacketSequenceNumber packet_sequence_number,
1074    const QuicPacket& packet) {
1075  DCHECK(encrypter_[level].get() != NULL);
1076
1077  scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket(
1078      packet_sequence_number, packet.AssociatedData(), packet.Plaintext()));
1079  if (out.get() == NULL) {
1080    RaiseError(QUIC_ENCRYPTION_FAILURE);
1081    return NULL;
1082  }
1083  StringPiece header_data = packet.BeforePlaintext();
1084  size_t len =  header_data.length() + out->length();
1085  char* buffer = new char[len];
1086  // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
1087  memcpy(buffer, header_data.data(), header_data.length());
1088  memcpy(buffer + header_data.length(), out->data(), out->length());
1089  return new QuicEncryptedPacket(buffer, len, true);
1090}
1091
1092size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
1093  // In order to keep the code simple, we don't have the current encryption
1094  // level to hand. At the moment, all AEADs have a tag-length of 16 bytes so
1095  // that doesn't matter but we take the minimum plaintext length just to be
1096  // safe.
1097  size_t min_plaintext_size = ciphertext_size;
1098
1099  for (int i = ENCRYPTION_NONE; i <= ENCRYPTION_FORWARD_SECURE; i++) {
1100    if (encrypter_[i].get() != NULL) {
1101      size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size);
1102      if (size < min_plaintext_size) {
1103        min_plaintext_size = size;
1104      }
1105    }
1106  }
1107
1108  return min_plaintext_size;
1109}
1110
1111bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
1112                                bool version_flag,
1113                                const QuicEncryptedPacket& packet) {
1114  StringPiece encrypted;
1115  if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
1116    return false;
1117  }
1118  DCHECK(decrypter_.get() != NULL);
1119  LOG(INFO) << "Decrypting packet";
1120  decrypted_.reset(decrypter_->DecryptPacket(
1121      sequence_number,
1122      GetAssociatedDataFromEncryptedPacket(packet, version_flag),
1123      encrypted));
1124  if  (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) {
1125    LOG(INFO) << "Trying alternative";
1126    decrypted_.reset(alternative_decrypter_->DecryptPacket(
1127        sequence_number,
1128        GetAssociatedDataFromEncryptedPacket(packet, version_flag),
1129        encrypted));
1130    if (decrypted_.get() != NULL) {
1131      LOG(INFO) << "alternative ok";
1132      if (alternative_decrypter_latch_) {
1133        LOG(INFO) << "  latching";
1134        // Switch to the alternative decrypter and latch so that we cannot
1135        // switch back.
1136        decrypter_.reset(alternative_decrypter_.release());
1137      } else {
1138        LOG(INFO) << "  swapping";
1139        // Switch the alternative decrypter so that we use it first next time.
1140        decrypter_.swap(alternative_decrypter_);
1141      }
1142    }
1143  }
1144
1145  if  (decrypted_.get() == NULL) {
1146    return false;
1147  }
1148
1149  reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
1150  return true;
1151}
1152
1153size_t QuicFramer::ComputeFrameLength(const QuicFrame& frame) {
1154  switch (frame.type) {
1155    case STREAM_FRAME:
1156      return GetMinStreamFrameSize() + frame.stream_frame->data.size();
1157    case ACK_FRAME: {
1158      const QuicAckFrame& ack = *frame.ack_frame;
1159      return GetMinAckFrameSize() +
1160          kSequenceNumberSize * ack.received_info.missing_packets.size();
1161    }
1162    case CONGESTION_FEEDBACK_FRAME: {
1163      size_t len = kQuicFrameTypeSize;
1164      const QuicCongestionFeedbackFrame& congestion_feedback =
1165          *frame.congestion_feedback_frame;
1166      len += 1;  // Congestion feedback type.
1167
1168      switch (congestion_feedback.type) {
1169        case kInterArrival: {
1170          const CongestionFeedbackMessageInterArrival& inter_arrival =
1171              congestion_feedback.inter_arrival;
1172          len += 2;
1173          len += 1;  // Number received packets.
1174          if (inter_arrival.received_packet_times.size() > 0) {
1175            len += kSequenceNumberSize;  // Smallest received.
1176            len += 8;  // Time.
1177            // 2 bytes per sequence number delta plus 4 bytes per delta time.
1178            len += kSequenceNumberSize *
1179                (inter_arrival.received_packet_times.size() - 1);
1180          }
1181          break;
1182        }
1183        case kFixRate:
1184          len += 4;
1185          break;
1186        case kTCP:
1187          len += 4;
1188          break;
1189        default:
1190          set_detailed_error("Illegal feedback type.");
1191          DLOG(INFO) << "Illegal feedback type: " << congestion_feedback.type;
1192          break;
1193      }
1194      return len;
1195    }
1196    case RST_STREAM_FRAME:
1197      return GetMinRstStreamFrameSize() +
1198          frame.rst_stream_frame->error_details.size();
1199    case CONNECTION_CLOSE_FRAME: {
1200      const QuicAckFrame& ack = frame.connection_close_frame->ack_frame;
1201      return GetMinConnectionCloseFrameSize() +
1202          frame.connection_close_frame->error_details.size() +
1203          kSequenceNumberSize * ack.received_info.missing_packets.size();
1204    }
1205    case GOAWAY_FRAME:
1206      return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size();
1207    case PADDING_FRAME:
1208      DCHECK(false);
1209      return 0;
1210    case NUM_FRAME_TYPES:
1211      DCHECK(false);
1212      return 0;
1213  }
1214
1215  // Not reachable, but some Chrome compilers can't figure that out.  *sigh*
1216  DCHECK(false);
1217  return 0;
1218}
1219
1220// static
1221bool QuicFramer::AppendPacketSequenceNumber(
1222    QuicPacketSequenceNumber packet_sequence_number,
1223    QuicDataWriter* writer) {
1224  // Ensure the entire sequence number can be written.
1225  if (writer->capacity() - writer->length() < kSequenceNumberSize) {
1226    return false;
1227  }
1228  return writer->WriteUInt48(packet_sequence_number & kSequenceNumberMask);
1229}
1230
1231bool QuicFramer::AppendStreamFramePayload(
1232    const QuicStreamFrame& frame,
1233    QuicDataWriter* writer) {
1234  if (!writer->WriteUInt32(frame.stream_id)) {
1235    return false;
1236  }
1237  if (!writer->WriteUInt8(frame.fin)) {
1238    return false;
1239  }
1240  if (!writer->WriteUInt64(frame.offset)) {
1241    return false;
1242  }
1243  if (!writer->WriteUInt16(frame.data.size())) {
1244    return false;
1245  }
1246  if (!writer->WriteBytes(frame.data.data(),
1247                           frame.data.size())) {
1248    return false;
1249  }
1250  return true;
1251}
1252
1253QuicPacketSequenceNumber QuicFramer::CalculateLargestObserved(
1254    const SequenceNumberSet& missing_packets,
1255    SequenceNumberSet::const_iterator largest_written) {
1256  SequenceNumberSet::const_iterator it = largest_written;
1257  QuicPacketSequenceNumber previous_missing = *it;
1258  ++it;
1259
1260  // See if the next thing is a gap in the missing packets: if it's a
1261  // non-missing packet we can return it.
1262  if (it != missing_packets.end() && previous_missing + 1 != *it) {
1263    return *it - 1;
1264  }
1265
1266  // Otherwise return the largest missing packet, as indirectly observed.
1267  return *largest_written;
1268}
1269
1270// TODO(ianswett): Use varints or another more compact approach for all deltas.
1271bool QuicFramer::AppendAckFramePayload(
1272    const QuicAckFrame& frame,
1273    QuicDataWriter* writer) {
1274  // TODO(satyamshekhar): Decide how often we really should send this
1275  // entropy_hash update.
1276  if (!writer->WriteUInt8(frame.sent_info.entropy_hash)) {
1277    return false;
1278  }
1279
1280  if (!AppendPacketSequenceNumber(frame.sent_info.least_unacked, writer)) {
1281    return false;
1282  }
1283
1284  size_t received_entropy_offset = writer->length();
1285  if (!writer->WriteUInt8(frame.received_info.entropy_hash)) {
1286    return false;
1287  }
1288
1289  size_t largest_observed_offset = writer->length();
1290  if (!AppendPacketSequenceNumber(frame.received_info.largest_observed,
1291                                  writer)) {
1292    return false;
1293  }
1294  uint32 delta_time_largest_observed_us = kInvalidDeltaTime;
1295  if (!frame.received_info.delta_time_largest_observed.IsInfinite()) {
1296    delta_time_largest_observed_us =
1297        frame.received_info.delta_time_largest_observed.ToMicroseconds();
1298  }
1299
1300  size_t delta_time_largest_observed_offset = writer->length();
1301  if (!writer->WriteUInt32(delta_time_largest_observed_us)) {
1302    return false;
1303  }
1304
1305  // We don't check for overflowing uint8 here, because we only can fit 192 acks
1306  // per packet, so if we overflow we will be truncated.
1307  uint8 num_missing_packets = frame.received_info.missing_packets.size();
1308  size_t num_missing_packets_offset = writer->length();
1309  if (!writer->WriteBytes(&num_missing_packets, 1)) {
1310    return false;
1311  }
1312
1313  SequenceNumberSet::const_iterator it =
1314      frame.received_info.missing_packets.begin();
1315  int num_missing_packets_written = 0;
1316  for (; it != frame.received_info.missing_packets.end(); ++it) {
1317    if (!AppendPacketSequenceNumber(*it, writer)) {
1318      // We are truncating.
1319      QuicPacketSequenceNumber largest_observed =
1320          CalculateLargestObserved(frame.received_info.missing_packets, --it);
1321      // Overwrite entropy hash for received packets.
1322      writer->WriteUInt8ToOffset(
1323          entropy_calculator_->ReceivedEntropyHash(largest_observed),
1324          received_entropy_offset);
1325      // Overwrite largest_observed.
1326      writer->WriteUInt48ToOffset(largest_observed & kSequenceNumberMask,
1327                                  largest_observed_offset);
1328      writer->WriteUInt32ToOffset(kInvalidDeltaTime,
1329                                  delta_time_largest_observed_offset);
1330      writer->WriteUInt8ToOffset(num_missing_packets_written,
1331                                 num_missing_packets_offset);
1332      return true;
1333    }
1334    ++num_missing_packets_written;
1335    DCHECK_GE(numeric_limits<uint8>::max(), num_missing_packets_written);
1336  }
1337
1338  return true;
1339}
1340
1341bool QuicFramer::AppendQuicCongestionFeedbackFramePayload(
1342    const QuicCongestionFeedbackFrame& frame,
1343    QuicDataWriter* writer) {
1344  if (!writer->WriteBytes(&frame.type, 1)) {
1345    return false;
1346  }
1347
1348  switch (frame.type) {
1349    case kInterArrival: {
1350      const CongestionFeedbackMessageInterArrival& inter_arrival =
1351          frame.inter_arrival;
1352      if (!writer->WriteUInt16(
1353              inter_arrival.accumulated_number_of_lost_packets)) {
1354        return false;
1355      }
1356      DCHECK_GE(numeric_limits<uint8>::max(),
1357                inter_arrival.received_packet_times.size());
1358      if (inter_arrival.received_packet_times.size() >
1359          numeric_limits<uint8>::max()) {
1360        return false;
1361      }
1362      // TODO(ianswett): Make num_received_packets a varint.
1363      uint8 num_received_packets =
1364          inter_arrival.received_packet_times.size();
1365      if (!writer->WriteBytes(&num_received_packets, 1)) {
1366        return false;
1367      }
1368      if (num_received_packets > 0) {
1369        TimeMap::const_iterator it =
1370            inter_arrival.received_packet_times.begin();
1371
1372        QuicPacketSequenceNumber lowest_sequence = it->first;
1373        if (!AppendPacketSequenceNumber(lowest_sequence, writer)) {
1374          return false;
1375        }
1376
1377        QuicTime lowest_time = it->second;
1378        if (!writer->WriteUInt64(
1379                lowest_time.Subtract(creation_time_).ToMicroseconds())) {
1380          return false;
1381        }
1382
1383        for (++it; it != inter_arrival.received_packet_times.end(); ++it) {
1384          QuicPacketSequenceNumber sequence_delta = it->first - lowest_sequence;
1385          DCHECK_GE(numeric_limits<uint16>::max(), sequence_delta);
1386          if (sequence_delta > numeric_limits<uint16>::max()) {
1387            return false;
1388          }
1389          if (!writer->WriteUInt16(static_cast<uint16>(sequence_delta))) {
1390            return false;
1391          }
1392
1393          int32 time_delta_us =
1394              it->second.Subtract(lowest_time).ToMicroseconds();
1395          if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
1396            return false;
1397          }
1398        }
1399      }
1400      break;
1401    }
1402    case kFixRate: {
1403      const CongestionFeedbackMessageFixRate& fix_rate =
1404          frame.fix_rate;
1405      if (!writer->WriteUInt32(fix_rate.bitrate.ToBytesPerSecond())) {
1406        return false;
1407      }
1408      break;
1409    }
1410    case kTCP: {
1411      const CongestionFeedbackMessageTCP& tcp = frame.tcp;
1412      DCHECK_LE(tcp.receive_window, 1u << 20);
1413      // Simple bit packing, don't send the 4 least significant bits.
1414      uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4);
1415      if (!writer->WriteUInt16(tcp.accumulated_number_of_lost_packets)) {
1416        return false;
1417      }
1418      if (!writer->WriteUInt16(receive_window)) {
1419        return false;
1420      }
1421      break;
1422    }
1423    default:
1424      return false;
1425  }
1426
1427  return true;
1428}
1429
1430bool QuicFramer::AppendRstStreamFramePayload(
1431        const QuicRstStreamFrame& frame,
1432        QuicDataWriter* writer) {
1433  if (!writer->WriteUInt32(frame.stream_id)) {
1434    return false;
1435  }
1436
1437  uint32 error_code = static_cast<uint32>(frame.error_code);
1438  if (!writer->WriteUInt32(error_code)) {
1439    return false;
1440  }
1441
1442  if (!writer->WriteStringPiece16(frame.error_details)) {
1443    return false;
1444  }
1445  return true;
1446}
1447
1448bool QuicFramer::AppendConnectionCloseFramePayload(
1449    const QuicConnectionCloseFrame& frame,
1450    QuicDataWriter* writer) {
1451  uint32 error_code = static_cast<uint32>(frame.error_code);
1452  if (!writer->WriteUInt32(error_code)) {
1453    return false;
1454  }
1455  if (!writer->WriteStringPiece16(frame.error_details)) {
1456    return false;
1457  }
1458  AppendAckFramePayload(frame.ack_frame, writer);
1459  return true;
1460}
1461
1462bool QuicFramer::AppendGoAwayFramePayload(const QuicGoAwayFrame& frame,
1463                                          QuicDataWriter* writer) {
1464  uint32 error_code = static_cast<uint32>(frame.error_code);
1465  if (!writer->WriteUInt32(error_code)) {
1466    return false;
1467  }
1468  uint32 stream_id = static_cast<uint32>(frame.last_good_stream_id);
1469  if (!writer->WriteUInt32(stream_id)) {
1470    return false;
1471  }
1472  if (!writer->WriteStringPiece16(frame.reason_phrase)) {
1473    return false;
1474  }
1475  return true;
1476}
1477
1478bool QuicFramer::RaiseError(QuicErrorCode error) {
1479  DLOG(INFO) << detailed_error_;
1480  set_error(error);
1481  visitor_->OnError(this);
1482  reader_.reset(NULL);
1483  return false;
1484}
1485
1486}  // namespace net
1487