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.
5 #include "net/quic/quic_framer.h"
7 #include "base/containers/hash_tables.h"
8 #include "base/stl_util.h"
9 #include "net/quic/crypto/crypto_framer.h"
10 #include "net/quic/crypto/crypto_handshake_message.h"
11 #include "net/quic/crypto/crypto_protocol.h"
12 #include "net/quic/crypto/quic_decrypter.h"
13 #include "net/quic/crypto/quic_encrypter.h"
14 #include "net/quic/quic_data_reader.h"
15 #include "net/quic/quic_data_writer.h"
16 #include "net/quic/quic_flags.h"
17 #include "net/quic/quic_socket_address_coder.h"
19 using base::StringPiece
;
24 using std::numeric_limits
;
31 // Mask to select the lowest 48 bits of a sequence number.
32 const QuicPacketSequenceNumber k6ByteSequenceNumberMask
=
33 GG_UINT64_C(0x0000FFFFFFFFFFFF);
34 const QuicPacketSequenceNumber k4ByteSequenceNumberMask
=
35 GG_UINT64_C(0x00000000FFFFFFFF);
36 const QuicPacketSequenceNumber k2ByteSequenceNumberMask
=
37 GG_UINT64_C(0x000000000000FFFF);
38 const QuicPacketSequenceNumber k1ByteSequenceNumberMask
=
39 GG_UINT64_C(0x00000000000000FF);
41 const QuicConnectionId k1ByteConnectionIdMask
= GG_UINT64_C(0x00000000000000FF);
42 const QuicConnectionId k4ByteConnectionIdMask
= GG_UINT64_C(0x00000000FFFFFFFF);
44 // Number of bits the sequence number length bits are shifted from the right
45 // edge of the public header.
46 const uint8 kPublicHeaderSequenceNumberShift
= 4;
48 // New Frame Types, QUIC v. >= 10:
49 // There are two interpretations for the Frame Type byte in the QUIC protocol,
50 // resulting in two Frame Types: Special Frame Types and Regular Frame Types.
52 // Regular Frame Types use the Frame Type byte simply. Currently defined
53 // Regular Frame Types are:
54 // Padding : 0b 00000000 (0x00)
55 // ResetStream : 0b 00000001 (0x01)
56 // ConnectionClose : 0b 00000010 (0x02)
57 // GoAway : 0b 00000011 (0x03)
58 // WindowUpdate : 0b 00000100 (0x04)
59 // Blocked : 0b 00000101 (0x05)
61 // Special Frame Types encode both a Frame Type and corresponding flags
62 // all in the Frame Type byte. Currently defined Special Frame Types are:
63 // Stream : 0b 1xxxxxxx
65 // CongestionFeedback : 0b 001xxxxx
67 // Semantics of the flag bits above (the x bits) depends on the frame type.
69 // Masks to determine if the frame type is a special use
70 // and for specific special frame types.
71 const uint8 kQuicFrameTypeSpecialMask
= 0xE0; // 0b 11100000
72 const uint8 kQuicFrameTypeStreamMask
= 0x80;
73 const uint8 kQuicFrameTypeAckMask
= 0x40;
74 const uint8 kQuicFrameTypeCongestionFeedbackMask
= 0x20;
76 // Stream frame relative shifts and masks for interpreting the stream flags.
77 // StreamID may be 1, 2, 3, or 4 bytes.
78 const uint8 kQuicStreamIdShift
= 2;
79 const uint8 kQuicStreamIDLengthMask
= 0x03;
81 // Offset may be 0, 2, 3, 4, 5, 6, 7, 8 bytes.
82 const uint8 kQuicStreamOffsetShift
= 3;
83 const uint8 kQuicStreamOffsetMask
= 0x07;
85 // Data length may be 0 or 2 bytes.
86 const uint8 kQuicStreamDataLengthShift
= 1;
87 const uint8 kQuicStreamDataLengthMask
= 0x01;
89 // Fin bit may be set or not.
90 const uint8 kQuicStreamFinShift
= 1;
91 const uint8 kQuicStreamFinMask
= 0x01;
93 // Sequence number size shift used in AckFrames.
94 const uint8 kQuicSequenceNumberLengthShift
= 2;
96 // Acks may be truncated.
97 const uint8 kQuicAckTruncatedShift
= 1;
98 const uint8 kQuicAckTruncatedMask
= 0x01;
100 // Acks may not have any nacks.
101 const uint8 kQuicHasNacksMask
= 0x01;
103 // Returns the absolute value of the difference between |a| and |b|.
104 QuicPacketSequenceNumber
Delta(QuicPacketSequenceNumber a
,
105 QuicPacketSequenceNumber b
) {
106 // Since these are unsigned numbers, we can't just return abs(a - b)
113 QuicPacketSequenceNumber
ClosestTo(QuicPacketSequenceNumber target
,
114 QuicPacketSequenceNumber a
,
115 QuicPacketSequenceNumber b
) {
116 return (Delta(target
, a
) < Delta(target
, b
)) ? a
: b
;
119 QuicSequenceNumberLength
ReadSequenceNumberLength(uint8 flags
) {
120 switch (flags
& PACKET_FLAGS_6BYTE_SEQUENCE
) {
121 case PACKET_FLAGS_6BYTE_SEQUENCE
:
122 return PACKET_6BYTE_SEQUENCE_NUMBER
;
123 case PACKET_FLAGS_4BYTE_SEQUENCE
:
124 return PACKET_4BYTE_SEQUENCE_NUMBER
;
125 case PACKET_FLAGS_2BYTE_SEQUENCE
:
126 return PACKET_2BYTE_SEQUENCE_NUMBER
;
127 case PACKET_FLAGS_1BYTE_SEQUENCE
:
128 return PACKET_1BYTE_SEQUENCE_NUMBER
;
130 LOG(DFATAL
) << "Unreachable case statement.";
131 return PACKET_6BYTE_SEQUENCE_NUMBER
;
136 QuicVersion version
, const QuicFrame
& frame
, size_t free_bytes
) {
137 if ((frame
.type
== ACK_FRAME
|| frame
.type
== CONNECTION_CLOSE_FRAME
) &&
139 QuicFramer::GetMinAckFrameSize(version
,
140 PACKET_6BYTE_SEQUENCE_NUMBER
,
141 PACKET_6BYTE_SEQUENCE_NUMBER
)) {
149 bool QuicFramerVisitorInterface::OnWindowUpdateFrame(
150 const QuicWindowUpdateFrame
& frame
) {
154 bool QuicFramerVisitorInterface::OnBlockedFrame(const QuicBlockedFrame
& frame
) {
158 QuicFramer::QuicFramer(const QuicVersionVector
& supported_versions
,
159 QuicTime creation_time
,
163 entropy_calculator_(NULL
),
164 error_(QUIC_NO_ERROR
),
165 last_sequence_number_(0),
166 last_serialized_connection_id_(0),
167 supported_versions_(supported_versions
),
168 alternative_decrypter_latch_(false),
169 is_server_(is_server
),
170 creation_time_(creation_time
) {
171 DCHECK(!supported_versions
.empty());
172 quic_version_
= supported_versions_
[0];
173 decrypter_
.reset(QuicDecrypter::Create(kNULL
));
174 encrypter_
[ENCRYPTION_NONE
].reset(
175 QuicEncrypter::Create(kNULL
));
178 QuicFramer::~QuicFramer() {}
181 size_t QuicFramer::GetMinStreamFrameSize(QuicVersion version
,
182 QuicStreamId stream_id
,
183 QuicStreamOffset offset
,
184 bool last_frame_in_packet
) {
185 return kQuicFrameTypeSize
+ GetStreamIdSize(stream_id
) +
186 GetStreamOffsetSize(offset
) +
187 (last_frame_in_packet
? 0 : kQuicStreamPayloadLengthSize
);
191 size_t QuicFramer::GetMinAckFrameSize(
193 QuicSequenceNumberLength sequence_number_length
,
194 QuicSequenceNumberLength largest_observed_length
) {
195 return kQuicFrameTypeSize
+ kQuicEntropyHashSize
+
196 sequence_number_length
+ kQuicEntropyHashSize
+
197 largest_observed_length
+ kQuicDeltaTimeLargestObservedSize
;
201 size_t QuicFramer::GetStopWaitingFrameSize(
202 QuicSequenceNumberLength sequence_number_length
) {
203 return kQuicFrameTypeSize
+ kQuicEntropyHashSize
+
204 sequence_number_length
;
208 size_t QuicFramer::GetMinRstStreamFrameSize(QuicVersion quic_version
) {
209 if (quic_version
> QUIC_VERSION_13
) {
210 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+
211 kQuicMaxStreamOffsetSize
+ kQuicErrorCodeSize
+
212 kQuicErrorDetailsLengthSize
;
214 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+ kQuicErrorCodeSize
+
215 kQuicErrorDetailsLengthSize
;
220 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
221 return kQuicFrameTypeSize
+ kQuicErrorCodeSize
+ kQuicErrorDetailsLengthSize
;
225 size_t QuicFramer::GetMinGoAwayFrameSize() {
226 return kQuicFrameTypeSize
+ kQuicErrorCodeSize
+ kQuicErrorDetailsLengthSize
+
227 kQuicMaxStreamIdSize
;
231 size_t QuicFramer::GetWindowUpdateFrameSize() {
232 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+ kQuicMaxStreamOffsetSize
;
236 size_t QuicFramer::GetBlockedFrameSize() {
237 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
;
241 size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id
) {
242 // Sizes are 1 through 4 bytes.
243 for (int i
= 1; i
<= 4; ++i
) {
245 if (stream_id
== 0) {
249 LOG(DFATAL
) << "Failed to determine StreamIDSize.";
254 size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset
) {
255 // 0 is a special case.
259 // 2 through 8 are the remaining sizes.
261 for (int i
= 2; i
<= 8; ++i
) {
267 LOG(DFATAL
) << "Failed to determine StreamOffsetSize.";
272 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions
) {
273 return kPublicFlagsSize
+ PACKET_8BYTE_CONNECTION_ID
+
274 number_versions
* kQuicVersionSize
;
277 bool QuicFramer::IsSupportedVersion(const QuicVersion version
) const {
278 for (size_t i
= 0; i
< supported_versions_
.size(); ++i
) {
279 if (version
== supported_versions_
[i
]) {
286 size_t QuicFramer::GetSerializedFrameLength(
287 const QuicFrame
& frame
,
291 QuicSequenceNumberLength sequence_number_length
) {
292 if (frame
.type
== PADDING_FRAME
) {
293 // PADDING implies end of packet.
297 ComputeFrameLength(frame
, last_frame
, sequence_number_length
);
298 if (frame_len
> free_bytes
) {
299 // Only truncate the first frame in a packet, so if subsequent ones go
300 // over, stop including more frames.
304 if (CanTruncate(quic_version_
, frame
, free_bytes
)) {
305 // Truncate the frame so the packet will not exceed kMaxPacketSize.
306 // Note that we may not use every byte of the writer in this case.
307 DVLOG(1) << "Truncating large frame";
309 } else if (!FLAGS_quic_allow_oversized_packets_for_test
) {
316 QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) { }
318 QuicFramer::AckFrameInfo::~AckFrameInfo() { }
320 QuicPacketEntropyHash
QuicFramer::GetPacketEntropyHash(
321 const QuicPacketHeader
& header
) const {
322 return header
.entropy_flag
<< (header
.packet_sequence_number
% 8);
326 SerializedPacket
QuicFramer::BuildUnsizedDataPacket(
327 const QuicPacketHeader
& header
,
328 const QuicFrames
& frames
) {
329 const size_t max_plaintext_size
= GetMaxPlaintextSize(kMaxPacketSize
);
330 size_t packet_size
= GetPacketHeaderSize(header
);
331 for (size_t i
= 0; i
< frames
.size(); ++i
) {
332 DCHECK_LE(packet_size
, max_plaintext_size
);
333 bool first_frame
= i
== 0;
334 bool last_frame
= i
== frames
.size() - 1;
335 const size_t frame_size
= GetSerializedFrameLength(
336 frames
[i
], max_plaintext_size
- packet_size
, first_frame
, last_frame
,
337 header
.public_header
.sequence_number_length
);
339 packet_size
+= frame_size
;
341 return BuildDataPacket(header
, frames
, packet_size
);
344 SerializedPacket
QuicFramer::BuildDataPacket(
345 const QuicPacketHeader
& header
,
346 const QuicFrames
& frames
,
347 size_t packet_size
) {
348 QuicDataWriter
writer(packet_size
);
349 const SerializedPacket
kNoPacket(
350 0, PACKET_1BYTE_SEQUENCE_NUMBER
, NULL
, 0, NULL
);
351 if (!AppendPacketHeader(header
, &writer
)) {
352 LOG(DFATAL
) << "AppendPacketHeader failed";
356 for (size_t i
= 0; i
< frames
.size(); ++i
) {
357 const QuicFrame
& frame
= frames
[i
];
359 const bool last_frame_in_packet
= i
== (frames
.size() - 1);
360 if (!AppendTypeByte(frame
, last_frame_in_packet
, &writer
)) {
361 LOG(DFATAL
) << "AppendTypeByte failed";
365 switch (frame
.type
) {
367 writer
.WritePadding();
370 if (!AppendStreamFrame(
371 *frame
.stream_frame
, last_frame_in_packet
, &writer
)) {
372 LOG(DFATAL
) << "AppendStreamFrame failed";
377 if (!AppendAckFrameAndTypeByte(
378 header
, *frame
.ack_frame
, &writer
)) {
379 LOG(DFATAL
) << "AppendAckFrameAndTypeByte failed";
383 case CONGESTION_FEEDBACK_FRAME
:
384 if (!AppendCongestionFeedbackFrame(
385 *frame
.congestion_feedback_frame
, &writer
)) {
386 LOG(DFATAL
) << "AppendCongestionFeedbackFrame failed";
390 case STOP_WAITING_FRAME
:
391 if (quic_version_
<= QUIC_VERSION_15
) {
392 LOG(DFATAL
) << "Attempt to add a StopWaitingFrame in "
393 << QuicVersionToString(quic_version_
);
396 if (!AppendStopWaitingFrame(
397 header
, *frame
.stop_waiting_frame
, &writer
)) {
398 LOG(DFATAL
) << "AppendStopWaitingFrame failed";
402 case RST_STREAM_FRAME
:
403 if (!AppendRstStreamFrame(*frame
.rst_stream_frame
, &writer
)) {
404 LOG(DFATAL
) << "AppendRstStreamFrame failed";
408 case CONNECTION_CLOSE_FRAME
:
409 if (!AppendConnectionCloseFrame(
410 *frame
.connection_close_frame
, &writer
)) {
411 LOG(DFATAL
) << "AppendConnectionCloseFrame failed";
416 if (!AppendGoAwayFrame(*frame
.goaway_frame
, &writer
)) {
417 LOG(DFATAL
) << "AppendGoAwayFrame failed";
421 case WINDOW_UPDATE_FRAME
:
422 if (quic_version_
> QUIC_VERSION_13
) {
423 if (!AppendWindowUpdateFrame(*frame
.window_update_frame
, &writer
)) {
424 LOG(DFATAL
) << "AppendWindowUpdateFrame failed";
428 LOG(DFATAL
) << "Attempt to add a WindowUpdateFrame in "
429 << QuicVersionToString(quic_version_
);
434 if (quic_version_
> QUIC_VERSION_13
) {
435 if (!AppendBlockedFrame(*frame
.blocked_frame
, &writer
)) {
436 LOG(DFATAL
) << "AppendBlockedFrame failed";
440 LOG(DFATAL
) << "Attempt to add a BlockedFrame in "
441 << QuicVersionToString(quic_version_
);
446 RaiseError(QUIC_INVALID_FRAME_DATA
);
447 LOG(DFATAL
) << "QUIC_INVALID_FRAME_DATA";
452 // Save the length before writing, because take clears it.
453 const size_t len
= writer
.length();
454 // Less than or equal because truncated acks end up with max_plaintex_size
455 // length, even though they're typically slightly shorter.
456 DCHECK_LE(len
, packet_size
);
457 QuicPacket
* packet
= QuicPacket::NewDataPacket(
458 writer
.take(), len
, true, header
.public_header
.connection_id_length
,
459 header
.public_header
.version_flag
,
460 header
.public_header
.sequence_number_length
);
463 fec_builder_
->OnBuiltFecProtectedPayload(header
,
464 packet
->FecProtectedData());
467 return SerializedPacket(header
.packet_sequence_number
,
468 header
.public_header
.sequence_number_length
, packet
,
469 GetPacketEntropyHash(header
), NULL
);
472 SerializedPacket
QuicFramer::BuildFecPacket(const QuicPacketHeader
& header
,
473 const QuicFecData
& fec
) {
474 DCHECK_EQ(IN_FEC_GROUP
, header
.is_in_fec_group
);
475 DCHECK_NE(0u, header
.fec_group
);
476 size_t len
= GetPacketHeaderSize(header
);
477 len
+= fec
.redundancy
.length();
479 QuicDataWriter
writer(len
);
480 const SerializedPacket
kNoPacket(
481 0, PACKET_1BYTE_SEQUENCE_NUMBER
, NULL
, 0, NULL
);
482 if (!AppendPacketHeader(header
, &writer
)) {
483 LOG(DFATAL
) << "AppendPacketHeader failed";
487 if (!writer
.WriteBytes(fec
.redundancy
.data(), fec
.redundancy
.length())) {
488 LOG(DFATAL
) << "Failed to add FEC";
492 return SerializedPacket(
493 header
.packet_sequence_number
,
494 header
.public_header
.sequence_number_length
,
495 QuicPacket::NewFecPacket(writer
.take(), len
, true,
496 header
.public_header
.connection_id_length
,
497 header
.public_header
.version_flag
,
498 header
.public_header
.sequence_number_length
),
499 GetPacketEntropyHash(header
), NULL
);
503 QuicEncryptedPacket
* QuicFramer::BuildPublicResetPacket(
504 const QuicPublicResetPacket
& packet
) {
505 DCHECK(packet
.public_header
.reset_flag
);
507 CryptoHandshakeMessage reset
;
508 reset
.set_tag(kPRST
);
509 reset
.SetValue(kRNON
, packet
.nonce_proof
);
510 reset
.SetValue(kRSEQ
, packet
.rejected_sequence_number
);
511 if (!packet
.client_address
.address().empty()) {
512 // packet.client_address is non-empty.
513 QuicSocketAddressCoder
address_coder(packet
.client_address
);
514 string serialized_address
= address_coder
.Encode();
515 if (serialized_address
.empty()) {
518 reset
.SetStringPiece(kCADR
, serialized_address
);
520 const QuicData
& reset_serialized
= reset
.GetSerialized();
523 kPublicFlagsSize
+ PACKET_8BYTE_CONNECTION_ID
+ reset_serialized
.length();
524 QuicDataWriter
writer(len
);
526 uint8 flags
= static_cast<uint8
>(PACKET_PUBLIC_FLAGS_RST
|
527 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
);
528 if (!writer
.WriteUInt8(flags
)) {
532 if (!writer
.WriteUInt64(packet
.public_header
.connection_id
)) {
536 if (!writer
.WriteBytes(reset_serialized
.data(), reset_serialized
.length())) {
540 return new QuicEncryptedPacket(writer
.take(), len
, true);
543 QuicEncryptedPacket
* QuicFramer::BuildVersionNegotiationPacket(
544 const QuicPacketPublicHeader
& header
,
545 const QuicVersionVector
& supported_versions
) {
546 DCHECK(header
.version_flag
);
547 size_t len
= GetVersionNegotiationPacketSize(supported_versions
.size());
548 QuicDataWriter
writer(len
);
550 uint8 flags
= static_cast<uint8
>(PACKET_PUBLIC_FLAGS_VERSION
|
551 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
);
552 if (!writer
.WriteUInt8(flags
)) {
556 if (!writer
.WriteUInt64(header
.connection_id
)) {
560 for (size_t i
= 0; i
< supported_versions
.size(); ++i
) {
561 if (!writer
.WriteUInt32(QuicVersionToQuicTag(supported_versions
[i
]))) {
566 return new QuicEncryptedPacket(writer
.take(), len
, true);
569 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket
& packet
) {
570 DCHECK(!reader_
.get());
571 reader_
.reset(new QuicDataReader(packet
.data(), packet
.length()));
573 visitor_
->OnPacket();
575 // First parse the public header.
576 QuicPacketPublicHeader public_header
;
577 if (!ProcessPublicHeader(&public_header
)) {
578 DLOG(WARNING
) << "Unable to process public header.";
579 DCHECK_NE("", detailed_error_
);
580 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
583 if (!visitor_
->OnUnauthenticatedPublicHeader(public_header
)) {
584 // The visitor suppresses further processing of the packet.
589 if (is_server_
&& public_header
.version_flag
&&
590 public_header
.versions
[0] != quic_version_
) {
591 if (!visitor_
->OnProtocolVersionMismatch(public_header
.versions
[0])) {
598 if (!is_server_
&& public_header
.version_flag
) {
599 rv
= ProcessVersionNegotiationPacket(&public_header
);
600 } else if (public_header
.reset_flag
) {
601 rv
= ProcessPublicResetPacket(public_header
);
603 rv
= ProcessDataPacket(public_header
, packet
);
610 bool QuicFramer::ProcessVersionNegotiationPacket(
611 QuicPacketPublicHeader
* public_header
) {
613 // Try reading at least once to raise error if the packet is invalid.
616 if (!reader_
->ReadBytes(&version
, kQuicVersionSize
)) {
617 set_detailed_error("Unable to read supported version in negotiation.");
618 return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET
);
620 public_header
->versions
.push_back(QuicTagToQuicVersion(version
));
621 } while (!reader_
->IsDoneReading());
623 visitor_
->OnVersionNegotiationPacket(*public_header
);
627 bool QuicFramer::ProcessDataPacket(
628 const QuicPacketPublicHeader
& public_header
,
629 const QuicEncryptedPacket
& packet
) {
630 QuicPacketHeader
header(public_header
);
631 if (!ProcessPacketHeader(&header
, packet
)) {
632 DLOG(WARNING
) << "Unable to process data packet header.";
636 if (!visitor_
->OnPacketHeader(header
)) {
637 // The visitor suppresses further processing of the packet.
641 if (packet
.length() > kMaxPacketSize
) {
642 DLOG(WARNING
) << "Packet too large: " << packet
.length();
643 return RaiseError(QUIC_PACKET_TOO_LARGE
);
646 // Handle the payload.
647 if (!header
.fec_flag
) {
648 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
649 StringPiece payload
= reader_
->PeekRemainingPayload();
650 visitor_
->OnFecProtectedPayload(payload
);
652 if (!ProcessFrameData(header
)) {
653 DCHECK_NE(QUIC_NO_ERROR
, error_
); // ProcessFrameData sets the error.
654 DLOG(WARNING
) << "Unable to process frame data.";
658 QuicFecData fec_data
;
659 fec_data
.fec_group
= header
.fec_group
;
660 fec_data
.redundancy
= reader_
->ReadRemainingPayload();
661 visitor_
->OnFecData(fec_data
);
664 visitor_
->OnPacketComplete();
668 bool QuicFramer::ProcessPublicResetPacket(
669 const QuicPacketPublicHeader
& public_header
) {
670 QuicPublicResetPacket
packet(public_header
);
672 if (public_header
.sequence_number_length
== PACKET_6BYTE_SEQUENCE_NUMBER
) {
673 // An old-style public reset packet has the
674 // PACKET_PUBLIC_FLAGS_6BYTE_SEQUENCE bits set in the public flags.
675 // TODO(wtc): remove this when we drop support for QUIC_VERSION_13.
676 if (!reader_
->ReadUInt64(&packet
.nonce_proof
)) {
677 set_detailed_error("Unable to read nonce proof.");
678 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
681 if (!reader_
->ReadUInt48(&packet
.rejected_sequence_number
)) {
682 set_detailed_error("Unable to read rejected sequence number.");
683 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
686 visitor_
->OnPublicResetPacket(packet
);
690 scoped_ptr
<CryptoHandshakeMessage
> reset(
691 CryptoFramer::ParseMessage(reader_
->ReadRemainingPayload()));
693 set_detailed_error("Unable to read reset message.");
694 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
696 if (reset
->tag() != kPRST
) {
697 set_detailed_error("Incorrect message tag.");
698 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
701 if (reset
->GetUint64(kRNON
, &packet
.nonce_proof
) != QUIC_NO_ERROR
) {
702 set_detailed_error("Unable to read nonce proof.");
703 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
705 // TODO(satyamshekhar): validate nonce to protect against DoS.
707 if (reset
->GetUint64(kRSEQ
, &packet
.rejected_sequence_number
) !=
709 set_detailed_error("Unable to read rejected sequence number.");
710 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
714 if (reset
->GetStringPiece(kCADR
, &address
)) {
715 QuicSocketAddressCoder address_coder
;
716 if (address_coder
.Decode(address
.data(), address
.length())) {
717 packet
.client_address
= IPEndPoint(address_coder
.ip(),
718 address_coder
.port());
722 visitor_
->OnPublicResetPacket(packet
);
726 bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader
* header
,
727 StringPiece payload
) {
728 DCHECK(!reader_
.get());
730 visitor_
->OnRevivedPacket();
732 header
->entropy_hash
= GetPacketEntropyHash(*header
);
734 if (!visitor_
->OnPacketHeader(*header
)) {
738 if (payload
.length() > kMaxPacketSize
) {
739 set_detailed_error("Revived packet too large.");
740 return RaiseError(QUIC_PACKET_TOO_LARGE
);
743 reader_
.reset(new QuicDataReader(payload
.data(), payload
.length()));
744 if (!ProcessFrameData(*header
)) {
745 DCHECK_NE(QUIC_NO_ERROR
, error_
); // ProcessFrameData sets the error.
746 DLOG(WARNING
) << "Unable to process frame data.";
750 visitor_
->OnPacketComplete();
755 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader
& header
,
756 QuicDataWriter
* writer
) {
757 DVLOG(1) << "Appending header: " << header
;
758 DCHECK(header
.fec_group
> 0 || header
.is_in_fec_group
== NOT_IN_FEC_GROUP
);
759 uint8 public_flags
= 0;
760 if (header
.public_header
.reset_flag
) {
761 public_flags
|= PACKET_PUBLIC_FLAGS_RST
;
763 if (header
.public_header
.version_flag
) {
764 public_flags
|= PACKET_PUBLIC_FLAGS_VERSION
;
768 GetSequenceNumberFlags(header
.public_header
.sequence_number_length
)
769 << kPublicHeaderSequenceNumberShift
;
771 switch (header
.public_header
.connection_id_length
) {
772 case PACKET_0BYTE_CONNECTION_ID
:
773 if (!writer
->WriteUInt8(
774 public_flags
| PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID
)) {
778 case PACKET_1BYTE_CONNECTION_ID
:
779 if (!writer
->WriteUInt8(
780 public_flags
| PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID
)) {
783 if (!writer
->WriteUInt8(
784 header
.public_header
.connection_id
& k1ByteConnectionIdMask
)) {
788 case PACKET_4BYTE_CONNECTION_ID
:
789 if (!writer
->WriteUInt8(
790 public_flags
| PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID
)) {
793 if (!writer
->WriteUInt32(
794 header
.public_header
.connection_id
& k4ByteConnectionIdMask
)) {
798 case PACKET_8BYTE_CONNECTION_ID
:
799 if (!writer
->WriteUInt8(
800 public_flags
| PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
)) {
803 if (!writer
->WriteUInt64(header
.public_header
.connection_id
)) {
808 last_serialized_connection_id_
= header
.public_header
.connection_id
;
810 if (header
.public_header
.version_flag
) {
812 writer
->WriteUInt32(QuicVersionToQuicTag(quic_version_
));
815 if (!AppendPacketSequenceNumber(header
.public_header
.sequence_number_length
,
816 header
.packet_sequence_number
, writer
)) {
820 uint8 private_flags
= 0;
821 if (header
.entropy_flag
) {
822 private_flags
|= PACKET_PRIVATE_FLAGS_ENTROPY
;
824 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
825 private_flags
|= PACKET_PRIVATE_FLAGS_FEC_GROUP
;
827 if (header
.fec_flag
) {
828 private_flags
|= PACKET_PRIVATE_FLAGS_FEC
;
830 if (!writer
->WriteUInt8(private_flags
)) {
834 // The FEC group number is the sequence number of the first fec
835 // protected packet, or 0 if this packet is not protected.
836 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
837 DCHECK_GE(header
.packet_sequence_number
, header
.fec_group
);
838 DCHECK_GT(255u, header
.packet_sequence_number
- header
.fec_group
);
839 // Offset from the current packet sequence number to the first fec
841 uint8 first_fec_protected_packet_offset
=
842 header
.packet_sequence_number
- header
.fec_group
;
843 if (!writer
->WriteBytes(&first_fec_protected_packet_offset
, 1)) {
851 QuicPacketSequenceNumber
QuicFramer::CalculatePacketSequenceNumberFromWire(
852 QuicSequenceNumberLength sequence_number_length
,
853 QuicPacketSequenceNumber packet_sequence_number
) const {
854 // The new sequence number might have wrapped to the next epoch, or
855 // it might have reverse wrapped to the previous epoch, or it might
856 // remain in the same epoch. Select the sequence number closest to the
857 // next expected sequence number, the previous sequence number plus 1.
859 // epoch_delta is the delta between epochs the sequence number was serialized
860 // with, so the correct value is likely the same epoch as the last sequence
861 // number or an adjacent epoch.
862 const QuicPacketSequenceNumber epoch_delta
=
863 GG_UINT64_C(1) << (8 * sequence_number_length
);
864 QuicPacketSequenceNumber next_sequence_number
= last_sequence_number_
+ 1;
865 QuicPacketSequenceNumber epoch
= last_sequence_number_
& ~(epoch_delta
- 1);
866 QuicPacketSequenceNumber prev_epoch
= epoch
- epoch_delta
;
867 QuicPacketSequenceNumber next_epoch
= epoch
+ epoch_delta
;
869 return ClosestTo(next_sequence_number
,
870 epoch
+ packet_sequence_number
,
871 ClosestTo(next_sequence_number
,
872 prev_epoch
+ packet_sequence_number
,
873 next_epoch
+ packet_sequence_number
));
876 bool QuicFramer::ProcessPublicHeader(
877 QuicPacketPublicHeader
* public_header
) {
879 if (!reader_
->ReadBytes(&public_flags
, 1)) {
880 set_detailed_error("Unable to read public flags.");
884 public_header
->reset_flag
= (public_flags
& PACKET_PUBLIC_FLAGS_RST
) != 0;
885 public_header
->version_flag
=
886 (public_flags
& PACKET_PUBLIC_FLAGS_VERSION
) != 0;
888 if (!public_header
->version_flag
&& public_flags
> PACKET_PUBLIC_FLAGS_MAX
) {
889 set_detailed_error("Illegal public flags value.");
893 if (public_header
->reset_flag
&& public_header
->version_flag
) {
894 set_detailed_error("Got version flag in reset packet");
898 switch (public_flags
& PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
) {
899 case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
:
900 if (!reader_
->ReadUInt64(&public_header
->connection_id
)) {
901 set_detailed_error("Unable to read ConnectionId.");
904 public_header
->connection_id_length
= PACKET_8BYTE_CONNECTION_ID
;
906 case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID
:
907 // If the connection_id is truncated, expect to read the last serialized
909 if (!reader_
->ReadBytes(&public_header
->connection_id
,
910 PACKET_4BYTE_CONNECTION_ID
)) {
911 set_detailed_error("Unable to read ConnectionId.");
914 if ((public_header
->connection_id
& k4ByteConnectionIdMask
) !=
915 (last_serialized_connection_id_
& k4ByteConnectionIdMask
)) {
916 set_detailed_error("Truncated 4 byte ConnectionId does not match "
917 "previous connection_id.");
920 public_header
->connection_id_length
= PACKET_4BYTE_CONNECTION_ID
;
921 public_header
->connection_id
= last_serialized_connection_id_
;
923 case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID
:
924 if (!reader_
->ReadBytes(&public_header
->connection_id
,
925 PACKET_1BYTE_CONNECTION_ID
)) {
926 set_detailed_error("Unable to read ConnectionId.");
929 if ((public_header
->connection_id
& k1ByteConnectionIdMask
) !=
930 (last_serialized_connection_id_
& k1ByteConnectionIdMask
)) {
931 set_detailed_error("Truncated 1 byte ConnectionId does not match "
932 "previous connection_id.");
935 public_header
->connection_id_length
= PACKET_1BYTE_CONNECTION_ID
;
936 public_header
->connection_id
= last_serialized_connection_id_
;
938 case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID
:
939 public_header
->connection_id_length
= PACKET_0BYTE_CONNECTION_ID
;
940 public_header
->connection_id
= last_serialized_connection_id_
;
944 public_header
->sequence_number_length
=
945 ReadSequenceNumberLength(
946 public_flags
>> kPublicHeaderSequenceNumberShift
);
948 // Read the version only if the packet is from the client.
949 // version flag from the server means version negotiation packet.
950 if (public_header
->version_flag
&& is_server_
) {
952 if (!reader_
->ReadUInt32(&version_tag
)) {
953 set_detailed_error("Unable to read protocol version.");
957 // If the version from the new packet is the same as the version of this
958 // framer, then the public flags should be set to something we understand.
959 // If not, this raises an error.
960 QuicVersion version
= QuicTagToQuicVersion(version_tag
);
961 if (version
== quic_version_
&& public_flags
> PACKET_PUBLIC_FLAGS_MAX
) {
962 set_detailed_error("Illegal public flags value.");
965 public_header
->versions
.push_back(version
);
971 QuicSequenceNumberLength
QuicFramer::GetMinSequenceNumberLength(
972 QuicPacketSequenceNumber sequence_number
) {
973 if (sequence_number
< 1 << (PACKET_1BYTE_SEQUENCE_NUMBER
* 8)) {
974 return PACKET_1BYTE_SEQUENCE_NUMBER
;
975 } else if (sequence_number
< 1 << (PACKET_2BYTE_SEQUENCE_NUMBER
* 8)) {
976 return PACKET_2BYTE_SEQUENCE_NUMBER
;
977 } else if (sequence_number
<
978 GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER
* 8)) {
979 return PACKET_4BYTE_SEQUENCE_NUMBER
;
981 return PACKET_6BYTE_SEQUENCE_NUMBER
;
986 uint8
QuicFramer::GetSequenceNumberFlags(
987 QuicSequenceNumberLength sequence_number_length
) {
988 switch (sequence_number_length
) {
989 case PACKET_1BYTE_SEQUENCE_NUMBER
:
990 return PACKET_FLAGS_1BYTE_SEQUENCE
;
991 case PACKET_2BYTE_SEQUENCE_NUMBER
:
992 return PACKET_FLAGS_2BYTE_SEQUENCE
;
993 case PACKET_4BYTE_SEQUENCE_NUMBER
:
994 return PACKET_FLAGS_4BYTE_SEQUENCE
;
995 case PACKET_6BYTE_SEQUENCE_NUMBER
:
996 return PACKET_FLAGS_6BYTE_SEQUENCE
;
998 LOG(DFATAL
) << "Unreachable case statement.";
999 return PACKET_FLAGS_6BYTE_SEQUENCE
;
1004 QuicFramer::AckFrameInfo
QuicFramer::GetAckFrameInfo(
1005 const QuicAckFrame
& frame
) {
1006 const ReceivedPacketInfo
& received_info
= frame
.received_info
;
1008 AckFrameInfo ack_info
;
1009 if (!received_info
.missing_packets
.empty()) {
1010 DCHECK_GE(received_info
.largest_observed
,
1011 *received_info
.missing_packets
.rbegin());
1012 size_t cur_range_length
= 0;
1013 SequenceNumberSet::const_iterator iter
=
1014 received_info
.missing_packets
.begin();
1015 QuicPacketSequenceNumber last_missing
= *iter
;
1017 for (; iter
!= received_info
.missing_packets
.end(); ++iter
) {
1018 if (cur_range_length
!= numeric_limits
<uint8
>::max() &&
1019 *iter
== (last_missing
+ 1)) {
1022 ack_info
.nack_ranges
[last_missing
- cur_range_length
]
1024 cur_range_length
= 0;
1026 ack_info
.max_delta
= max(ack_info
.max_delta
, *iter
- last_missing
);
1027 last_missing
= *iter
;
1029 // Include the last nack range.
1030 ack_info
.nack_ranges
[last_missing
- cur_range_length
] = cur_range_length
;
1031 // Include the range to the largest observed.
1032 ack_info
.max_delta
= max(ack_info
.max_delta
,
1033 received_info
.largest_observed
- last_missing
);
1038 bool QuicFramer::ProcessPacketHeader(
1039 QuicPacketHeader
* header
,
1040 const QuicEncryptedPacket
& packet
) {
1041 if (!ProcessPacketSequenceNumber(header
->public_header
.sequence_number_length
,
1042 &header
->packet_sequence_number
)) {
1043 set_detailed_error("Unable to read sequence number.");
1044 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1047 if (header
->packet_sequence_number
== 0u) {
1048 set_detailed_error("Packet sequence numbers cannot be 0.");
1049 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1052 if (!visitor_
->OnUnauthenticatedHeader(*header
)) {
1056 if (!DecryptPayload(*header
, packet
)) {
1057 set_detailed_error("Unable to decrypt payload.");
1058 return RaiseError(QUIC_DECRYPTION_FAILURE
);
1061 uint8 private_flags
;
1062 if (!reader_
->ReadBytes(&private_flags
, 1)) {
1063 set_detailed_error("Unable to read private flags.");
1064 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1067 if (private_flags
> PACKET_PRIVATE_FLAGS_MAX
) {
1068 set_detailed_error("Illegal private flags value.");
1069 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1072 header
->entropy_flag
= (private_flags
& PACKET_PRIVATE_FLAGS_ENTROPY
) != 0;
1073 header
->fec_flag
= (private_flags
& PACKET_PRIVATE_FLAGS_FEC
) != 0;
1075 if ((private_flags
& PACKET_PRIVATE_FLAGS_FEC_GROUP
) != 0) {
1076 header
->is_in_fec_group
= IN_FEC_GROUP
;
1077 uint8 first_fec_protected_packet_offset
;
1078 if (!reader_
->ReadBytes(&first_fec_protected_packet_offset
, 1)) {
1079 set_detailed_error("Unable to read first fec protected packet offset.");
1080 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1082 if (first_fec_protected_packet_offset
>= header
->packet_sequence_number
) {
1083 set_detailed_error("First fec protected packet offset must be less "
1084 "than the sequence number.");
1085 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1088 header
->packet_sequence_number
- first_fec_protected_packet_offset
;
1091 header
->entropy_hash
= GetPacketEntropyHash(*header
);
1092 // Set the last sequence number after we have decrypted the packet
1093 // so we are confident is not attacker controlled.
1094 last_sequence_number_
= header
->packet_sequence_number
;
1098 bool QuicFramer::ProcessPacketSequenceNumber(
1099 QuicSequenceNumberLength sequence_number_length
,
1100 QuicPacketSequenceNumber
* sequence_number
) {
1101 QuicPacketSequenceNumber wire_sequence_number
= 0u;
1102 if (!reader_
->ReadBytes(&wire_sequence_number
, sequence_number_length
)) {
1106 // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers
1107 // in case the first guess is incorrect.
1109 CalculatePacketSequenceNumberFromWire(sequence_number_length
,
1110 wire_sequence_number
);
1114 bool QuicFramer::ProcessFrameData(const QuicPacketHeader
& header
) {
1115 if (reader_
->IsDoneReading()) {
1116 set_detailed_error("Packet has no frames.");
1117 return RaiseError(QUIC_MISSING_PAYLOAD
);
1119 while (!reader_
->IsDoneReading()) {
1121 if (!reader_
->ReadBytes(&frame_type
, 1)) {
1122 set_detailed_error("Unable to read frame type.");
1123 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1126 if (frame_type
& kQuicFrameTypeSpecialMask
) {
1128 if (frame_type
& kQuicFrameTypeStreamMask
) {
1129 QuicStreamFrame frame
;
1130 if (!ProcessStreamFrame(frame_type
, &frame
)) {
1131 return RaiseError(QUIC_INVALID_STREAM_DATA
);
1133 if (!visitor_
->OnStreamFrame(frame
)) {
1134 DVLOG(1) << "Visitor asked to stop further processing.";
1135 // Returning true since there was no parsing error.
1142 if (frame_type
& kQuicFrameTypeAckMask
) {
1144 if (!ProcessAckFrame(header
, frame_type
, &frame
)) {
1145 return RaiseError(QUIC_INVALID_ACK_DATA
);
1147 if (!visitor_
->OnAckFrame(frame
)) {
1148 DVLOG(1) << "Visitor asked to stop further processing.";
1149 // Returning true since there was no parsing error.
1155 // Congestion Feedback Frame
1156 if (frame_type
& kQuicFrameTypeCongestionFeedbackMask
) {
1157 QuicCongestionFeedbackFrame frame
;
1158 if (!ProcessQuicCongestionFeedbackFrame(&frame
)) {
1159 return RaiseError(QUIC_INVALID_CONGESTION_FEEDBACK_DATA
);
1161 if (!visitor_
->OnCongestionFeedbackFrame(frame
)) {
1162 DVLOG(1) << "Visitor asked to stop further processing.";
1163 // Returning true since there was no parsing error.
1169 // This was a special frame type that did not match any
1170 // of the known ones. Error.
1171 set_detailed_error("Illegal frame type.");
1172 DLOG(WARNING
) << "Illegal frame type: "
1173 << static_cast<int>(frame_type
);
1174 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1177 switch (frame_type
) {
1179 // We're done with the packet.
1182 case RST_STREAM_FRAME
: {
1183 QuicRstStreamFrame frame
;
1184 if (!ProcessRstStreamFrame(&frame
)) {
1185 return RaiseError(QUIC_INVALID_RST_STREAM_DATA
);
1187 if (!visitor_
->OnRstStreamFrame(frame
)) {
1188 DVLOG(1) << "Visitor asked to stop further processing.";
1189 // Returning true since there was no parsing error.
1195 case CONNECTION_CLOSE_FRAME
: {
1196 QuicConnectionCloseFrame frame
;
1197 if (!ProcessConnectionCloseFrame(&frame
)) {
1198 return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA
);
1201 if (!visitor_
->OnConnectionCloseFrame(frame
)) {
1202 DVLOG(1) << "Visitor asked to stop further processing.";
1203 // Returning true since there was no parsing error.
1209 case GOAWAY_FRAME
: {
1210 QuicGoAwayFrame goaway_frame
;
1211 if (!ProcessGoAwayFrame(&goaway_frame
)) {
1212 return RaiseError(QUIC_INVALID_GOAWAY_DATA
);
1214 if (!visitor_
->OnGoAwayFrame(goaway_frame
)) {
1215 DVLOG(1) << "Visitor asked to stop further processing.";
1216 // Returning true since there was no parsing error.
1222 case WINDOW_UPDATE_FRAME
: {
1223 if (quic_version_
> QUIC_VERSION_13
) {
1224 QuicWindowUpdateFrame window_update_frame
;
1225 if (!ProcessWindowUpdateFrame(&window_update_frame
)) {
1226 return RaiseError(QUIC_INVALID_WINDOW_UPDATE_DATA
);
1228 if (!visitor_
->OnWindowUpdateFrame(window_update_frame
)) {
1229 DVLOG(1) << "Visitor asked to stop further processing.";
1230 // Returning true since there was no parsing error.
1234 LOG(DFATAL
) << "Trying to read a WindowUpdateFrame in "
1235 << QuicVersionToString(quic_version_
);
1236 return RaiseError(QUIC_INTERNAL_ERROR
);
1241 case BLOCKED_FRAME
: {
1242 if (quic_version_
> QUIC_VERSION_13
) {
1243 QuicBlockedFrame blocked_frame
;
1244 if (!ProcessBlockedFrame(&blocked_frame
)) {
1245 return RaiseError(QUIC_INVALID_BLOCKED_DATA
);
1247 if (!visitor_
->OnBlockedFrame(blocked_frame
)) {
1248 DVLOG(1) << "Visitor asked to stop further processing.";
1249 // Returning true since there was no parsing error.
1253 LOG(DFATAL
) << "Trying to read a BlockedFrame in "
1254 << QuicVersionToString(quic_version_
);
1255 return RaiseError(QUIC_INTERNAL_ERROR
);
1260 case STOP_WAITING_FRAME
: {
1261 if (quic_version_
<= QUIC_VERSION_15
) {
1262 LOG(DFATAL
) << "Trying to read a StopWaiting in "
1263 << QuicVersionToString(quic_version_
);
1264 return RaiseError(QUIC_INTERNAL_ERROR
);
1266 QuicStopWaitingFrame stop_waiting_frame
;
1267 if (!ProcessStopWaitingFrame(header
, &stop_waiting_frame
)) {
1268 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA
);
1270 if (!visitor_
->OnStopWaitingFrame(stop_waiting_frame
)) {
1271 DVLOG(1) << "Visitor asked to stop further processing.";
1272 // Returning true since there was no parsing error.
1279 set_detailed_error("Illegal frame type.");
1280 DLOG(WARNING
) << "Illegal frame type: "
1281 << static_cast<int>(frame_type
);
1282 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1289 bool QuicFramer::ProcessStreamFrame(uint8 frame_type
,
1290 QuicStreamFrame
* frame
) {
1291 uint8 stream_flags
= frame_type
;
1293 stream_flags
&= ~kQuicFrameTypeStreamMask
;
1295 // Read from right to left: StreamID, Offset, Data Length, Fin.
1296 const uint8 stream_id_length
= (stream_flags
& kQuicStreamIDLengthMask
) + 1;
1297 stream_flags
>>= kQuicStreamIdShift
;
1299 uint8 offset_length
= (stream_flags
& kQuicStreamOffsetMask
);
1300 // There is no encoding for 1 byte, only 0 and 2 through 8.
1301 if (offset_length
> 0) {
1304 stream_flags
>>= kQuicStreamOffsetShift
;
1306 bool has_data_length
=
1307 (stream_flags
& kQuicStreamDataLengthMask
) == kQuicStreamDataLengthMask
;
1308 stream_flags
>>= kQuicStreamDataLengthShift
;
1310 frame
->fin
= (stream_flags
& kQuicStreamFinMask
) == kQuicStreamFinShift
;
1312 frame
->stream_id
= 0;
1313 if (!reader_
->ReadBytes(&frame
->stream_id
, stream_id_length
)) {
1314 set_detailed_error("Unable to read stream_id.");
1319 if (!reader_
->ReadBytes(&frame
->offset
, offset_length
)) {
1320 set_detailed_error("Unable to read offset.");
1324 StringPiece frame_data
;
1325 if (has_data_length
) {
1326 if (!reader_
->ReadStringPiece16(&frame_data
)) {
1327 set_detailed_error("Unable to read frame data.");
1331 if (!reader_
->ReadStringPiece(&frame_data
, reader_
->BytesRemaining())) {
1332 set_detailed_error("Unable to read frame data.");
1336 // Point frame to the right data.
1337 frame
->data
.Clear();
1338 if (!frame_data
.empty()) {
1339 frame
->data
.Append(const_cast<char*>(frame_data
.data()), frame_data
.size());
1345 bool QuicFramer::ProcessAckFrame(const QuicPacketHeader
& header
,
1347 QuicAckFrame
* frame
) {
1348 if (quic_version_
<= QUIC_VERSION_15
) {
1349 if (!ProcessStopWaitingFrame(header
, &frame
->sent_info
)) {
1353 if (!ProcessReceivedInfo(frame_type
, &frame
->received_info
)) {
1359 bool QuicFramer::ProcessReceivedInfo(uint8 frame_type
,
1360 ReceivedPacketInfo
* received_info
) {
1361 // Determine the three lengths from the frame type: largest observed length,
1362 // missing sequence number length, and missing range length.
1363 const QuicSequenceNumberLength missing_sequence_number_length
=
1364 ReadSequenceNumberLength(frame_type
);
1365 frame_type
>>= kQuicSequenceNumberLengthShift
;
1366 const QuicSequenceNumberLength largest_observed_sequence_number_length
=
1367 ReadSequenceNumberLength(frame_type
);
1368 frame_type
>>= kQuicSequenceNumberLengthShift
;
1369 received_info
->is_truncated
= frame_type
& kQuicAckTruncatedMask
;
1370 frame_type
>>= kQuicAckTruncatedShift
;
1371 bool has_nacks
= frame_type
& kQuicHasNacksMask
;
1373 if (!reader_
->ReadBytes(&received_info
->entropy_hash
, 1)) {
1374 set_detailed_error("Unable to read entropy hash for received packets.");
1378 if (!reader_
->ReadBytes(&received_info
->largest_observed
,
1379 largest_observed_sequence_number_length
)) {
1380 set_detailed_error("Unable to read largest observed.");
1384 uint64 delta_time_largest_observed_us
;
1385 if (!reader_
->ReadUFloat16(&delta_time_largest_observed_us
)) {
1386 set_detailed_error("Unable to read delta time largest observed.");
1390 if (delta_time_largest_observed_us
== kUFloat16MaxValue
) {
1391 received_info
->delta_time_largest_observed
= QuicTime::Delta::Infinite();
1393 received_info
->delta_time_largest_observed
=
1394 QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us
);
1401 uint8 num_missing_ranges
;
1402 if (!reader_
->ReadBytes(&num_missing_ranges
, 1)) {
1403 set_detailed_error("Unable to read num missing packet ranges.");
1407 QuicPacketSequenceNumber last_sequence_number
=
1408 received_info
->largest_observed
;
1409 for (size_t i
= 0; i
< num_missing_ranges
; ++i
) {
1410 QuicPacketSequenceNumber missing_delta
= 0;
1411 if (!reader_
->ReadBytes(&missing_delta
, missing_sequence_number_length
)) {
1412 set_detailed_error("Unable to read missing sequence number delta.");
1415 last_sequence_number
-= missing_delta
;
1416 QuicPacketSequenceNumber range_length
= 0;
1417 if (!reader_
->ReadBytes(&range_length
, PACKET_1BYTE_SEQUENCE_NUMBER
)) {
1418 set_detailed_error("Unable to read missing sequence number range.");
1421 for (size_t i
= 0; i
<= range_length
; ++i
) {
1422 received_info
->missing_packets
.insert(last_sequence_number
- i
);
1424 // Subtract an extra 1 to ensure ranges are represented efficiently and
1425 // can't overlap by 1 sequence number. This allows a missing_delta of 0
1426 // to represent an adjacent nack range.
1427 last_sequence_number
-= (range_length
+ 1);
1430 if (quic_version_
!= QUIC_VERSION_13
) {
1431 // Parse the revived packets list.
1432 uint8 num_revived_packets
;
1433 if (!reader_
->ReadBytes(&num_revived_packets
, 1)) {
1434 set_detailed_error("Unable to read num revived packets.");
1438 for (size_t i
= 0; i
< num_revived_packets
; ++i
) {
1439 QuicPacketSequenceNumber revived_packet
= 0;
1440 if (!reader_
->ReadBytes(&revived_packet
,
1441 largest_observed_sequence_number_length
)) {
1442 set_detailed_error("Unable to read revived packet.");
1446 received_info
->revived_packets
.insert(revived_packet
);
1453 bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader
& header
,
1454 QuicStopWaitingFrame
* stop_waiting
) {
1455 if (!reader_
->ReadBytes(&stop_waiting
->entropy_hash
, 1)) {
1456 set_detailed_error("Unable to read entropy hash for sent packets.");
1460 QuicPacketSequenceNumber least_unacked_delta
= 0;
1461 if (!reader_
->ReadBytes(&least_unacked_delta
,
1462 header
.public_header
.sequence_number_length
)) {
1463 set_detailed_error("Unable to read least unacked delta.");
1466 DCHECK_GE(header
.packet_sequence_number
, least_unacked_delta
);
1467 stop_waiting
->least_unacked
=
1468 header
.packet_sequence_number
- least_unacked_delta
;
1473 bool QuicFramer::ProcessQuicCongestionFeedbackFrame(
1474 QuicCongestionFeedbackFrame
* frame
) {
1475 uint8 feedback_type
;
1476 if (!reader_
->ReadBytes(&feedback_type
, 1)) {
1477 set_detailed_error("Unable to read congestion feedback type.");
1481 static_cast<CongestionFeedbackType
>(feedback_type
);
1483 switch (frame
->type
) {
1484 case kInterArrival
: {
1485 CongestionFeedbackMessageInterArrival
* inter_arrival
=
1486 &frame
->inter_arrival
;
1487 if (quic_version_
== QUIC_VERSION_13
) {
1488 uint16 unused_accumulated_number_of_lost_packets
;
1489 if (!reader_
->ReadUInt16(
1490 &unused_accumulated_number_of_lost_packets
)) {
1492 "Unable to read accumulated number of lost packets.");
1496 uint8 num_received_packets
;
1497 if (!reader_
->ReadBytes(&num_received_packets
, 1)) {
1498 set_detailed_error("Unable to read num received packets.");
1502 if (num_received_packets
> 0u) {
1503 uint64 smallest_received
;
1504 if (!ProcessPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER
,
1505 &smallest_received
)) {
1506 set_detailed_error("Unable to read smallest received.");
1510 uint64 time_received_us
;
1511 if (!reader_
->ReadUInt64(&time_received_us
)) {
1512 set_detailed_error("Unable to read time received.");
1515 QuicTime time_received
= creation_time_
.Add(
1516 QuicTime::Delta::FromMicroseconds(time_received_us
));
1518 inter_arrival
->received_packet_times
.insert(
1519 make_pair(smallest_received
, time_received
));
1521 for (uint8 i
= 0; i
< num_received_packets
- 1; ++i
) {
1522 uint16 sequence_delta
;
1523 if (!reader_
->ReadUInt16(&sequence_delta
)) {
1525 "Unable to read sequence delta in received packets.");
1529 int32 time_delta_us
;
1530 if (!reader_
->ReadBytes(&time_delta_us
, sizeof(time_delta_us
))) {
1532 "Unable to read time delta in received packets.");
1535 QuicPacketSequenceNumber packet
= smallest_received
+ sequence_delta
;
1536 inter_arrival
->received_packet_times
.insert(
1537 make_pair(packet
, time_received
.Add(
1538 QuicTime::Delta::FromMicroseconds(time_delta_us
))));
1545 if (!reader_
->ReadUInt32(&bitrate
)) {
1546 set_detailed_error("Unable to read bitrate.");
1549 frame
->fix_rate
.bitrate
= QuicBandwidth::FromBytesPerSecond(bitrate
);
1553 CongestionFeedbackMessageTCP
* tcp
= &frame
->tcp
;
1554 if (quic_version_
== QUIC_VERSION_13
) {
1555 uint16 unused_accumulated_number_of_lost_packets
;
1556 if (!reader_
->ReadUInt16(&unused_accumulated_number_of_lost_packets
)) {
1558 "Unable to read accumulated number of lost packets.");
1562 // TODO(ianswett): Remove receive window, since it's constant.
1563 uint16 receive_window
= 0;
1564 if (!reader_
->ReadUInt16(&receive_window
)) {
1565 set_detailed_error("Unable to read receive window.");
1568 // Simple bit packing, don't send the 4 least significant bits.
1569 tcp
->receive_window
= static_cast<QuicByteCount
>(receive_window
) << 4;
1573 set_detailed_error("Illegal congestion feedback type.");
1574 DLOG(WARNING
) << "Illegal congestion feedback type: "
1576 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1582 bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame
* frame
) {
1583 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1584 set_detailed_error("Unable to read stream_id.");
1588 if (quic_version_
> QUIC_VERSION_13
) {
1589 if (!reader_
->ReadUInt64(&frame
->byte_offset
)) {
1590 set_detailed_error("Unable to read rst stream sent byte offset.");
1596 if (!reader_
->ReadUInt32(&error_code
)) {
1597 set_detailed_error("Unable to read rst stream error code.");
1601 if (error_code
>= QUIC_STREAM_LAST_ERROR
||
1602 error_code
< QUIC_STREAM_NO_ERROR
) {
1603 set_detailed_error("Invalid rst stream error code.");
1607 frame
->error_code
= static_cast<QuicRstStreamErrorCode
>(error_code
);
1609 StringPiece error_details
;
1610 if (!reader_
->ReadStringPiece16(&error_details
)) {
1611 set_detailed_error("Unable to read rst stream error details.");
1614 frame
->error_details
= error_details
.as_string();
1619 bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame
* frame
) {
1621 if (!reader_
->ReadUInt32(&error_code
)) {
1622 set_detailed_error("Unable to read connection close error code.");
1626 if (error_code
>= QUIC_LAST_ERROR
||
1627 error_code
< QUIC_NO_ERROR
) {
1628 set_detailed_error("Invalid error code.");
1632 frame
->error_code
= static_cast<QuicErrorCode
>(error_code
);
1634 StringPiece error_details
;
1635 if (!reader_
->ReadStringPiece16(&error_details
)) {
1636 set_detailed_error("Unable to read connection close error details.");
1639 frame
->error_details
= error_details
.as_string();
1644 bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame
* frame
) {
1646 if (!reader_
->ReadUInt32(&error_code
)) {
1647 set_detailed_error("Unable to read go away error code.");
1650 frame
->error_code
= static_cast<QuicErrorCode
>(error_code
);
1652 if (error_code
>= QUIC_LAST_ERROR
||
1653 error_code
< QUIC_NO_ERROR
) {
1654 set_detailed_error("Invalid error code.");
1659 if (!reader_
->ReadUInt32(&stream_id
)) {
1660 set_detailed_error("Unable to read last good stream id.");
1663 frame
->last_good_stream_id
= static_cast<QuicStreamId
>(stream_id
);
1665 StringPiece reason_phrase
;
1666 if (!reader_
->ReadStringPiece16(&reason_phrase
)) {
1667 set_detailed_error("Unable to read goaway reason.");
1670 frame
->reason_phrase
= reason_phrase
.as_string();
1675 bool QuicFramer::ProcessWindowUpdateFrame(QuicWindowUpdateFrame
* frame
) {
1676 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1677 set_detailed_error("Unable to read stream_id.");
1681 if (!reader_
->ReadUInt64(&frame
->byte_offset
)) {
1682 set_detailed_error("Unable to read window byte_offset.");
1689 bool QuicFramer::ProcessBlockedFrame(QuicBlockedFrame
* frame
) {
1690 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1691 set_detailed_error("Unable to read stream_id.");
1699 StringPiece
QuicFramer::GetAssociatedDataFromEncryptedPacket(
1700 const QuicEncryptedPacket
& encrypted
,
1701 QuicConnectionIdLength connection_id_length
,
1702 bool includes_version
,
1703 QuicSequenceNumberLength sequence_number_length
) {
1705 encrypted
.data() + kStartOfHashData
, GetStartOfEncryptedData(
1706 connection_id_length
, includes_version
, sequence_number_length
)
1707 - kStartOfHashData
);
1710 void QuicFramer::SetDecrypter(QuicDecrypter
* decrypter
) {
1711 DCHECK(alternative_decrypter_
.get() == NULL
);
1712 decrypter_
.reset(decrypter
);
1715 void QuicFramer::SetAlternativeDecrypter(QuicDecrypter
* decrypter
,
1716 bool latch_once_used
) {
1717 alternative_decrypter_
.reset(decrypter
);
1718 alternative_decrypter_latch_
= latch_once_used
;
1721 const QuicDecrypter
* QuicFramer::decrypter() const {
1722 return decrypter_
.get();
1725 const QuicDecrypter
* QuicFramer::alternative_decrypter() const {
1726 return alternative_decrypter_
.get();
1729 void QuicFramer::SetEncrypter(EncryptionLevel level
,
1730 QuicEncrypter
* encrypter
) {
1731 DCHECK_GE(level
, 0);
1732 DCHECK_LT(level
, NUM_ENCRYPTION_LEVELS
);
1733 encrypter_
[level
].reset(encrypter
);
1736 const QuicEncrypter
* QuicFramer::encrypter(EncryptionLevel level
) const {
1737 DCHECK_GE(level
, 0);
1738 DCHECK_LT(level
, NUM_ENCRYPTION_LEVELS
);
1739 DCHECK(encrypter_
[level
].get() != NULL
);
1740 return encrypter_
[level
].get();
1743 void QuicFramer::SwapCryptersForTest(QuicFramer
* other
) {
1744 for (int i
= ENCRYPTION_NONE
; i
< NUM_ENCRYPTION_LEVELS
; i
++) {
1745 encrypter_
[i
].swap(other
->encrypter_
[i
]);
1747 decrypter_
.swap(other
->decrypter_
);
1748 alternative_decrypter_
.swap(other
->alternative_decrypter_
);
1750 const bool other_latch
= other
->alternative_decrypter_latch_
;
1751 other
->alternative_decrypter_latch_
= alternative_decrypter_latch_
;
1752 alternative_decrypter_latch_
= other_latch
;
1755 QuicEncryptedPacket
* QuicFramer::EncryptPacket(
1756 EncryptionLevel level
,
1757 QuicPacketSequenceNumber packet_sequence_number
,
1758 const QuicPacket
& packet
) {
1759 DCHECK(encrypter_
[level
].get() != NULL
);
1761 scoped_ptr
<QuicData
> out(encrypter_
[level
]->EncryptPacket(
1762 packet_sequence_number
, packet
.AssociatedData(), packet
.Plaintext()));
1763 if (out
.get() == NULL
) {
1764 RaiseError(QUIC_ENCRYPTION_FAILURE
);
1767 StringPiece header_data
= packet
.BeforePlaintext();
1768 size_t len
= header_data
.length() + out
->length();
1769 char* buffer
= new char[len
];
1770 // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
1771 memcpy(buffer
, header_data
.data(), header_data
.length());
1772 memcpy(buffer
+ header_data
.length(), out
->data(), out
->length());
1773 return new QuicEncryptedPacket(buffer
, len
, true);
1776 size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size
) {
1777 // In order to keep the code simple, we don't have the current encryption
1778 // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12.
1779 size_t min_plaintext_size
= ciphertext_size
;
1781 for (int i
= ENCRYPTION_NONE
; i
< NUM_ENCRYPTION_LEVELS
; i
++) {
1782 if (encrypter_
[i
].get() != NULL
) {
1783 size_t size
= encrypter_
[i
]->GetMaxPlaintextSize(ciphertext_size
);
1784 if (size
< min_plaintext_size
) {
1785 min_plaintext_size
= size
;
1790 return min_plaintext_size
;
1793 bool QuicFramer::DecryptPayload(const QuicPacketHeader
& header
,
1794 const QuicEncryptedPacket
& packet
) {
1795 StringPiece encrypted
;
1796 if (!reader_
->ReadStringPiece(&encrypted
, reader_
->BytesRemaining())) {
1799 DCHECK(decrypter_
.get() != NULL
);
1800 decrypted_
.reset(decrypter_
->DecryptPacket(
1801 header
.packet_sequence_number
,
1802 GetAssociatedDataFromEncryptedPacket(
1804 header
.public_header
.connection_id_length
,
1805 header
.public_header
.version_flag
,
1806 header
.public_header
.sequence_number_length
),
1808 if (decrypted_
.get() == NULL
&& alternative_decrypter_
.get() != NULL
) {
1809 decrypted_
.reset(alternative_decrypter_
->DecryptPacket(
1810 header
.packet_sequence_number
,
1811 GetAssociatedDataFromEncryptedPacket(
1813 header
.public_header
.connection_id_length
,
1814 header
.public_header
.version_flag
,
1815 header
.public_header
.sequence_number_length
),
1817 if (decrypted_
.get() != NULL
) {
1818 if (alternative_decrypter_latch_
) {
1819 // Switch to the alternative decrypter and latch so that we cannot
1821 decrypter_
.reset(alternative_decrypter_
.release());
1823 // Switch the alternative decrypter so that we use it first next time.
1824 decrypter_
.swap(alternative_decrypter_
);
1829 if (decrypted_
.get() == NULL
) {
1833 reader_
.reset(new QuicDataReader(decrypted_
->data(), decrypted_
->length()));
1837 size_t QuicFramer::GetAckFrameSize(
1838 const QuicAckFrame
& ack
,
1839 QuicSequenceNumberLength sequence_number_length
) {
1840 AckFrameInfo ack_info
= GetAckFrameInfo(ack
);
1841 QuicSequenceNumberLength largest_observed_length
=
1842 GetMinSequenceNumberLength(ack
.received_info
.largest_observed
);
1843 QuicSequenceNumberLength missing_sequence_number_length
=
1844 GetMinSequenceNumberLength(ack_info
.max_delta
);
1846 size_t ack_size
= GetMinAckFrameSize(quic_version_
,
1847 sequence_number_length
,
1848 largest_observed_length
);
1849 if (!ack_info
.nack_ranges
.empty()) {
1850 ack_size
+= kNumberOfMissingPacketsSize
+
1851 (quic_version_
== QUIC_VERSION_13
? 0 : kNumberOfRevivedPacketsSize
);
1852 ack_size
+= ack_info
.nack_ranges
.size() *
1853 (missing_sequence_number_length
+ PACKET_1BYTE_SEQUENCE_NUMBER
);
1855 ack
.received_info
.revived_packets
.size() * largest_observed_length
;
1860 size_t QuicFramer::ComputeFrameLength(
1861 const QuicFrame
& frame
,
1862 bool last_frame_in_packet
,
1863 QuicSequenceNumberLength sequence_number_length
) {
1864 switch (frame
.type
) {
1866 return GetMinStreamFrameSize(quic_version_
,
1867 frame
.stream_frame
->stream_id
,
1868 frame
.stream_frame
->offset
,
1869 last_frame_in_packet
) +
1870 frame
.stream_frame
->data
.TotalBufferSize();
1872 return GetAckFrameSize(*frame
.ack_frame
, sequence_number_length
);
1874 case CONGESTION_FEEDBACK_FRAME
: {
1875 size_t len
= kQuicFrameTypeSize
;
1876 const QuicCongestionFeedbackFrame
& congestion_feedback
=
1877 *frame
.congestion_feedback_frame
;
1878 len
+= 1; // Congestion feedback type.
1880 switch (congestion_feedback
.type
) {
1881 case kInterArrival
: {
1882 const CongestionFeedbackMessageInterArrival
& inter_arrival
=
1883 congestion_feedback
.inter_arrival
;
1884 if (quic_version_
== QUIC_VERSION_13
) {
1885 len
+= 2; // Accumulated number of lost packets.
1887 len
+= 1; // Number received packets.
1888 if (inter_arrival
.received_packet_times
.size() > 0) {
1889 len
+= PACKET_6BYTE_SEQUENCE_NUMBER
; // Smallest received.
1891 // 2 bytes per sequence number delta plus 4 bytes per delta time.
1892 len
+= PACKET_6BYTE_SEQUENCE_NUMBER
*
1893 (inter_arrival
.received_packet_times
.size() - 1);
1898 len
+= 4; // Bitrate.
1901 if (quic_version_
== QUIC_VERSION_13
) {
1902 len
+= 2; // Accumulated number of lost packets.
1904 len
+= 2; // Receive window.
1907 set_detailed_error("Illegal feedback type.");
1908 DVLOG(1) << "Illegal feedback type: " << congestion_feedback
.type
;
1913 case STOP_WAITING_FRAME
:
1914 return GetStopWaitingFrameSize(sequence_number_length
);
1915 case RST_STREAM_FRAME
:
1916 return GetMinRstStreamFrameSize(quic_version_
) +
1917 frame
.rst_stream_frame
->error_details
.size();
1918 case CONNECTION_CLOSE_FRAME
:
1919 return GetMinConnectionCloseFrameSize() +
1920 frame
.connection_close_frame
->error_details
.size();
1922 return GetMinGoAwayFrameSize() + frame
.goaway_frame
->reason_phrase
.size();
1923 case WINDOW_UPDATE_FRAME
:
1924 return GetWindowUpdateFrameSize();
1926 return GetBlockedFrameSize();
1930 case NUM_FRAME_TYPES
:
1935 // Not reachable, but some Chrome compilers can't figure that out. *sigh*
1940 bool QuicFramer::AppendTypeByte(const QuicFrame
& frame
,
1941 bool last_frame_in_packet
,
1942 QuicDataWriter
* writer
) {
1943 uint8 type_byte
= 0;
1944 switch (frame
.type
) {
1945 case STREAM_FRAME
: {
1946 if (frame
.stream_frame
== NULL
) {
1947 LOG(DFATAL
) << "Failed to append STREAM frame with no stream_frame.";
1950 type_byte
|= frame
.stream_frame
->fin
? kQuicStreamFinMask
: 0;
1953 type_byte
<<= kQuicStreamDataLengthShift
;
1954 type_byte
|= last_frame_in_packet
? 0 : kQuicStreamDataLengthMask
;
1957 type_byte
<<= kQuicStreamOffsetShift
;
1958 const size_t offset_len
= GetStreamOffsetSize(frame
.stream_frame
->offset
);
1959 if (offset_len
> 0) {
1960 type_byte
|= offset_len
- 1;
1963 // stream id 2 bits.
1964 type_byte
<<= kQuicStreamIdShift
;
1965 type_byte
|= GetStreamIdSize(frame
.stream_frame
->stream_id
) - 1;
1966 type_byte
|= kQuicFrameTypeStreamMask
; // Set Stream Frame Type to 1.
1971 case CONGESTION_FEEDBACK_FRAME
: {
1972 // TODO(ianswett): Use extra 5 bits in the congestion feedback framing.
1973 type_byte
= kQuicFrameTypeCongestionFeedbackMask
;
1977 type_byte
= frame
.type
;
1981 return writer
->WriteUInt8(type_byte
);
1985 bool QuicFramer::AppendPacketSequenceNumber(
1986 QuicSequenceNumberLength sequence_number_length
,
1987 QuicPacketSequenceNumber packet_sequence_number
,
1988 QuicDataWriter
* writer
) {
1989 // Ensure the entire sequence number can be written.
1990 if (writer
->capacity() - writer
->length() <
1991 static_cast<size_t>(sequence_number_length
)) {
1994 switch (sequence_number_length
) {
1995 case PACKET_1BYTE_SEQUENCE_NUMBER
:
1996 return writer
->WriteUInt8(
1997 packet_sequence_number
& k1ByteSequenceNumberMask
);
1999 case PACKET_2BYTE_SEQUENCE_NUMBER
:
2000 return writer
->WriteUInt16(
2001 packet_sequence_number
& k2ByteSequenceNumberMask
);
2003 case PACKET_4BYTE_SEQUENCE_NUMBER
:
2004 return writer
->WriteUInt32(
2005 packet_sequence_number
& k4ByteSequenceNumberMask
);
2007 case PACKET_6BYTE_SEQUENCE_NUMBER
:
2008 return writer
->WriteUInt48(
2009 packet_sequence_number
& k6ByteSequenceNumberMask
);
2012 DCHECK(false) << "sequence_number_length: " << sequence_number_length
;
2017 bool QuicFramer::AppendStreamFrame(
2018 const QuicStreamFrame
& frame
,
2019 bool last_frame_in_packet
,
2020 QuicDataWriter
* writer
) {
2021 if (!writer
->WriteBytes(&frame
.stream_id
, GetStreamIdSize(frame
.stream_id
))) {
2024 if (!writer
->WriteBytes(&frame
.offset
, GetStreamOffsetSize(frame
.offset
))) {
2027 if (!last_frame_in_packet
) {
2028 if (!writer
->WriteUInt16(frame
.data
.TotalBufferSize())) {
2033 if (!writer
->WriteIOVector(frame
.data
)) {
2040 void QuicFramer::set_version(const QuicVersion version
) {
2041 DCHECK(IsSupportedVersion(version
)) << QuicVersionToString(version
);
2042 quic_version_
= version
;
2045 bool QuicFramer::AppendAckFrameAndTypeByte(
2046 const QuicPacketHeader
& header
,
2047 const QuicAckFrame
& frame
,
2048 QuicDataWriter
* writer
) {
2049 AckFrameInfo ack_info
= GetAckFrameInfo(frame
);
2050 QuicPacketSequenceNumber ack_largest_observed
=
2051 frame
.received_info
.largest_observed
;
2052 QuicSequenceNumberLength largest_observed_length
=
2053 GetMinSequenceNumberLength(ack_largest_observed
);
2054 QuicSequenceNumberLength missing_sequence_number_length
=
2055 GetMinSequenceNumberLength(ack_info
.max_delta
);
2056 // Determine whether we need to truncate ranges.
2057 size_t available_range_bytes
= writer
->capacity() - writer
->length() -
2058 GetMinAckFrameSize(quic_version_
,
2059 header
.public_header
.sequence_number_length
,
2060 largest_observed_length
) -
2061 (quic_version_
== QUIC_VERSION_13
? 0 : kNumberOfRevivedPacketsSize
);
2062 size_t max_num_ranges
= available_range_bytes
/
2063 (missing_sequence_number_length
+ PACKET_1BYTE_SEQUENCE_NUMBER
);
2065 min(static_cast<size_t>(numeric_limits
<uint8
>::max()), max_num_ranges
);
2066 bool truncated
= ack_info
.nack_ranges
.size() > max_num_ranges
;
2067 DVLOG_IF(1, truncated
) << "Truncating ack from "
2068 << ack_info
.nack_ranges
.size() << " ranges to "
2071 // Write out the type byte by setting the low order bits and doing shifts
2072 // to make room for the next bit flags to be set.
2073 // Whether there are any nacks.
2074 uint8 type_byte
= ack_info
.nack_ranges
.empty() ? 0 : kQuicHasNacksMask
;
2077 type_byte
<<= kQuicAckTruncatedShift
;
2078 type_byte
|= truncated
? kQuicAckTruncatedMask
: 0;
2080 // Largest observed sequence number length.
2081 type_byte
<<= kQuicSequenceNumberLengthShift
;
2082 type_byte
|= GetSequenceNumberFlags(largest_observed_length
);
2084 // Missing sequence number length.
2085 type_byte
<<= kQuicSequenceNumberLengthShift
;
2086 type_byte
|= GetSequenceNumberFlags(missing_sequence_number_length
);
2088 type_byte
|= kQuicFrameTypeAckMask
;
2090 if (!writer
->WriteUInt8(type_byte
)) {
2094 if (quic_version_
<= QUIC_VERSION_15
) {
2095 if (!AppendStopWaitingFrame(header
, frame
.sent_info
, writer
)) {
2100 const ReceivedPacketInfo
& received_info
= frame
.received_info
;
2101 QuicPacketEntropyHash ack_entropy_hash
= received_info
.entropy_hash
;
2102 NackRangeMap::reverse_iterator ack_iter
= ack_info
.nack_ranges
.rbegin();
2104 // Skip the nack ranges which the truncated ack won't include and set
2105 // a correct largest observed for the truncated ack.
2106 for (size_t i
= 1; i
< (ack_info
.nack_ranges
.size() - max_num_ranges
);
2110 // If the last range is followed by acks, include them.
2111 // If the last range is followed by another range, specify the end of the
2112 // range as the largest_observed.
2113 ack_largest_observed
= ack_iter
->first
- 1;
2114 // Also update the entropy so it matches the largest observed.
2115 ack_entropy_hash
= entropy_calculator_
->EntropyHash(ack_largest_observed
);
2119 if (!writer
->WriteUInt8(ack_entropy_hash
)) {
2123 if (!AppendPacketSequenceNumber(largest_observed_length
,
2124 ack_largest_observed
, writer
)) {
2128 uint64 delta_time_largest_observed_us
= kUFloat16MaxValue
;
2129 if (!received_info
.delta_time_largest_observed
.IsInfinite()) {
2131 frame
.received_info
.delta_time_largest_observed
.ToMicroseconds());
2132 delta_time_largest_observed_us
=
2133 received_info
.delta_time_largest_observed
.ToMicroseconds();
2136 if (!writer
->WriteUFloat16(delta_time_largest_observed_us
)) {
2140 if (ack_info
.nack_ranges
.empty()) {
2144 const uint8 num_missing_ranges
=
2145 min(ack_info
.nack_ranges
.size(), max_num_ranges
);
2146 if (!writer
->WriteBytes(&num_missing_ranges
, 1)) {
2150 int num_ranges_written
= 0;
2151 QuicPacketSequenceNumber last_sequence_written
= ack_largest_observed
;
2152 for (; ack_iter
!= ack_info
.nack_ranges
.rend(); ++ack_iter
) {
2153 // Calculate the delta to the last number in the range.
2154 QuicPacketSequenceNumber missing_delta
=
2155 last_sequence_written
- (ack_iter
->first
+ ack_iter
->second
);
2156 if (!AppendPacketSequenceNumber(missing_sequence_number_length
,
2157 missing_delta
, writer
)) {
2160 if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER
,
2161 ack_iter
->second
, writer
)) {
2164 // Subtract 1 so a missing_delta of 0 means an adjacent range.
2165 last_sequence_written
= ack_iter
->first
- 1;
2166 ++num_ranges_written
;
2168 DCHECK_EQ(num_missing_ranges
, num_ranges_written
);
2170 if (quic_version_
!= QUIC_VERSION_13
) {
2171 // Append revived packets.
2172 // If not all the revived packets fit, only mention the ones that do.
2173 uint8 num_revived_packets
=
2174 min(received_info
.revived_packets
.size(),
2175 static_cast<size_t>(numeric_limits
<uint8
>::max()));
2176 num_revived_packets
= min(
2177 static_cast<size_t>(num_revived_packets
),
2178 (writer
->capacity() - writer
->length()) / largest_observed_length
);
2179 if (!writer
->WriteBytes(&num_revived_packets
, 1)) {
2183 SequenceNumberSet::const_iterator iter
=
2184 received_info
.revived_packets
.begin();
2185 for (int i
= 0; i
< num_revived_packets
; ++i
, ++iter
) {
2186 LOG_IF(DFATAL
, !ContainsKey(received_info
.missing_packets
, *iter
));
2187 if (!AppendPacketSequenceNumber(largest_observed_length
,
2197 bool QuicFramer::AppendCongestionFeedbackFrame(
2198 const QuicCongestionFeedbackFrame
& frame
,
2199 QuicDataWriter
* writer
) {
2200 if (!writer
->WriteBytes(&frame
.type
, 1)) {
2204 switch (frame
.type
) {
2205 case kInterArrival
: {
2206 const CongestionFeedbackMessageInterArrival
& inter_arrival
=
2207 frame
.inter_arrival
;
2208 if (quic_version_
== QUIC_VERSION_13
) {
2209 // accumulated_number_of_lost_packets is removed. Always write 0.
2210 if (!writer
->WriteUInt16(0)) {
2214 DCHECK_GE(numeric_limits
<uint8
>::max(),
2215 inter_arrival
.received_packet_times
.size());
2216 if (inter_arrival
.received_packet_times
.size() >
2217 numeric_limits
<uint8
>::max()) {
2220 // TODO(ianswett): Make num_received_packets a varint.
2221 uint8 num_received_packets
=
2222 inter_arrival
.received_packet_times
.size();
2223 if (!writer
->WriteBytes(&num_received_packets
, 1)) {
2226 if (num_received_packets
> 0) {
2227 TimeMap::const_iterator it
=
2228 inter_arrival
.received_packet_times
.begin();
2230 QuicPacketSequenceNumber lowest_sequence
= it
->first
;
2231 if (!AppendPacketSequenceNumber(PACKET_6BYTE_SEQUENCE_NUMBER
,
2232 lowest_sequence
, writer
)) {
2236 QuicTime lowest_time
= it
->second
;
2237 if (!writer
->WriteUInt64(
2238 lowest_time
.Subtract(creation_time_
).ToMicroseconds())) {
2242 for (++it
; it
!= inter_arrival
.received_packet_times
.end(); ++it
) {
2243 QuicPacketSequenceNumber sequence_delta
= it
->first
- lowest_sequence
;
2244 DCHECK_GE(numeric_limits
<uint16
>::max(), sequence_delta
);
2245 if (sequence_delta
> numeric_limits
<uint16
>::max()) {
2248 if (!writer
->WriteUInt16(static_cast<uint16
>(sequence_delta
))) {
2252 int32 time_delta_us
=
2253 it
->second
.Subtract(lowest_time
).ToMicroseconds();
2254 if (!writer
->WriteBytes(&time_delta_us
, sizeof(time_delta_us
))) {
2262 const CongestionFeedbackMessageFixRate
& fix_rate
=
2264 if (!writer
->WriteUInt32(fix_rate
.bitrate
.ToBytesPerSecond())) {
2270 const CongestionFeedbackMessageTCP
& tcp
= frame
.tcp
;
2271 DCHECK_LE(tcp
.receive_window
, 1u << 20);
2272 // Simple bit packing, don't send the 4 least significant bits.
2273 uint16 receive_window
= static_cast<uint16
>(tcp
.receive_window
>> 4);
2274 if (quic_version_
== QUIC_VERSION_13
) {
2275 // accumulated_number_of_lost_packets is removed. Always write 0.
2276 if (!writer
->WriteUInt16(0)) {
2280 if (!writer
->WriteUInt16(receive_window
)) {
2292 bool QuicFramer::AppendStopWaitingFrame(
2293 const QuicPacketHeader
& header
,
2294 const QuicStopWaitingFrame
& frame
,
2295 QuicDataWriter
* writer
) {
2296 DCHECK_GE(header
.packet_sequence_number
, frame
.least_unacked
);
2297 const QuicPacketSequenceNumber least_unacked_delta
=
2298 header
.packet_sequence_number
- frame
.least_unacked
;
2299 const QuicPacketSequenceNumber length_shift
=
2300 header
.public_header
.sequence_number_length
* 8;
2301 if (!writer
->WriteUInt8(frame
.entropy_hash
)) {
2302 LOG(DFATAL
) << " hash failed";
2306 if (least_unacked_delta
>> length_shift
> 0) {
2307 LOG(DFATAL
) << "sequence_number_length "
2308 << header
.public_header
.sequence_number_length
2309 << " is too small for least_unacked_delta: "
2310 << least_unacked_delta
;
2313 if (!AppendPacketSequenceNumber(header
.public_header
.sequence_number_length
,
2314 least_unacked_delta
, writer
)) {
2315 LOG(DFATAL
) << " seq failed: "
2316 << header
.public_header
.sequence_number_length
;
2323 bool QuicFramer::AppendRstStreamFrame(
2324 const QuicRstStreamFrame
& frame
,
2325 QuicDataWriter
* writer
) {
2326 if (!writer
->WriteUInt32(frame
.stream_id
)) {
2330 if (quic_version_
> QUIC_VERSION_13
) {
2331 if (!writer
->WriteUInt64(frame
.byte_offset
)) {
2336 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2337 if (!writer
->WriteUInt32(error_code
)) {
2341 if (!writer
->WriteStringPiece16(frame
.error_details
)) {
2347 bool QuicFramer::AppendConnectionCloseFrame(
2348 const QuicConnectionCloseFrame
& frame
,
2349 QuicDataWriter
* writer
) {
2350 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2351 if (!writer
->WriteUInt32(error_code
)) {
2354 if (!writer
->WriteStringPiece16(frame
.error_details
)) {
2360 bool QuicFramer::AppendGoAwayFrame(const QuicGoAwayFrame
& frame
,
2361 QuicDataWriter
* writer
) {
2362 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2363 if (!writer
->WriteUInt32(error_code
)) {
2366 uint32 stream_id
= static_cast<uint32
>(frame
.last_good_stream_id
);
2367 if (!writer
->WriteUInt32(stream_id
)) {
2370 if (!writer
->WriteStringPiece16(frame
.reason_phrase
)) {
2376 bool QuicFramer::AppendWindowUpdateFrame(const QuicWindowUpdateFrame
& frame
,
2377 QuicDataWriter
* writer
) {
2378 uint32 stream_id
= static_cast<uint32
>(frame
.stream_id
);
2379 if (!writer
->WriteUInt32(stream_id
)) {
2382 if (!writer
->WriteUInt64(frame
.byte_offset
)) {
2388 bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame
& frame
,
2389 QuicDataWriter
* writer
) {
2390 uint32 stream_id
= static_cast<uint32
>(frame
.stream_id
);
2391 if (!writer
->WriteUInt32(stream_id
)) {
2397 bool QuicFramer::RaiseError(QuicErrorCode error
) {
2398 DVLOG(1) << "Error detail: " << detailed_error_
;
2400 visitor_
->OnError(this);
2401 reader_
.reset(NULL
);