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"
9 #include "base/basictypes.h"
10 #include "base/logging.h"
11 #include "base/stl_util.h"
12 #include "net/quic/crypto/crypto_framer.h"
13 #include "net/quic/crypto/crypto_handshake_message.h"
14 #include "net/quic/crypto/crypto_protocol.h"
15 #include "net/quic/crypto/quic_decrypter.h"
16 #include "net/quic/crypto/quic_encrypter.h"
17 #include "net/quic/quic_data_reader.h"
18 #include "net/quic/quic_data_writer.h"
19 #include "net/quic/quic_flags.h"
20 #include "net/quic/quic_socket_address_coder.h"
21 #include "net/quic/quic_utils.h"
23 using base::StringPiece
;
27 using std::numeric_limits
;
34 // Mask to select the lowest 48 bits of a sequence number.
35 const QuicPacketSequenceNumber k6ByteSequenceNumberMask
=
36 UINT64_C(0x0000FFFFFFFFFFFF);
37 const QuicPacketSequenceNumber k4ByteSequenceNumberMask
=
38 UINT64_C(0x00000000FFFFFFFF);
39 const QuicPacketSequenceNumber k2ByteSequenceNumberMask
=
40 UINT64_C(0x000000000000FFFF);
41 const QuicPacketSequenceNumber k1ByteSequenceNumberMask
=
42 UINT64_C(0x00000000000000FF);
44 const QuicConnectionId k1ByteConnectionIdMask
= UINT64_C(0x00000000000000FF);
45 const QuicConnectionId k4ByteConnectionIdMask
= UINT64_C(0x00000000FFFFFFFF);
47 // Number of bits the sequence number length bits are shifted from the right
48 // edge of the public header.
49 const uint8 kPublicHeaderSequenceNumberShift
= 4;
51 // New Frame Types, QUIC v. >= 10:
52 // There are two interpretations for the Frame Type byte in the QUIC protocol,
53 // resulting in two Frame Types: Special Frame Types and Regular Frame Types.
55 // Regular Frame Types use the Frame Type byte simply. Currently defined
56 // Regular Frame Types are:
57 // Padding : 0b 00000000 (0x00)
58 // ResetStream : 0b 00000001 (0x01)
59 // ConnectionClose : 0b 00000010 (0x02)
60 // GoAway : 0b 00000011 (0x03)
61 // WindowUpdate : 0b 00000100 (0x04)
62 // Blocked : 0b 00000101 (0x05)
64 // Special Frame Types encode both a Frame Type and corresponding flags
65 // all in the Frame Type byte. Currently defined Special Frame Types are:
66 // Stream : 0b 1xxxxxxx
69 // Semantics of the flag bits above (the x bits) depends on the frame type.
71 // Masks to determine if the frame type is a special use
72 // and for specific special frame types.
73 const uint8 kQuicFrameTypeSpecialMask
= 0xE0; // 0b 11100000
74 const uint8 kQuicFrameTypeStreamMask
= 0x80;
75 const uint8 kQuicFrameTypeAckMask
= 0x40;
77 // Stream frame relative shifts and masks for interpreting the stream flags.
78 // StreamID may be 1, 2, 3, or 4 bytes.
79 const uint8 kQuicStreamIdShift
= 2;
80 const uint8 kQuicStreamIDLengthMask
= 0x03;
82 // Offset may be 0, 2, 3, 4, 5, 6, 7, 8 bytes.
83 const uint8 kQuicStreamOffsetShift
= 3;
84 const uint8 kQuicStreamOffsetMask
= 0x07;
86 // Data length may be 0 or 2 bytes.
87 const uint8 kQuicStreamDataLengthShift
= 1;
88 const uint8 kQuicStreamDataLengthMask
= 0x01;
90 // Fin bit may be set or not.
91 const uint8 kQuicStreamFinShift
= 1;
92 const uint8 kQuicStreamFinMask
= 0x01;
94 // Sequence number size shift used in AckFrames.
95 const uint8 kQuicSequenceNumberLengthShift
= 2;
97 // Acks may be truncated.
98 const uint8 kQuicAckTruncatedShift
= 1;
99 const uint8 kQuicAckTruncatedMask
= 0x01;
101 // Acks may not have any nacks.
102 const uint8 kQuicHasNacksMask
= 0x01;
104 // Returns the absolute value of the difference between |a| and |b|.
105 QuicPacketSequenceNumber
Delta(QuicPacketSequenceNumber a
,
106 QuicPacketSequenceNumber b
) {
107 // Since these are unsigned numbers, we can't just return abs(a - b)
114 QuicPacketSequenceNumber
ClosestTo(QuicPacketSequenceNumber target
,
115 QuicPacketSequenceNumber a
,
116 QuicPacketSequenceNumber b
) {
117 return (Delta(target
, a
) < Delta(target
, b
)) ? a
: b
;
120 QuicSequenceNumberLength
ReadSequenceNumberLength(uint8 flags
) {
121 switch (flags
& PACKET_FLAGS_6BYTE_SEQUENCE
) {
122 case PACKET_FLAGS_6BYTE_SEQUENCE
:
123 return PACKET_6BYTE_SEQUENCE_NUMBER
;
124 case PACKET_FLAGS_4BYTE_SEQUENCE
:
125 return PACKET_4BYTE_SEQUENCE_NUMBER
;
126 case PACKET_FLAGS_2BYTE_SEQUENCE
:
127 return PACKET_2BYTE_SEQUENCE_NUMBER
;
128 case PACKET_FLAGS_1BYTE_SEQUENCE
:
129 return PACKET_1BYTE_SEQUENCE_NUMBER
;
131 LOG(DFATAL
) << "Unreachable case statement.";
132 return PACKET_6BYTE_SEQUENCE_NUMBER
;
138 QuicFramer::QuicFramer(const QuicVersionVector
& supported_versions
,
139 QuicTime creation_time
,
140 Perspective perspective
)
142 entropy_calculator_(nullptr),
143 error_(QUIC_NO_ERROR
),
144 last_sequence_number_(0),
145 last_serialized_connection_id_(0),
146 supported_versions_(supported_versions
),
147 decrypter_level_(ENCRYPTION_NONE
),
148 alternative_decrypter_level_(ENCRYPTION_NONE
),
149 alternative_decrypter_latch_(false),
150 perspective_(perspective
),
151 validate_flags_(true),
152 creation_time_(creation_time
),
153 last_timestamp_(QuicTime::Delta::Zero()) {
154 DCHECK(!supported_versions
.empty());
155 quic_version_
= supported_versions_
[0];
156 decrypter_
.reset(QuicDecrypter::Create(kNULL
));
157 encrypter_
[ENCRYPTION_NONE
].reset(QuicEncrypter::Create(kNULL
));
160 QuicFramer::~QuicFramer() {}
163 size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id
,
164 QuicStreamOffset offset
,
165 bool last_frame_in_packet
,
166 InFecGroup is_in_fec_group
) {
167 bool no_stream_frame_length
= last_frame_in_packet
&&
168 is_in_fec_group
== NOT_IN_FEC_GROUP
;
169 return kQuicFrameTypeSize
+ GetStreamIdSize(stream_id
) +
170 GetStreamOffsetSize(offset
) +
171 (no_stream_frame_length
? 0 : kQuicStreamPayloadLengthSize
);
175 size_t QuicFramer::GetMinAckFrameSize(
176 QuicSequenceNumberLength largest_observed_length
) {
177 return kQuicFrameTypeSize
+ kQuicEntropyHashSize
+
178 largest_observed_length
+ kQuicDeltaTimeLargestObservedSize
;
182 size_t QuicFramer::GetStopWaitingFrameSize(
183 QuicSequenceNumberLength sequence_number_length
) {
184 return kQuicFrameTypeSize
+ kQuicEntropyHashSize
+
185 sequence_number_length
;
189 size_t QuicFramer::GetMinRstStreamFrameSize() {
190 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+
191 kQuicMaxStreamOffsetSize
+ kQuicErrorCodeSize
+
192 kQuicErrorDetailsLengthSize
;
196 size_t QuicFramer::GetRstStreamFrameSize() {
197 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+ kQuicMaxStreamOffsetSize
+
202 size_t QuicFramer::GetMinConnectionCloseFrameSize() {
203 return kQuicFrameTypeSize
+ kQuicErrorCodeSize
+ kQuicErrorDetailsLengthSize
;
207 size_t QuicFramer::GetMinGoAwayFrameSize() {
208 return kQuicFrameTypeSize
+ kQuicErrorCodeSize
+ kQuicErrorDetailsLengthSize
+
209 kQuicMaxStreamIdSize
;
213 size_t QuicFramer::GetWindowUpdateFrameSize() {
214 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
+ kQuicMaxStreamOffsetSize
;
218 size_t QuicFramer::GetBlockedFrameSize() {
219 return kQuicFrameTypeSize
+ kQuicMaxStreamIdSize
;
223 size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id
) {
224 // Sizes are 1 through 4 bytes.
225 for (int i
= 1; i
<= 4; ++i
) {
227 if (stream_id
== 0) {
231 LOG(DFATAL
) << "Failed to determine StreamIDSize.";
236 size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset
) {
237 // 0 is a special case.
241 // 2 through 8 are the remaining sizes.
243 for (int i
= 2; i
<= 8; ++i
) {
249 LOG(DFATAL
) << "Failed to determine StreamOffsetSize.";
254 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions
) {
255 return kPublicFlagsSize
+ PACKET_8BYTE_CONNECTION_ID
+
256 number_versions
* kQuicVersionSize
;
259 bool QuicFramer::IsSupportedVersion(const QuicVersion version
) const {
260 for (size_t i
= 0; i
< supported_versions_
.size(); ++i
) {
261 if (version
== supported_versions_
[i
]) {
268 size_t QuicFramer::GetSerializedFrameLength(
269 const QuicFrame
& frame
,
273 InFecGroup is_in_fec_group
,
274 QuicSequenceNumberLength sequence_number_length
) {
275 // Prevent a rare crash reported in b/19458523.
276 if (frame
.stream_frame
== nullptr) {
277 LOG(DFATAL
) << "Cannot compute the length of a null frame. "
278 << "type:" << frame
.type
<< "free_bytes:" << free_bytes
279 << " first_frame:" << first_frame
280 << " last_frame:" << last_frame
281 << " is_in_fec:" << is_in_fec_group
282 << " seq num length:" << sequence_number_length
;
283 set_error(QUIC_INTERNAL_ERROR
);
284 visitor_
->OnError(this);
287 if (frame
.type
== PADDING_FRAME
) {
288 // PADDING implies end of packet.
292 ComputeFrameLength(frame
, last_frame
, is_in_fec_group
,
293 sequence_number_length
);
294 if (frame_len
<= free_bytes
) {
295 // Frame fits within packet. Note that acks may be truncated.
298 // Only truncate the first frame in a packet, so if subsequent ones go
299 // over, stop including more frames.
304 frame
.type
== ACK_FRAME
&&
305 free_bytes
>= GetMinAckFrameSize(PACKET_6BYTE_SEQUENCE_NUMBER
);
307 // Truncate the frame so the packet will not exceed kMaxPacketSize.
308 // Note that we may not use every byte of the writer in this case.
309 DVLOG(1) << "Truncating large frame, free bytes: " << free_bytes
;
312 if (!FLAGS_quic_allow_oversized_packets_for_test
) {
315 LOG(DFATAL
) << "Packet size too small to fit frame.";
319 QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) {}
321 QuicFramer::AckFrameInfo::~AckFrameInfo() {}
324 QuicPacketEntropyHash
QuicFramer::GetPacketEntropyHash(
325 const QuicPacketHeader
& header
) {
326 return header
.entropy_flag
<< (header
.packet_sequence_number
% 8);
329 QuicPacket
* QuicFramer::BuildDataPacket(const QuicPacketHeader
& header
,
330 const QuicFrames
& frames
,
332 size_t packet_length
) {
333 QuicDataWriter
writer(packet_length
, buffer
);
334 if (!AppendPacketHeader(header
, &writer
)) {
335 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
336 CHECK(false) << "AppendPacketHeader failed";
341 for (const QuicFrame
& frame
: frames
) {
342 // Determine if we should write stream frame length in header.
343 const bool no_stream_frame_length
=
344 (header
.is_in_fec_group
== NOT_IN_FEC_GROUP
) &&
345 (i
== frames
.size() - 1);
346 if (!AppendTypeByte(frame
, no_stream_frame_length
, &writer
)) {
347 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
348 CHECK(false) << "AppendTypeByte failed";
352 switch (frame
.type
) {
354 writer
.WritePadding();
357 if (!AppendStreamFrame(
358 *frame
.stream_frame
, no_stream_frame_length
, &writer
)) {
359 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
360 CHECK(false) << "AppendStreamFrame failed";
365 if (!AppendAckFrameAndTypeByte(
366 header
, *frame
.ack_frame
, &writer
)) {
367 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
368 CHECK(false) << "AppendAckFrameAndTypeByte failed";
372 case STOP_WAITING_FRAME
:
373 if (!AppendStopWaitingFrame(
374 header
, *frame
.stop_waiting_frame
, &writer
)) {
375 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
376 CHECK(false) << "AppendStopWaitingFrame failed";
380 case MTU_DISCOVERY_FRAME
:
381 // MTU discovery frames are serialized as ping frames.
383 // Ping has no payload.
385 case RST_STREAM_FRAME
:
386 if (!AppendRstStreamFrame(*frame
.rst_stream_frame
, &writer
)) {
387 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
388 CHECK(false) << "AppendRstStreamFrame failed";
392 case CONNECTION_CLOSE_FRAME
:
393 if (!AppendConnectionCloseFrame(
394 *frame
.connection_close_frame
, &writer
)) {
395 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
396 CHECK(false) << "AppendConnectionCloseFrame failed";
401 if (!AppendGoAwayFrame(*frame
.goaway_frame
, &writer
)) {
402 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
403 CHECK(false) << "AppendGoAwayFrame failed";
407 case WINDOW_UPDATE_FRAME
:
408 if (!AppendWindowUpdateFrame(*frame
.window_update_frame
, &writer
)) {
409 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
410 CHECK(false) << "AppendWindowUpdateFrame failed";
415 if (!AppendBlockedFrame(*frame
.blocked_frame
, &writer
)) {
416 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
417 CHECK(false) << "AppendBlockedFrame failed";
422 RaiseError(QUIC_INVALID_FRAME_DATA
);
423 // TODO(rtenneti): Revert the CHECKs to LOG(DFATAL).
424 CHECK(false) << "QUIC_INVALID_FRAME_DATA";
431 new QuicPacket(writer
.data(), writer
.length(), false,
432 header
.public_header
.connection_id_length
,
433 header
.public_header
.version_flag
,
434 header
.public_header
.sequence_number_length
);
439 QuicPacket
* QuicFramer::BuildFecPacket(const QuicPacketHeader
& header
,
440 const QuicFecData
& fec
) {
441 DCHECK_EQ(IN_FEC_GROUP
, header
.is_in_fec_group
);
442 DCHECK_NE(0u, header
.fec_group
);
443 size_t len
= GetPacketHeaderSize(header
);
444 len
+= fec
.redundancy
.length();
446 scoped_ptr
<char[]> buffer(new char[len
]);
447 QuicDataWriter
writer(len
, buffer
.get());
448 if (!AppendPacketHeader(header
, &writer
)) {
449 LOG(DFATAL
) << "AppendPacketHeader failed";
453 if (!writer
.WriteBytes(fec
.redundancy
.data(), fec
.redundancy
.length())) {
454 LOG(DFATAL
) << "Failed to add FEC";
458 return new QuicPacket(buffer
.release(), len
, true,
459 header
.public_header
.connection_id_length
,
460 header
.public_header
.version_flag
,
461 header
.public_header
.sequence_number_length
);
465 QuicEncryptedPacket
* QuicFramer::BuildPublicResetPacket(
466 const QuicPublicResetPacket
& packet
) {
467 DCHECK(packet
.public_header
.reset_flag
);
469 CryptoHandshakeMessage reset
;
470 reset
.set_tag(kPRST
);
471 reset
.SetValue(kRNON
, packet
.nonce_proof
);
472 reset
.SetValue(kRSEQ
, packet
.rejected_sequence_number
);
473 if (!packet
.client_address
.address().empty()) {
474 // packet.client_address is non-empty.
475 QuicSocketAddressCoder
address_coder(packet
.client_address
);
476 string serialized_address
= address_coder
.Encode();
477 if (serialized_address
.empty()) {
480 reset
.SetStringPiece(kCADR
, serialized_address
);
482 const QuicData
& reset_serialized
= reset
.GetSerialized();
485 kPublicFlagsSize
+ PACKET_8BYTE_CONNECTION_ID
+ reset_serialized
.length();
486 scoped_ptr
<char[]> buffer(new char[len
]);
487 QuicDataWriter
writer(len
, buffer
.get());
489 uint8 flags
= static_cast<uint8
>(PACKET_PUBLIC_FLAGS_RST
|
490 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
);
491 if (!writer
.WriteUInt8(flags
)) {
495 if (!writer
.WriteUInt64(packet
.public_header
.connection_id
)) {
499 if (!writer
.WriteBytes(reset_serialized
.data(), reset_serialized
.length())) {
503 return new QuicEncryptedPacket(buffer
.release(), len
, true);
506 QuicEncryptedPacket
* QuicFramer::BuildVersionNegotiationPacket(
507 const QuicPacketPublicHeader
& header
,
508 const QuicVersionVector
& supported_versions
) {
509 DCHECK(header
.version_flag
);
510 size_t len
= GetVersionNegotiationPacketSize(supported_versions
.size());
511 scoped_ptr
<char[]> buffer(new char[len
]);
512 QuicDataWriter
writer(len
, buffer
.get());
514 uint8 flags
= static_cast<uint8
>(PACKET_PUBLIC_FLAGS_VERSION
|
515 PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
);
516 if (!writer
.WriteUInt8(flags
)) {
520 if (!writer
.WriteUInt64(header
.connection_id
)) {
524 for (size_t i
= 0; i
< supported_versions
.size(); ++i
) {
525 if (!writer
.WriteUInt32(QuicVersionToQuicTag(supported_versions
[i
]))) {
530 return new QuicEncryptedPacket(buffer
.release(), len
, true);
533 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket
& packet
) {
534 DCHECK(!reader_
.get());
535 reader_
.reset(new QuicDataReader(packet
.data(), packet
.length()));
537 visitor_
->OnPacket();
539 // First parse the public header.
540 QuicPacketPublicHeader public_header
;
541 if (!ProcessPublicHeader(&public_header
)) {
542 DLOG(WARNING
) << "Unable to process public header.";
543 DCHECK_NE("", detailed_error_
);
544 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
547 if (!visitor_
->OnUnauthenticatedPublicHeader(public_header
)) {
548 // The visitor suppresses further processing of the packet.
549 reader_
.reset(nullptr);
553 if (perspective_
== Perspective::IS_SERVER
&& public_header
.version_flag
&&
554 public_header
.versions
[0] != quic_version_
) {
555 if (!visitor_
->OnProtocolVersionMismatch(public_header
.versions
[0])) {
556 reader_
.reset(nullptr);
562 if (perspective_
== Perspective::IS_CLIENT
&& public_header
.version_flag
) {
563 rv
= ProcessVersionNegotiationPacket(&public_header
);
564 } else if (public_header
.reset_flag
) {
565 rv
= ProcessPublicResetPacket(public_header
);
566 } else if (packet
.length() <= kMaxPacketSize
) {
567 char buffer
[kMaxPacketSize
];
568 rv
= ProcessDataPacket(public_header
, packet
, buffer
, kMaxPacketSize
);
570 scoped_ptr
<char[]> large_buffer(new char[packet
.length()]);
571 rv
= ProcessDataPacket(public_header
, packet
, large_buffer
.get(),
573 LOG_IF(DFATAL
, rv
) << "QUIC should never successfully process packets "
574 << "larger than kMaxPacketSize. packet size:"
578 reader_
.reset(nullptr);
582 bool QuicFramer::ProcessVersionNegotiationPacket(
583 QuicPacketPublicHeader
* public_header
) {
584 DCHECK_EQ(Perspective::IS_CLIENT
, perspective_
);
585 // Try reading at least once to raise error if the packet is invalid.
588 if (!reader_
->ReadBytes(&version
, kQuicVersionSize
)) {
589 set_detailed_error("Unable to read supported version in negotiation.");
590 return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET
);
592 public_header
->versions
.push_back(QuicTagToQuicVersion(version
));
593 } while (!reader_
->IsDoneReading());
595 visitor_
->OnVersionNegotiationPacket(*public_header
);
599 bool QuicFramer::ProcessDataPacket(const QuicPacketPublicHeader
& public_header
,
600 const QuicEncryptedPacket
& packet
,
601 char* decrypted_buffer
,
602 size_t buffer_length
) {
603 QuicPacketHeader
header(public_header
);
604 if (!ProcessPacketHeader(&header
, packet
, decrypted_buffer
, buffer_length
)) {
605 DLOG(WARNING
) << "Unable to process packet header. Stopping parsing.";
609 if (!visitor_
->OnPacketHeader(header
)) {
610 // The visitor suppresses further processing of the packet.
614 if (packet
.length() > kMaxPacketSize
) {
615 DLOG(WARNING
) << "Packet too large: " << packet
.length();
616 return RaiseError(QUIC_PACKET_TOO_LARGE
);
619 // Handle the payload.
620 if (!header
.fec_flag
) {
621 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
622 StringPiece payload
= reader_
->PeekRemainingPayload();
623 visitor_
->OnFecProtectedPayload(payload
);
625 if (!ProcessFrameData(header
)) {
626 DCHECK_NE(QUIC_NO_ERROR
, error_
); // ProcessFrameData sets the error.
627 DLOG(WARNING
) << "Unable to process frame data.";
631 QuicFecData fec_data
;
632 fec_data
.fec_group
= header
.fec_group
;
633 fec_data
.redundancy
= reader_
->ReadRemainingPayload();
634 visitor_
->OnFecData(fec_data
);
637 visitor_
->OnPacketComplete();
641 bool QuicFramer::ProcessPublicResetPacket(
642 const QuicPacketPublicHeader
& public_header
) {
643 QuicPublicResetPacket
packet(public_header
);
645 scoped_ptr
<CryptoHandshakeMessage
> reset(
646 CryptoFramer::ParseMessage(reader_
->ReadRemainingPayload()));
648 set_detailed_error("Unable to read reset message.");
649 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
651 if (reset
->tag() != kPRST
) {
652 set_detailed_error("Incorrect message tag.");
653 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
656 if (reset
->GetUint64(kRNON
, &packet
.nonce_proof
) != QUIC_NO_ERROR
) {
657 set_detailed_error("Unable to read nonce proof.");
658 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
660 // TODO(satyamshekhar): validate nonce to protect against DoS.
662 if (reset
->GetUint64(kRSEQ
, &packet
.rejected_sequence_number
) !=
664 set_detailed_error("Unable to read rejected sequence number.");
665 return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET
);
669 if (reset
->GetStringPiece(kCADR
, &address
)) {
670 QuicSocketAddressCoder address_coder
;
671 if (address_coder
.Decode(address
.data(), address
.length())) {
672 packet
.client_address
= IPEndPoint(address_coder
.ip(),
673 address_coder
.port());
677 visitor_
->OnPublicResetPacket(packet
);
681 bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader
* header
,
682 StringPiece payload
) {
683 DCHECK(!reader_
.get());
685 visitor_
->OnRevivedPacket();
687 header
->entropy_hash
= GetPacketEntropyHash(*header
);
689 if (!visitor_
->OnPacketHeader(*header
)) {
693 if (payload
.length() > kMaxPacketSize
) {
694 set_detailed_error("Revived packet too large.");
695 return RaiseError(QUIC_PACKET_TOO_LARGE
);
698 reader_
.reset(new QuicDataReader(payload
.data(), payload
.length()));
699 if (!ProcessFrameData(*header
)) {
700 DCHECK_NE(QUIC_NO_ERROR
, error_
); // ProcessFrameData sets the error.
701 DLOG(WARNING
) << "Unable to process frame data.";
705 visitor_
->OnPacketComplete();
706 reader_
.reset(nullptr);
710 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader
& header
,
711 QuicDataWriter
* writer
) {
712 DVLOG(1) << "Appending header: " << header
;
713 DCHECK(header
.fec_group
> 0 || header
.is_in_fec_group
== NOT_IN_FEC_GROUP
);
714 uint8 public_flags
= 0;
715 if (header
.public_header
.reset_flag
) {
716 public_flags
|= PACKET_PUBLIC_FLAGS_RST
;
718 if (header
.public_header
.version_flag
) {
719 public_flags
|= PACKET_PUBLIC_FLAGS_VERSION
;
723 GetSequenceNumberFlags(header
.public_header
.sequence_number_length
)
724 << kPublicHeaderSequenceNumberShift
;
726 switch (header
.public_header
.connection_id_length
) {
727 case PACKET_0BYTE_CONNECTION_ID
:
728 if (!writer
->WriteUInt8(
729 public_flags
| PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID
)) {
733 case PACKET_1BYTE_CONNECTION_ID
:
734 if (!writer
->WriteUInt8(
735 public_flags
| PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID
)) {
738 if (!writer
->WriteUInt8(
739 header
.public_header
.connection_id
& k1ByteConnectionIdMask
)) {
743 case PACKET_4BYTE_CONNECTION_ID
:
744 if (!writer
->WriteUInt8(
745 public_flags
| PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID
)) {
748 if (!writer
->WriteUInt32(
749 header
.public_header
.connection_id
& k4ByteConnectionIdMask
)) {
753 case PACKET_8BYTE_CONNECTION_ID
:
754 if (!writer
->WriteUInt8(
755 public_flags
| PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
)) {
758 if (!writer
->WriteUInt64(header
.public_header
.connection_id
)) {
763 last_serialized_connection_id_
= header
.public_header
.connection_id
;
765 if (header
.public_header
.version_flag
) {
766 DCHECK_EQ(Perspective::IS_CLIENT
, perspective_
);
767 QuicTag tag
= QuicVersionToQuicTag(quic_version_
);
768 writer
->WriteUInt32(tag
);
769 DVLOG(1) << "version = " << quic_version_
<< ", tag = '"
770 << QuicUtils::TagToString(tag
) << "'";
773 if (!AppendPacketSequenceNumber(header
.public_header
.sequence_number_length
,
774 header
.packet_sequence_number
, writer
)) {
778 uint8 private_flags
= 0;
779 if (header
.entropy_flag
) {
780 private_flags
|= PACKET_PRIVATE_FLAGS_ENTROPY
;
782 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
783 private_flags
|= PACKET_PRIVATE_FLAGS_FEC_GROUP
;
785 if (header
.fec_flag
) {
786 private_flags
|= PACKET_PRIVATE_FLAGS_FEC
;
788 if (!writer
->WriteUInt8(private_flags
)) {
792 // The FEC group number is the sequence number of the first fec
793 // protected packet, or 0 if this packet is not protected.
794 if (header
.is_in_fec_group
== IN_FEC_GROUP
) {
795 DCHECK_LE(header
.fec_group
, header
.packet_sequence_number
);
796 DCHECK_LT(header
.packet_sequence_number
- header
.fec_group
, 255u);
797 // Offset from the current packet sequence number to the first fec
799 uint8 first_fec_protected_packet_offset
=
800 static_cast<uint8
>(header
.packet_sequence_number
- header
.fec_group
);
801 if (!writer
->WriteBytes(&first_fec_protected_packet_offset
, 1)) {
809 const QuicTime::Delta
QuicFramer::CalculateTimestampFromWire(
810 uint32 time_delta_us
) {
811 // The new time_delta might have wrapped to the next epoch, or it
812 // might have reverse wrapped to the previous epoch, or it might
813 // remain in the same epoch. Select the time closest to the previous
816 // epoch_delta is the delta between epochs. A delta is 4 bytes of
818 const uint64 epoch_delta
= UINT64_C(1) << 32;
819 uint64 epoch
= last_timestamp_
.ToMicroseconds() & ~(epoch_delta
- 1);
820 // Wrapping is safe here because a wrapped value will not be ClosestTo below.
821 uint64 prev_epoch
= epoch
- epoch_delta
;
822 uint64 next_epoch
= epoch
+ epoch_delta
;
824 uint64 time
= ClosestTo(last_timestamp_
.ToMicroseconds(),
825 epoch
+ time_delta_us
,
826 ClosestTo(last_timestamp_
.ToMicroseconds(),
827 prev_epoch
+ time_delta_us
,
828 next_epoch
+ time_delta_us
));
830 return QuicTime::Delta::FromMicroseconds(time
);
833 QuicPacketSequenceNumber
QuicFramer::CalculatePacketSequenceNumberFromWire(
834 QuicSequenceNumberLength sequence_number_length
,
835 QuicPacketSequenceNumber packet_sequence_number
) const {
836 // The new sequence number might have wrapped to the next epoch, or
837 // it might have reverse wrapped to the previous epoch, or it might
838 // remain in the same epoch. Select the sequence number closest to the
839 // next expected sequence number, the previous sequence number plus 1.
841 // epoch_delta is the delta between epochs the sequence number was serialized
842 // with, so the correct value is likely the same epoch as the last sequence
843 // number or an adjacent epoch.
844 const QuicPacketSequenceNumber epoch_delta
=
845 UINT64_C(1) << (8 * sequence_number_length
);
846 QuicPacketSequenceNumber next_sequence_number
= last_sequence_number_
+ 1;
847 QuicPacketSequenceNumber epoch
= last_sequence_number_
& ~(epoch_delta
- 1);
848 QuicPacketSequenceNumber prev_epoch
= epoch
- epoch_delta
;
849 QuicPacketSequenceNumber next_epoch
= epoch
+ epoch_delta
;
851 return ClosestTo(next_sequence_number
,
852 epoch
+ packet_sequence_number
,
853 ClosestTo(next_sequence_number
,
854 prev_epoch
+ packet_sequence_number
,
855 next_epoch
+ packet_sequence_number
));
858 bool QuicFramer::ProcessPublicHeader(
859 QuicPacketPublicHeader
* public_header
) {
861 if (!reader_
->ReadBytes(&public_flags
, 1)) {
862 set_detailed_error("Unable to read public flags.");
866 public_header
->reset_flag
= (public_flags
& PACKET_PUBLIC_FLAGS_RST
) != 0;
867 public_header
->version_flag
=
868 (public_flags
& PACKET_PUBLIC_FLAGS_VERSION
) != 0;
870 if (validate_flags_
&&
871 !public_header
->version_flag
&& public_flags
> PACKET_PUBLIC_FLAGS_MAX
) {
872 set_detailed_error("Illegal public flags value.");
876 if (public_header
->reset_flag
&& public_header
->version_flag
) {
877 set_detailed_error("Got version flag in reset packet");
881 switch (public_flags
& PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
) {
882 case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID
:
883 if (!reader_
->ReadUInt64(&public_header
->connection_id
)) {
884 set_detailed_error("Unable to read ConnectionId.");
887 public_header
->connection_id_length
= PACKET_8BYTE_CONNECTION_ID
;
889 case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID
:
890 // If the connection_id is truncated, expect to read the last serialized
892 if (!reader_
->ReadBytes(&public_header
->connection_id
,
893 PACKET_4BYTE_CONNECTION_ID
)) {
894 set_detailed_error("Unable to read ConnectionId.");
897 if (last_serialized_connection_id_
&&
898 (public_header
->connection_id
& k4ByteConnectionIdMask
) !=
899 (last_serialized_connection_id_
& k4ByteConnectionIdMask
)) {
900 set_detailed_error("Truncated 4 byte ConnectionId does not match "
901 "previous connection_id.");
904 public_header
->connection_id_length
= PACKET_4BYTE_CONNECTION_ID
;
905 public_header
->connection_id
= last_serialized_connection_id_
;
907 case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID
:
908 if (!reader_
->ReadBytes(&public_header
->connection_id
,
909 PACKET_1BYTE_CONNECTION_ID
)) {
910 set_detailed_error("Unable to read ConnectionId.");
913 if (last_serialized_connection_id_
&&
914 (public_header
->connection_id
& k1ByteConnectionIdMask
) !=
915 (last_serialized_connection_id_
& k1ByteConnectionIdMask
)) {
916 set_detailed_error("Truncated 1 byte ConnectionId does not match "
917 "previous connection_id.");
920 public_header
->connection_id_length
= PACKET_1BYTE_CONNECTION_ID
;
921 public_header
->connection_id
= last_serialized_connection_id_
;
923 case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID
:
924 public_header
->connection_id_length
= PACKET_0BYTE_CONNECTION_ID
;
925 public_header
->connection_id
= last_serialized_connection_id_
;
929 public_header
->sequence_number_length
=
930 ReadSequenceNumberLength(
931 public_flags
>> kPublicHeaderSequenceNumberShift
);
933 // Read the version only if the packet is from the client.
934 // version flag from the server means version negotiation packet.
935 if (public_header
->version_flag
&& perspective_
== Perspective::IS_SERVER
) {
937 if (!reader_
->ReadUInt32(&version_tag
)) {
938 set_detailed_error("Unable to read protocol version.");
942 // If the version from the new packet is the same as the version of this
943 // framer, then the public flags should be set to something we understand.
944 // If not, this raises an error.
945 QuicVersion version
= QuicTagToQuicVersion(version_tag
);
946 if (version
== quic_version_
&& public_flags
> PACKET_PUBLIC_FLAGS_MAX
) {
947 set_detailed_error("Illegal public flags value.");
950 public_header
->versions
.push_back(version
);
956 QuicSequenceNumberLength
QuicFramer::GetMinSequenceNumberLength(
957 QuicPacketSequenceNumber sequence_number
) {
958 if (sequence_number
< 1 << (PACKET_1BYTE_SEQUENCE_NUMBER
* 8)) {
959 return PACKET_1BYTE_SEQUENCE_NUMBER
;
960 } else if (sequence_number
< 1 << (PACKET_2BYTE_SEQUENCE_NUMBER
* 8)) {
961 return PACKET_2BYTE_SEQUENCE_NUMBER
;
962 } else if (sequence_number
<
963 UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER
* 8)) {
964 return PACKET_4BYTE_SEQUENCE_NUMBER
;
966 return PACKET_6BYTE_SEQUENCE_NUMBER
;
971 uint8
QuicFramer::GetSequenceNumberFlags(
972 QuicSequenceNumberLength sequence_number_length
) {
973 switch (sequence_number_length
) {
974 case PACKET_1BYTE_SEQUENCE_NUMBER
:
975 return PACKET_FLAGS_1BYTE_SEQUENCE
;
976 case PACKET_2BYTE_SEQUENCE_NUMBER
:
977 return PACKET_FLAGS_2BYTE_SEQUENCE
;
978 case PACKET_4BYTE_SEQUENCE_NUMBER
:
979 return PACKET_FLAGS_4BYTE_SEQUENCE
;
980 case PACKET_6BYTE_SEQUENCE_NUMBER
:
981 return PACKET_FLAGS_6BYTE_SEQUENCE
;
983 LOG(DFATAL
) << "Unreachable case statement.";
984 return PACKET_FLAGS_6BYTE_SEQUENCE
;
989 QuicFramer::AckFrameInfo
QuicFramer::GetAckFrameInfo(
990 const QuicAckFrame
& frame
) {
991 AckFrameInfo ack_info
;
992 if (frame
.missing_packets
.empty()) {
995 DCHECK_GE(frame
.largest_observed
, *frame
.missing_packets
.rbegin());
996 size_t cur_range_length
= 0;
997 SequenceNumberSet::const_iterator iter
= frame
.missing_packets
.begin();
998 QuicPacketSequenceNumber last_missing
= *iter
;
1000 for (; iter
!= frame
.missing_packets
.end(); ++iter
) {
1001 if (cur_range_length
< numeric_limits
<uint8
>::max() &&
1002 *iter
== (last_missing
+ 1)) {
1005 ack_info
.nack_ranges
[last_missing
- cur_range_length
] =
1006 static_cast<uint8
>(cur_range_length
);
1007 cur_range_length
= 0;
1009 ack_info
.max_delta
= max(ack_info
.max_delta
, *iter
- last_missing
);
1010 last_missing
= *iter
;
1012 // Include the last nack range.
1013 ack_info
.nack_ranges
[last_missing
- cur_range_length
] =
1014 static_cast<uint8
>(cur_range_length
);
1015 // Include the range to the largest observed.
1016 ack_info
.max_delta
=
1017 max(ack_info
.max_delta
, frame
.largest_observed
- last_missing
);
1021 bool QuicFramer::ProcessPacketHeader(QuicPacketHeader
* header
,
1022 const QuicEncryptedPacket
& packet
,
1023 char* decrypted_buffer
,
1024 size_t buffer_length
) {
1025 if (!ProcessPacketSequenceNumber(header
->public_header
.sequence_number_length
,
1026 &header
->packet_sequence_number
)) {
1027 set_detailed_error("Unable to read sequence number.");
1028 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1031 if (header
->packet_sequence_number
== 0u) {
1032 set_detailed_error("Packet sequence numbers cannot be 0.");
1033 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1036 if (!visitor_
->OnUnauthenticatedHeader(*header
)) {
1040 if (!DecryptPayload(*header
, packet
, decrypted_buffer
, buffer_length
)) {
1041 set_detailed_error("Unable to decrypt payload.");
1042 return RaiseError(QUIC_DECRYPTION_FAILURE
);
1045 uint8 private_flags
;
1046 if (!reader_
->ReadBytes(&private_flags
, 1)) {
1047 set_detailed_error("Unable to read private flags.");
1048 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1051 if (private_flags
> PACKET_PRIVATE_FLAGS_MAX
) {
1052 set_detailed_error("Illegal private flags value.");
1053 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1056 header
->entropy_flag
= (private_flags
& PACKET_PRIVATE_FLAGS_ENTROPY
) != 0;
1057 header
->fec_flag
= (private_flags
& PACKET_PRIVATE_FLAGS_FEC
) != 0;
1059 if ((private_flags
& PACKET_PRIVATE_FLAGS_FEC_GROUP
) != 0) {
1060 header
->is_in_fec_group
= IN_FEC_GROUP
;
1061 uint8 first_fec_protected_packet_offset
;
1062 if (!reader_
->ReadBytes(&first_fec_protected_packet_offset
, 1)) {
1063 set_detailed_error("Unable to read first fec protected packet offset.");
1064 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1066 if (first_fec_protected_packet_offset
>= header
->packet_sequence_number
) {
1067 set_detailed_error("First fec protected packet offset must be less "
1068 "than the sequence number.");
1069 return RaiseError(QUIC_INVALID_PACKET_HEADER
);
1072 header
->packet_sequence_number
- first_fec_protected_packet_offset
;
1075 header
->entropy_hash
= GetPacketEntropyHash(*header
);
1076 // Set the last sequence number after we have decrypted the packet
1077 // so we are confident is not attacker controlled.
1078 last_sequence_number_
= header
->packet_sequence_number
;
1082 bool QuicFramer::ProcessPacketSequenceNumber(
1083 QuicSequenceNumberLength sequence_number_length
,
1084 QuicPacketSequenceNumber
* sequence_number
) {
1085 QuicPacketSequenceNumber wire_sequence_number
= 0u;
1086 if (!reader_
->ReadBytes(&wire_sequence_number
, sequence_number_length
)) {
1090 // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers
1091 // in case the first guess is incorrect.
1093 CalculatePacketSequenceNumberFromWire(sequence_number_length
,
1094 wire_sequence_number
);
1098 bool QuicFramer::ProcessFrameData(const QuicPacketHeader
& header
) {
1099 if (reader_
->IsDoneReading()) {
1100 set_detailed_error("Packet has no frames.");
1101 return RaiseError(QUIC_MISSING_PAYLOAD
);
1103 while (!reader_
->IsDoneReading()) {
1105 if (!reader_
->ReadBytes(&frame_type
, 1)) {
1106 set_detailed_error("Unable to read frame type.");
1107 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1110 if (frame_type
& kQuicFrameTypeSpecialMask
) {
1112 if (frame_type
& kQuicFrameTypeStreamMask
) {
1113 QuicStreamFrame frame
;
1114 if (!ProcessStreamFrame(frame_type
, &frame
)) {
1115 return RaiseError(QUIC_INVALID_STREAM_DATA
);
1117 if (!visitor_
->OnStreamFrame(frame
)) {
1118 DVLOG(1) << "Visitor asked to stop further processing.";
1119 // Returning true since there was no parsing error.
1126 if (frame_type
& kQuicFrameTypeAckMask
) {
1128 if (!ProcessAckFrame(frame_type
, &frame
)) {
1129 return RaiseError(QUIC_INVALID_ACK_DATA
);
1131 if (!visitor_
->OnAckFrame(frame
)) {
1132 DVLOG(1) << "Visitor asked to stop further processing.";
1133 // Returning true since there was no parsing error.
1139 // This was a special frame type that did not match any
1140 // of the known ones. Error.
1141 set_detailed_error("Illegal frame type.");
1142 DLOG(WARNING
) << "Illegal frame type: "
1143 << static_cast<int>(frame_type
);
1144 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1147 switch (frame_type
) {
1149 // We're done with the packet.
1152 case RST_STREAM_FRAME
: {
1153 QuicRstStreamFrame frame
;
1154 if (!ProcessRstStreamFrame(&frame
)) {
1155 return RaiseError(QUIC_INVALID_RST_STREAM_DATA
);
1157 if (!visitor_
->OnRstStreamFrame(frame
)) {
1158 DVLOG(1) << "Visitor asked to stop further processing.";
1159 // Returning true since there was no parsing error.
1165 case CONNECTION_CLOSE_FRAME
: {
1166 QuicConnectionCloseFrame frame
;
1167 if (!ProcessConnectionCloseFrame(&frame
)) {
1168 return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA
);
1171 if (!visitor_
->OnConnectionCloseFrame(frame
)) {
1172 DVLOG(1) << "Visitor asked to stop further processing.";
1173 // Returning true since there was no parsing error.
1179 case GOAWAY_FRAME
: {
1180 QuicGoAwayFrame goaway_frame
;
1181 if (!ProcessGoAwayFrame(&goaway_frame
)) {
1182 return RaiseError(QUIC_INVALID_GOAWAY_DATA
);
1184 if (!visitor_
->OnGoAwayFrame(goaway_frame
)) {
1185 DVLOG(1) << "Visitor asked to stop further processing.";
1186 // Returning true since there was no parsing error.
1192 case WINDOW_UPDATE_FRAME
: {
1193 QuicWindowUpdateFrame window_update_frame
;
1194 if (!ProcessWindowUpdateFrame(&window_update_frame
)) {
1195 return RaiseError(QUIC_INVALID_WINDOW_UPDATE_DATA
);
1197 if (!visitor_
->OnWindowUpdateFrame(window_update_frame
)) {
1198 DVLOG(1) << "Visitor asked to stop further processing.";
1199 // Returning true since there was no parsing error.
1205 case BLOCKED_FRAME
: {
1206 QuicBlockedFrame blocked_frame
;
1207 if (!ProcessBlockedFrame(&blocked_frame
)) {
1208 return RaiseError(QUIC_INVALID_BLOCKED_DATA
);
1210 if (!visitor_
->OnBlockedFrame(blocked_frame
)) {
1211 DVLOG(1) << "Visitor asked to stop further processing.";
1212 // Returning true since there was no parsing error.
1218 case STOP_WAITING_FRAME
: {
1219 QuicStopWaitingFrame stop_waiting_frame
;
1220 if (!ProcessStopWaitingFrame(header
, &stop_waiting_frame
)) {
1221 return RaiseError(QUIC_INVALID_STOP_WAITING_DATA
);
1223 if (!visitor_
->OnStopWaitingFrame(stop_waiting_frame
)) {
1224 DVLOG(1) << "Visitor asked to stop further processing.";
1225 // Returning true since there was no parsing error.
1231 // Ping has no payload.
1232 QuicPingFrame ping_frame
;
1233 if (!visitor_
->OnPingFrame(ping_frame
)) {
1234 DVLOG(1) << "Visitor asked to stop further processing.";
1235 // Returning true since there was no parsing error.
1242 set_detailed_error("Illegal frame type.");
1243 DLOG(WARNING
) << "Illegal frame type: "
1244 << static_cast<int>(frame_type
);
1245 return RaiseError(QUIC_INVALID_FRAME_DATA
);
1252 bool QuicFramer::ProcessStreamFrame(uint8 frame_type
,
1253 QuicStreamFrame
* frame
) {
1254 uint8 stream_flags
= frame_type
;
1256 stream_flags
&= ~kQuicFrameTypeStreamMask
;
1258 // Read from right to left: StreamID, Offset, Data Length, Fin.
1259 const uint8 stream_id_length
= (stream_flags
& kQuicStreamIDLengthMask
) + 1;
1260 stream_flags
>>= kQuicStreamIdShift
;
1262 uint8 offset_length
= (stream_flags
& kQuicStreamOffsetMask
);
1263 // There is no encoding for 1 byte, only 0 and 2 through 8.
1264 if (offset_length
> 0) {
1267 stream_flags
>>= kQuicStreamOffsetShift
;
1269 bool has_data_length
=
1270 (stream_flags
& kQuicStreamDataLengthMask
) == kQuicStreamDataLengthMask
;
1271 stream_flags
>>= kQuicStreamDataLengthShift
;
1273 frame
->fin
= (stream_flags
& kQuicStreamFinMask
) == kQuicStreamFinShift
;
1275 frame
->stream_id
= 0;
1276 if (!reader_
->ReadBytes(&frame
->stream_id
, stream_id_length
)) {
1277 set_detailed_error("Unable to read stream_id.");
1282 if (!reader_
->ReadBytes(&frame
->offset
, offset_length
)) {
1283 set_detailed_error("Unable to read offset.");
1287 if (has_data_length
) {
1288 if (!reader_
->ReadStringPiece16(&frame
->data
)) {
1289 set_detailed_error("Unable to read frame data.");
1293 if (!reader_
->ReadStringPiece(&frame
->data
, reader_
->BytesRemaining())) {
1294 set_detailed_error("Unable to read frame data.");
1302 bool QuicFramer::ProcessAckFrame(uint8 frame_type
, QuicAckFrame
* ack_frame
) {
1303 // Determine the three lengths from the frame type: largest observed length,
1304 // missing sequence number length, and missing range length.
1305 const QuicSequenceNumberLength missing_sequence_number_length
=
1306 ReadSequenceNumberLength(frame_type
);
1307 frame_type
>>= kQuicSequenceNumberLengthShift
;
1308 const QuicSequenceNumberLength largest_observed_sequence_number_length
=
1309 ReadSequenceNumberLength(frame_type
);
1310 frame_type
>>= kQuicSequenceNumberLengthShift
;
1311 ack_frame
->is_truncated
= frame_type
& kQuicAckTruncatedMask
;
1312 frame_type
>>= kQuicAckTruncatedShift
;
1313 bool has_nacks
= frame_type
& kQuicHasNacksMask
;
1315 if (!reader_
->ReadBytes(&ack_frame
->entropy_hash
, 1)) {
1316 set_detailed_error("Unable to read entropy hash for received packets.");
1320 if (!reader_
->ReadBytes(&ack_frame
->largest_observed
,
1321 largest_observed_sequence_number_length
)) {
1322 set_detailed_error("Unable to read largest observed.");
1326 uint64 delta_time_largest_observed_us
;
1327 if (!reader_
->ReadUFloat16(&delta_time_largest_observed_us
)) {
1328 set_detailed_error("Unable to read delta time largest observed.");
1332 if (delta_time_largest_observed_us
== kUFloat16MaxValue
) {
1333 ack_frame
->delta_time_largest_observed
= QuicTime::Delta::Infinite();
1335 ack_frame
->delta_time_largest_observed
=
1336 QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us
);
1339 if (!ProcessTimestampsInAckFrame(ack_frame
)) {
1347 uint8 num_missing_ranges
;
1348 if (!reader_
->ReadBytes(&num_missing_ranges
, 1)) {
1349 set_detailed_error("Unable to read num missing packet ranges.");
1353 QuicPacketSequenceNumber last_sequence_number
= ack_frame
->largest_observed
;
1354 for (size_t i
= 0; i
< num_missing_ranges
; ++i
) {
1355 QuicPacketSequenceNumber missing_delta
= 0;
1356 if (!reader_
->ReadBytes(&missing_delta
, missing_sequence_number_length
)) {
1357 set_detailed_error("Unable to read missing sequence number delta.");
1360 last_sequence_number
-= missing_delta
;
1361 QuicPacketSequenceNumber range_length
= 0;
1362 if (!reader_
->ReadBytes(&range_length
, PACKET_1BYTE_SEQUENCE_NUMBER
)) {
1363 set_detailed_error("Unable to read missing sequence number range.");
1366 for (size_t j
= 0; j
<= range_length
; ++j
) {
1367 ack_frame
->missing_packets
.insert(last_sequence_number
- j
);
1369 // Subtract an extra 1 to ensure ranges are represented efficiently and
1370 // can't overlap by 1 sequence number. This allows a missing_delta of 0
1371 // to represent an adjacent nack range.
1372 last_sequence_number
-= (range_length
+ 1);
1375 // Parse the revived packets list.
1376 uint8 num_revived_packets
;
1377 if (!reader_
->ReadBytes(&num_revived_packets
, 1)) {
1378 set_detailed_error("Unable to read num revived packets.");
1382 for (size_t i
= 0; i
< num_revived_packets
; ++i
) {
1383 QuicPacketSequenceNumber revived_packet
= 0;
1384 if (!reader_
->ReadBytes(&revived_packet
,
1385 largest_observed_sequence_number_length
)) {
1386 set_detailed_error("Unable to read revived packet.");
1390 ack_frame
->revived_packets
.insert(revived_packet
);
1396 bool QuicFramer::ProcessTimestampsInAckFrame(QuicAckFrame
* ack_frame
) {
1397 if (ack_frame
->is_truncated
) {
1400 uint8 num_received_packets
;
1401 if (!reader_
->ReadBytes(&num_received_packets
, 1)) {
1402 set_detailed_error("Unable to read num received packets.");
1406 if (num_received_packets
> 0) {
1407 uint8 delta_from_largest_observed
;
1408 if (!reader_
->ReadBytes(&delta_from_largest_observed
,
1409 PACKET_1BYTE_SEQUENCE_NUMBER
)) {
1410 set_detailed_error("Unable to read sequence delta in received packets.");
1413 QuicPacketSequenceNumber seq_num
=
1414 ack_frame
->largest_observed
- delta_from_largest_observed
;
1416 // Time delta from the framer creation.
1417 uint32 time_delta_us
;
1418 if (!reader_
->ReadBytes(&time_delta_us
, sizeof(time_delta_us
))) {
1419 set_detailed_error("Unable to read time delta in received packets.");
1423 last_timestamp_
= CalculateTimestampFromWire(time_delta_us
);
1425 ack_frame
->received_packet_times
.push_back(
1426 std::make_pair(seq_num
, creation_time_
.Add(last_timestamp_
)));
1428 for (uint8 i
= 1; i
< num_received_packets
; ++i
) {
1429 if (!reader_
->ReadBytes(&delta_from_largest_observed
,
1430 PACKET_1BYTE_SEQUENCE_NUMBER
)) {
1432 "Unable to read sequence delta in received packets.");
1435 seq_num
= ack_frame
->largest_observed
- delta_from_largest_observed
;
1437 // Time delta from the previous timestamp.
1438 uint64 incremental_time_delta_us
;
1439 if (!reader_
->ReadUFloat16(&incremental_time_delta_us
)) {
1441 "Unable to read incremental time delta in received packets.");
1445 last_timestamp_
= last_timestamp_
.Add(
1446 QuicTime::Delta::FromMicroseconds(incremental_time_delta_us
));
1447 ack_frame
->received_packet_times
.push_back(
1448 std::make_pair(seq_num
, creation_time_
.Add(last_timestamp_
)));
1454 bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader
& header
,
1455 QuicStopWaitingFrame
* stop_waiting
) {
1456 if (!reader_
->ReadBytes(&stop_waiting
->entropy_hash
, 1)) {
1457 set_detailed_error("Unable to read entropy hash for sent packets.");
1461 QuicPacketSequenceNumber least_unacked_delta
= 0;
1462 if (!reader_
->ReadBytes(&least_unacked_delta
,
1463 header
.public_header
.sequence_number_length
)) {
1464 set_detailed_error("Unable to read least unacked delta.");
1467 DCHECK_GE(header
.packet_sequence_number
, least_unacked_delta
);
1468 stop_waiting
->least_unacked
=
1469 header
.packet_sequence_number
- least_unacked_delta
;
1474 bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame
* frame
) {
1475 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1476 set_detailed_error("Unable to read stream_id.");
1480 if (!reader_
->ReadUInt64(&frame
->byte_offset
)) {
1481 set_detailed_error("Unable to read rst stream sent byte offset.");
1486 if (!reader_
->ReadUInt32(&error_code
)) {
1487 set_detailed_error("Unable to read rst stream error code.");
1491 if (error_code
>= QUIC_STREAM_LAST_ERROR
) {
1492 set_detailed_error("Invalid rst stream error code.");
1496 frame
->error_code
= static_cast<QuicRstStreamErrorCode
>(error_code
);
1497 if (quic_version_
<= QUIC_VERSION_24
) {
1498 StringPiece error_details
;
1499 if (!reader_
->ReadStringPiece16(&error_details
)) {
1500 set_detailed_error("Unable to read rst stream error details.");
1503 frame
->error_details
= error_details
.as_string();
1509 bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame
* frame
) {
1511 if (!reader_
->ReadUInt32(&error_code
)) {
1512 set_detailed_error("Unable to read connection close error code.");
1516 if (error_code
>= QUIC_LAST_ERROR
) {
1517 set_detailed_error("Invalid error code.");
1521 frame
->error_code
= static_cast<QuicErrorCode
>(error_code
);
1523 StringPiece error_details
;
1524 if (!reader_
->ReadStringPiece16(&error_details
)) {
1525 set_detailed_error("Unable to read connection close error details.");
1528 frame
->error_details
= error_details
.as_string();
1533 bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame
* frame
) {
1535 if (!reader_
->ReadUInt32(&error_code
)) {
1536 set_detailed_error("Unable to read go away error code.");
1539 frame
->error_code
= static_cast<QuicErrorCode
>(error_code
);
1541 if (error_code
>= QUIC_LAST_ERROR
) {
1542 set_detailed_error("Invalid error code.");
1547 if (!reader_
->ReadUInt32(&stream_id
)) {
1548 set_detailed_error("Unable to read last good stream id.");
1551 frame
->last_good_stream_id
= static_cast<QuicStreamId
>(stream_id
);
1553 StringPiece reason_phrase
;
1554 if (!reader_
->ReadStringPiece16(&reason_phrase
)) {
1555 set_detailed_error("Unable to read goaway reason.");
1558 frame
->reason_phrase
= reason_phrase
.as_string();
1563 bool QuicFramer::ProcessWindowUpdateFrame(QuicWindowUpdateFrame
* frame
) {
1564 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1565 set_detailed_error("Unable to read stream_id.");
1569 if (!reader_
->ReadUInt64(&frame
->byte_offset
)) {
1570 set_detailed_error("Unable to read window byte_offset.");
1577 bool QuicFramer::ProcessBlockedFrame(QuicBlockedFrame
* frame
) {
1578 if (!reader_
->ReadUInt32(&frame
->stream_id
)) {
1579 set_detailed_error("Unable to read stream_id.");
1587 StringPiece
QuicFramer::GetAssociatedDataFromEncryptedPacket(
1588 const QuicEncryptedPacket
& encrypted
,
1589 QuicConnectionIdLength connection_id_length
,
1590 bool includes_version
,
1591 QuicSequenceNumberLength sequence_number_length
) {
1593 encrypted
.data() + kStartOfHashData
, GetStartOfEncryptedData(
1594 connection_id_length
, includes_version
, sequence_number_length
)
1595 - kStartOfHashData
);
1598 void QuicFramer::SetDecrypter(EncryptionLevel level
, QuicDecrypter
* decrypter
) {
1599 DCHECK(alternative_decrypter_
.get() == nullptr);
1600 DCHECK_GE(level
, decrypter_level_
);
1601 decrypter_
.reset(decrypter
);
1602 decrypter_level_
= level
;
1605 void QuicFramer::SetAlternativeDecrypter(EncryptionLevel level
,
1606 QuicDecrypter
* decrypter
,
1607 bool latch_once_used
) {
1608 alternative_decrypter_
.reset(decrypter
);
1609 alternative_decrypter_level_
= level
;
1610 alternative_decrypter_latch_
= latch_once_used
;
1613 const QuicDecrypter
* QuicFramer::decrypter() const {
1614 return decrypter_
.get();
1617 const QuicDecrypter
* QuicFramer::alternative_decrypter() const {
1618 return alternative_decrypter_
.get();
1621 void QuicFramer::SetEncrypter(EncryptionLevel level
,
1622 QuicEncrypter
* encrypter
) {
1623 DCHECK_GE(level
, 0);
1624 DCHECK_LT(level
, NUM_ENCRYPTION_LEVELS
);
1625 encrypter_
[level
].reset(encrypter
);
1628 QuicEncryptedPacket
* QuicFramer::EncryptPayload(
1629 EncryptionLevel level
,
1630 QuicPacketSequenceNumber packet_sequence_number
,
1631 const QuicPacket
& packet
,
1633 size_t buffer_len
) {
1634 DCHECK(encrypter_
[level
].get() != nullptr);
1636 const size_t encrypted_len
=
1637 encrypter_
[level
]->GetCiphertextSize(packet
.Plaintext().length());
1638 StringPiece header_data
= packet
.BeforePlaintext();
1639 const size_t total_len
= header_data
.length() + encrypted_len
;
1641 char* encryption_buffer
= buffer
;
1642 // Allocate a large enough buffer for the header and the encrypted data.
1643 const bool is_new_buffer
= total_len
> buffer_len
;
1644 if (is_new_buffer
) {
1645 if (!FLAGS_quic_allow_oversized_packets_for_test
) {
1646 LOG(DFATAL
) << "Buffer of length:" << buffer_len
1647 << " is not large enough to encrypt length " << total_len
;
1650 encryption_buffer
= new char[total_len
];
1652 // Copy in the header, because the encrypter only populates the encrypted
1653 // plaintext content.
1654 memcpy(encryption_buffer
, header_data
.data(), header_data
.length());
1655 // Encrypt the plaintext into the buffer.
1656 size_t output_length
= 0;
1657 if (!encrypter_
[level
]->EncryptPacket(
1658 packet_sequence_number
, packet
.AssociatedData(), packet
.Plaintext(),
1659 encryption_buffer
+ header_data
.length(), &output_length
,
1661 RaiseError(QUIC_ENCRYPTION_FAILURE
);
1665 return new QuicEncryptedPacket(
1666 encryption_buffer
, header_data
.length() + output_length
, is_new_buffer
);
1669 size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size
) {
1670 // In order to keep the code simple, we don't have the current encryption
1671 // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12.
1672 size_t min_plaintext_size
= ciphertext_size
;
1674 for (int i
= ENCRYPTION_NONE
; i
< NUM_ENCRYPTION_LEVELS
; i
++) {
1675 if (encrypter_
[i
].get() != nullptr) {
1676 size_t size
= encrypter_
[i
]->GetMaxPlaintextSize(ciphertext_size
);
1677 if (size
< min_plaintext_size
) {
1678 min_plaintext_size
= size
;
1683 return min_plaintext_size
;
1686 bool QuicFramer::DecryptPayload(const QuicPacketHeader
& header
,
1687 const QuicEncryptedPacket
& packet
,
1688 char* decrypted_buffer
,
1689 size_t buffer_length
) {
1690 StringPiece encrypted
= reader_
->ReadRemainingPayload();
1691 DCHECK(decrypter_
.get() != nullptr);
1692 const StringPiece
& associated_data
= GetAssociatedDataFromEncryptedPacket(
1693 packet
, header
.public_header
.connection_id_length
,
1694 header
.public_header
.version_flag
,
1695 header
.public_header
.sequence_number_length
);
1696 size_t decrypted_length
= 0;
1697 bool success
= decrypter_
->DecryptPacket(
1698 header
.packet_sequence_number
, associated_data
, encrypted
,
1699 decrypted_buffer
, &decrypted_length
, buffer_length
);
1701 visitor_
->OnDecryptedPacket(decrypter_level_
);
1702 } else if (alternative_decrypter_
.get() != nullptr) {
1703 success
= alternative_decrypter_
->DecryptPacket(
1704 header
.packet_sequence_number
, associated_data
, encrypted
,
1705 decrypted_buffer
, &decrypted_length
, buffer_length
);
1707 visitor_
->OnDecryptedPacket(alternative_decrypter_level_
);
1708 if (alternative_decrypter_latch_
) {
1709 // Switch to the alternative decrypter and latch so that we cannot
1711 decrypter_
.reset(alternative_decrypter_
.release());
1712 decrypter_level_
= alternative_decrypter_level_
;
1713 alternative_decrypter_level_
= ENCRYPTION_NONE
;
1715 // Switch the alternative decrypter so that we use it first next time.
1716 decrypter_
.swap(alternative_decrypter_
);
1717 EncryptionLevel level
= alternative_decrypter_level_
;
1718 alternative_decrypter_level_
= decrypter_level_
;
1719 decrypter_level_
= level
;
1725 DLOG(WARNING
) << "DecryptPacket failed for sequence_number:"
1726 << header
.packet_sequence_number
;
1730 reader_
.reset(new QuicDataReader(decrypted_buffer
, decrypted_length
));
1734 size_t QuicFramer::GetAckFrameSize(
1735 const QuicAckFrame
& ack
,
1736 QuicSequenceNumberLength sequence_number_length
) {
1737 AckFrameInfo ack_info
= GetAckFrameInfo(ack
);
1738 QuicSequenceNumberLength largest_observed_length
=
1739 GetMinSequenceNumberLength(ack
.largest_observed
);
1740 QuicSequenceNumberLength missing_sequence_number_length
=
1741 GetMinSequenceNumberLength(ack_info
.max_delta
);
1743 size_t ack_size
= GetMinAckFrameSize(largest_observed_length
);
1744 if (!ack_info
.nack_ranges
.empty()) {
1745 ack_size
+= kNumberOfNackRangesSize
+ kNumberOfRevivedPacketsSize
;
1746 ack_size
+= min(ack_info
.nack_ranges
.size(), kMaxNackRanges
) *
1747 (missing_sequence_number_length
+ PACKET_1BYTE_SEQUENCE_NUMBER
);
1748 ack_size
+= min(ack
.revived_packets
.size(),
1749 kMaxRevivedPackets
) * largest_observed_length
;
1752 // In version 23, if the ack will be truncated due to too many nack ranges,
1753 // then do not include the number of timestamps (1 byte).
1754 if (ack_info
.nack_ranges
.size() <= kMaxNackRanges
) {
1755 // 1 byte for the number of timestamps.
1757 if (ack
.received_packet_times
.size() > 0) {
1758 // 1 byte for sequence number, 4 bytes for timestamp for the first
1762 // 1 byte for sequence number, 2 bytes for timestamp for the other
1764 ack_size
+= 3 * (ack
.received_packet_times
.size() - 1);
1771 size_t QuicFramer::ComputeFrameLength(
1772 const QuicFrame
& frame
,
1773 bool last_frame_in_packet
,
1774 InFecGroup is_in_fec_group
,
1775 QuicSequenceNumberLength sequence_number_length
) {
1776 switch (frame
.type
) {
1778 return GetMinStreamFrameSize(frame
.stream_frame
->stream_id
,
1779 frame
.stream_frame
->offset
,
1780 last_frame_in_packet
, is_in_fec_group
) +
1781 frame
.stream_frame
->data
.length();
1783 return GetAckFrameSize(*frame
.ack_frame
, sequence_number_length
);
1785 case STOP_WAITING_FRAME
:
1786 return GetStopWaitingFrameSize(sequence_number_length
);
1787 case MTU_DISCOVERY_FRAME
:
1788 // MTU discovery frames are serialized as ping frames.
1790 // Ping has no payload.
1791 return kQuicFrameTypeSize
;
1792 case RST_STREAM_FRAME
:
1793 if (quic_version_
<= QUIC_VERSION_24
) {
1794 return GetMinRstStreamFrameSize() +
1795 frame
.rst_stream_frame
->error_details
.size();
1797 return GetRstStreamFrameSize();
1798 case CONNECTION_CLOSE_FRAME
:
1799 return GetMinConnectionCloseFrameSize() +
1800 frame
.connection_close_frame
->error_details
.size();
1802 return GetMinGoAwayFrameSize() + frame
.goaway_frame
->reason_phrase
.size();
1803 case WINDOW_UPDATE_FRAME
:
1804 return GetWindowUpdateFrameSize();
1806 return GetBlockedFrameSize();
1810 case NUM_FRAME_TYPES
:
1815 // Not reachable, but some Chrome compilers can't figure that out. *sigh*
1820 bool QuicFramer::AppendTypeByte(const QuicFrame
& frame
,
1821 bool no_stream_frame_length
,
1822 QuicDataWriter
* writer
) {
1823 uint8 type_byte
= 0;
1824 switch (frame
.type
) {
1825 case STREAM_FRAME
: {
1826 if (frame
.stream_frame
== nullptr) {
1827 LOG(DFATAL
) << "Failed to append STREAM frame with no stream_frame.";
1830 type_byte
|= frame
.stream_frame
->fin
? kQuicStreamFinMask
: 0;
1833 type_byte
<<= kQuicStreamDataLengthShift
;
1834 type_byte
|= no_stream_frame_length
? 0: kQuicStreamDataLengthMask
;
1837 type_byte
<<= kQuicStreamOffsetShift
;
1838 const size_t offset_len
= GetStreamOffsetSize(frame
.stream_frame
->offset
);
1839 if (offset_len
> 0) {
1840 type_byte
|= offset_len
- 1;
1843 // stream id 2 bits.
1844 type_byte
<<= kQuicStreamIdShift
;
1845 type_byte
|= GetStreamIdSize(frame
.stream_frame
->stream_id
) - 1;
1846 type_byte
|= kQuicFrameTypeStreamMask
; // Set Stream Frame Type to 1.
1851 case MTU_DISCOVERY_FRAME
:
1852 type_byte
= static_cast<uint8
>(PING_FRAME
);
1855 type_byte
= static_cast<uint8
>(frame
.type
);
1859 return writer
->WriteUInt8(type_byte
);
1863 bool QuicFramer::AppendPacketSequenceNumber(
1864 QuicSequenceNumberLength sequence_number_length
,
1865 QuicPacketSequenceNumber packet_sequence_number
,
1866 QuicDataWriter
* writer
) {
1867 // Ensure the entire sequence number can be written.
1868 if (writer
->capacity() - writer
->length() <
1869 static_cast<size_t>(sequence_number_length
)) {
1872 switch (sequence_number_length
) {
1873 case PACKET_1BYTE_SEQUENCE_NUMBER
:
1874 return writer
->WriteUInt8(
1875 packet_sequence_number
& k1ByteSequenceNumberMask
);
1877 case PACKET_2BYTE_SEQUENCE_NUMBER
:
1878 return writer
->WriteUInt16(
1879 packet_sequence_number
& k2ByteSequenceNumberMask
);
1881 case PACKET_4BYTE_SEQUENCE_NUMBER
:
1882 return writer
->WriteUInt32(
1883 packet_sequence_number
& k4ByteSequenceNumberMask
);
1885 case PACKET_6BYTE_SEQUENCE_NUMBER
:
1886 return writer
->WriteUInt48(
1887 packet_sequence_number
& k6ByteSequenceNumberMask
);
1890 DCHECK(false) << "sequence_number_length: " << sequence_number_length
;
1895 bool QuicFramer::AppendStreamFrame(
1896 const QuicStreamFrame
& frame
,
1897 bool no_stream_frame_length
,
1898 QuicDataWriter
* writer
) {
1899 if (!writer
->WriteBytes(&frame
.stream_id
, GetStreamIdSize(frame
.stream_id
))) {
1900 LOG(DFATAL
) << "Writing stream id size failed.";
1903 if (!writer
->WriteBytes(&frame
.offset
, GetStreamOffsetSize(frame
.offset
))) {
1904 LOG(DFATAL
) << "Writing offset size failed.";
1907 if (!no_stream_frame_length
) {
1908 if ((frame
.data
.size() > numeric_limits
<uint16
>::max()) ||
1909 !writer
->WriteUInt16(static_cast<uint16
>(frame
.data
.size()))) {
1910 LOG(DFATAL
) << "Writing stream frame length failed";
1915 if (!writer
->WriteBytes(frame
.data
.data(), frame
.data
.size())) {
1916 LOG(DFATAL
) << "Writing frame data failed.";
1922 void QuicFramer::set_version(const QuicVersion version
) {
1923 DCHECK(IsSupportedVersion(version
)) << QuicVersionToString(version
);
1924 quic_version_
= version
;
1927 bool QuicFramer::AppendAckFrameAndTypeByte(
1928 const QuicPacketHeader
& header
,
1929 const QuicAckFrame
& frame
,
1930 QuicDataWriter
* writer
) {
1931 AckFrameInfo ack_info
= GetAckFrameInfo(frame
);
1932 QuicPacketSequenceNumber ack_largest_observed
= frame
.largest_observed
;
1933 QuicSequenceNumberLength largest_observed_length
=
1934 GetMinSequenceNumberLength(ack_largest_observed
);
1935 QuicSequenceNumberLength missing_sequence_number_length
=
1936 GetMinSequenceNumberLength(ack_info
.max_delta
);
1937 // Determine whether we need to truncate ranges.
1938 size_t available_range_bytes
=
1939 writer
->capacity() - writer
->length() - kNumberOfRevivedPacketsSize
-
1940 kNumberOfNackRangesSize
- GetMinAckFrameSize(largest_observed_length
);
1941 size_t max_num_ranges
= available_range_bytes
/
1942 (missing_sequence_number_length
+ PACKET_1BYTE_SEQUENCE_NUMBER
);
1943 max_num_ranges
= min(kMaxNackRanges
, max_num_ranges
);
1944 bool truncated
= ack_info
.nack_ranges
.size() > max_num_ranges
;
1945 DVLOG_IF(1, truncated
) << "Truncating ack from "
1946 << ack_info
.nack_ranges
.size() << " ranges to "
1948 // Write out the type byte by setting the low order bits and doing shifts
1949 // to make room for the next bit flags to be set.
1950 // Whether there are any nacks.
1951 uint8 type_byte
= ack_info
.nack_ranges
.empty() ? 0 : kQuicHasNacksMask
;
1954 type_byte
<<= kQuicAckTruncatedShift
;
1955 type_byte
|= truncated
? kQuicAckTruncatedMask
: 0;
1957 // Largest observed sequence number length.
1958 type_byte
<<= kQuicSequenceNumberLengthShift
;
1959 type_byte
|= GetSequenceNumberFlags(largest_observed_length
);
1961 // Missing sequence number length.
1962 type_byte
<<= kQuicSequenceNumberLengthShift
;
1963 type_byte
|= GetSequenceNumberFlags(missing_sequence_number_length
);
1965 type_byte
|= kQuicFrameTypeAckMask
;
1967 if (!writer
->WriteUInt8(type_byte
)) {
1971 QuicPacketEntropyHash ack_entropy_hash
= frame
.entropy_hash
;
1972 NackRangeMap::reverse_iterator ack_iter
= ack_info
.nack_ranges
.rbegin();
1974 // Skip the nack ranges which the truncated ack won't include and set
1975 // a correct largest observed for the truncated ack.
1976 for (size_t i
= 1; i
< (ack_info
.nack_ranges
.size() - max_num_ranges
);
1980 // If the last range is followed by acks, include them.
1981 // If the last range is followed by another range, specify the end of the
1982 // range as the largest_observed.
1983 ack_largest_observed
= ack_iter
->first
- 1;
1984 // Also update the entropy so it matches the largest observed.
1985 ack_entropy_hash
= entropy_calculator_
->EntropyHash(ack_largest_observed
);
1989 if (!writer
->WriteUInt8(ack_entropy_hash
)) {
1993 if (!AppendPacketSequenceNumber(largest_observed_length
,
1994 ack_largest_observed
, writer
)) {
1998 uint64 delta_time_largest_observed_us
= kUFloat16MaxValue
;
1999 if (!frame
.delta_time_largest_observed
.IsInfinite()) {
2000 DCHECK_LE(0u, frame
.delta_time_largest_observed
.ToMicroseconds());
2001 delta_time_largest_observed_us
=
2002 frame
.delta_time_largest_observed
.ToMicroseconds();
2005 if (!writer
->WriteUFloat16(delta_time_largest_observed_us
)) {
2009 // Timestamp goes at the end of the required fields.
2011 if (!AppendTimestampToAckFrame(frame
, writer
)) {
2016 if (ack_info
.nack_ranges
.empty()) {
2020 const uint8 num_missing_ranges
=
2021 static_cast<uint8
>(min(ack_info
.nack_ranges
.size(), max_num_ranges
));
2022 if (!writer
->WriteBytes(&num_missing_ranges
, 1)) {
2026 int num_ranges_written
= 0;
2027 QuicPacketSequenceNumber last_sequence_written
= ack_largest_observed
;
2028 for (; ack_iter
!= ack_info
.nack_ranges
.rend(); ++ack_iter
) {
2029 // Calculate the delta to the last number in the range.
2030 QuicPacketSequenceNumber missing_delta
=
2031 last_sequence_written
- (ack_iter
->first
+ ack_iter
->second
);
2032 if (!AppendPacketSequenceNumber(missing_sequence_number_length
,
2033 missing_delta
, writer
)) {
2036 if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER
,
2037 ack_iter
->second
, writer
)) {
2040 // Subtract 1 so a missing_delta of 0 means an adjacent range.
2041 last_sequence_written
= ack_iter
->first
- 1;
2042 ++num_ranges_written
;
2044 DCHECK_EQ(num_missing_ranges
, num_ranges_written
);
2046 // Append revived packets.
2047 // If not all the revived packets fit, only mention the ones that do.
2048 uint8 num_revived_packets
=
2049 static_cast<uint8
>(min(frame
.revived_packets
.size(), kMaxRevivedPackets
));
2050 num_revived_packets
= static_cast<uint8
>(min(
2051 static_cast<size_t>(num_revived_packets
),
2052 (writer
->capacity() - writer
->length()) / largest_observed_length
));
2053 if (!writer
->WriteBytes(&num_revived_packets
, 1)) {
2057 SequenceNumberSet::const_iterator iter
= frame
.revived_packets
.begin();
2058 for (int i
= 0; i
< num_revived_packets
; ++i
, ++iter
) {
2059 LOG_IF(DFATAL
, !ContainsKey(frame
.missing_packets
, *iter
));
2060 if (!AppendPacketSequenceNumber(largest_observed_length
,
2069 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame
& frame
,
2070 QuicDataWriter
* writer
) {
2071 DCHECK_GE(numeric_limits
<uint8
>::max(), frame
.received_packet_times
.size());
2072 // num_received_packets is only 1 byte.
2073 if (frame
.received_packet_times
.size() > numeric_limits
<uint8
>::max()) {
2077 uint8 num_received_packets
= frame
.received_packet_times
.size();
2079 if (!writer
->WriteBytes(&num_received_packets
, 1)) {
2082 if (num_received_packets
== 0) {
2086 PacketTimeList::const_iterator it
= frame
.received_packet_times
.begin();
2087 QuicPacketSequenceNumber sequence_number
= it
->first
;
2088 QuicPacketSequenceNumber delta_from_largest_observed
=
2089 frame
.largest_observed
- sequence_number
;
2091 DCHECK_GE(numeric_limits
<uint8
>::max(), delta_from_largest_observed
);
2092 if (delta_from_largest_observed
> numeric_limits
<uint8
>::max()) {
2096 if (!writer
->WriteUInt8(
2097 delta_from_largest_observed
& k1ByteSequenceNumberMask
)) {
2101 // Use the lowest 4 bytes of the time delta from the creation_time_.
2102 const uint64 time_epoch_delta_us
= UINT64_C(1) << 32;
2103 uint32 time_delta_us
=
2104 static_cast<uint32
>(it
->second
.Subtract(creation_time_
).ToMicroseconds()
2105 & (time_epoch_delta_us
- 1));
2106 if (!writer
->WriteBytes(&time_delta_us
, sizeof(time_delta_us
))) {
2110 QuicTime prev_time
= it
->second
;
2112 for (++it
; it
!= frame
.received_packet_times
.end(); ++it
) {
2113 sequence_number
= it
->first
;
2114 delta_from_largest_observed
= frame
.largest_observed
- sequence_number
;
2116 if (delta_from_largest_observed
> numeric_limits
<uint8
>::max()) {
2120 if (!writer
->WriteUInt8(
2121 delta_from_largest_observed
& k1ByteSequenceNumberMask
)) {
2125 uint64 frame_time_delta_us
=
2126 it
->second
.Subtract(prev_time
).ToMicroseconds();
2127 prev_time
= it
->second
;
2128 if (!writer
->WriteUFloat16(frame_time_delta_us
)) {
2135 bool QuicFramer::AppendStopWaitingFrame(
2136 const QuicPacketHeader
& header
,
2137 const QuicStopWaitingFrame
& frame
,
2138 QuicDataWriter
* writer
) {
2139 DCHECK_GE(header
.packet_sequence_number
, frame
.least_unacked
);
2140 const QuicPacketSequenceNumber least_unacked_delta
=
2141 header
.packet_sequence_number
- frame
.least_unacked
;
2142 const QuicPacketSequenceNumber length_shift
=
2143 header
.public_header
.sequence_number_length
* 8;
2144 if (!writer
->WriteUInt8(frame
.entropy_hash
)) {
2145 LOG(DFATAL
) << " hash failed";
2149 if (least_unacked_delta
>> length_shift
> 0) {
2150 LOG(DFATAL
) << "sequence_number_length "
2151 << header
.public_header
.sequence_number_length
2152 << " is too small for least_unacked_delta: "
2153 << least_unacked_delta
;
2156 if (!AppendPacketSequenceNumber(header
.public_header
.sequence_number_length
,
2157 least_unacked_delta
, writer
)) {
2158 LOG(DFATAL
) << " seq failed: "
2159 << header
.public_header
.sequence_number_length
;
2166 bool QuicFramer::AppendRstStreamFrame(const QuicRstStreamFrame
& frame
,
2167 QuicDataWriter
* writer
) {
2168 if (!writer
->WriteUInt32(frame
.stream_id
)) {
2172 if (!writer
->WriteUInt64(frame
.byte_offset
)) {
2176 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2177 if (!writer
->WriteUInt32(error_code
)) {
2181 if (quic_version_
<= QUIC_VERSION_24
) {
2182 if (!writer
->WriteStringPiece16(frame
.error_details
)) {
2189 bool QuicFramer::AppendConnectionCloseFrame(
2190 const QuicConnectionCloseFrame
& frame
,
2191 QuicDataWriter
* writer
) {
2192 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2193 if (!writer
->WriteUInt32(error_code
)) {
2196 if (!writer
->WriteStringPiece16(frame
.error_details
)) {
2202 bool QuicFramer::AppendGoAwayFrame(const QuicGoAwayFrame
& frame
,
2203 QuicDataWriter
* writer
) {
2204 uint32 error_code
= static_cast<uint32
>(frame
.error_code
);
2205 if (!writer
->WriteUInt32(error_code
)) {
2208 uint32 stream_id
= static_cast<uint32
>(frame
.last_good_stream_id
);
2209 if (!writer
->WriteUInt32(stream_id
)) {
2212 if (!writer
->WriteStringPiece16(frame
.reason_phrase
)) {
2218 bool QuicFramer::AppendWindowUpdateFrame(const QuicWindowUpdateFrame
& frame
,
2219 QuicDataWriter
* writer
) {
2220 uint32 stream_id
= static_cast<uint32
>(frame
.stream_id
);
2221 if (!writer
->WriteUInt32(stream_id
)) {
2224 if (!writer
->WriteUInt64(frame
.byte_offset
)) {
2230 bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame
& frame
,
2231 QuicDataWriter
* writer
) {
2232 uint32 stream_id
= static_cast<uint32
>(frame
.stream_id
);
2233 if (!writer
->WriteUInt32(stream_id
)) {
2239 bool QuicFramer::RaiseError(QuicErrorCode error
) {
2240 DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error
)
2241 << " detail: " << detailed_error_
;
2243 visitor_
->OnError(this);
2244 reader_
.reset(nullptr);