| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "net/quic/quic_framer.h" |
| |
| #include "base/containers/hash_tables.h" |
| #include "base/stl_util.h" |
| #include "net/quic/crypto/crypto_framer.h" |
| #include "net/quic/crypto/crypto_handshake_message.h" |
| #include "net/quic/crypto/crypto_protocol.h" |
| #include "net/quic/crypto/quic_decrypter.h" |
| #include "net/quic/crypto/quic_encrypter.h" |
| #include "net/quic/quic_data_reader.h" |
| #include "net/quic/quic_data_writer.h" |
| #include "net/quic/quic_flags.h" |
| #include "net/quic/quic_socket_address_coder.h" |
| |
| using base::StringPiece; |
| using std::make_pair; |
| using std::map; |
| using std::max; |
| using std::min; |
| using std::numeric_limits; |
| using std::string; |
| |
| namespace net { |
| |
| namespace { |
| |
| // Mask to select the lowest 48 bits of a sequence number. |
| const QuicPacketSequenceNumber k6ByteSequenceNumberMask = |
| GG_UINT64_C(0x0000FFFFFFFFFFFF); |
| const QuicPacketSequenceNumber k4ByteSequenceNumberMask = |
| GG_UINT64_C(0x00000000FFFFFFFF); |
| const QuicPacketSequenceNumber k2ByteSequenceNumberMask = |
| GG_UINT64_C(0x000000000000FFFF); |
| const QuicPacketSequenceNumber k1ByteSequenceNumberMask = |
| GG_UINT64_C(0x00000000000000FF); |
| |
| const QuicConnectionId k1ByteConnectionIdMask = GG_UINT64_C(0x00000000000000FF); |
| const QuicConnectionId k4ByteConnectionIdMask = GG_UINT64_C(0x00000000FFFFFFFF); |
| |
| // Number of bits the sequence number length bits are shifted from the right |
| // edge of the public header. |
| const uint8 kPublicHeaderSequenceNumberShift = 4; |
| |
| // New Frame Types, QUIC v. >= 10: |
| // There are two interpretations for the Frame Type byte in the QUIC protocol, |
| // resulting in two Frame Types: Special Frame Types and Regular Frame Types. |
| // |
| // Regular Frame Types use the Frame Type byte simply. Currently defined |
| // Regular Frame Types are: |
| // Padding : 0b 00000000 (0x00) |
| // ResetStream : 0b 00000001 (0x01) |
| // ConnectionClose : 0b 00000010 (0x02) |
| // GoAway : 0b 00000011 (0x03) |
| // WindowUpdate : 0b 00000100 (0x04) |
| // Blocked : 0b 00000101 (0x05) |
| // |
| // Special Frame Types encode both a Frame Type and corresponding flags |
| // all in the Frame Type byte. Currently defined Special Frame Types are: |
| // Stream : 0b 1xxxxxxx |
| // Ack : 0b 01xxxxxx |
| // CongestionFeedback : 0b 001xxxxx |
| // |
| // Semantics of the flag bits above (the x bits) depends on the frame type. |
| |
| // Masks to determine if the frame type is a special use |
| // and for specific special frame types. |
| const uint8 kQuicFrameTypeSpecialMask = 0xE0; // 0b 11100000 |
| const uint8 kQuicFrameTypeStreamMask = 0x80; |
| const uint8 kQuicFrameTypeAckMask = 0x40; |
| const uint8 kQuicFrameTypeCongestionFeedbackMask = 0x20; |
| |
| // Stream frame relative shifts and masks for interpreting the stream flags. |
| // StreamID may be 1, 2, 3, or 4 bytes. |
| const uint8 kQuicStreamIdShift = 2; |
| const uint8 kQuicStreamIDLengthMask = 0x03; |
| |
| // Offset may be 0, 2, 3, 4, 5, 6, 7, 8 bytes. |
| const uint8 kQuicStreamOffsetShift = 3; |
| const uint8 kQuicStreamOffsetMask = 0x07; |
| |
| // Data length may be 0 or 2 bytes. |
| const uint8 kQuicStreamDataLengthShift = 1; |
| const uint8 kQuicStreamDataLengthMask = 0x01; |
| |
| // Fin bit may be set or not. |
| const uint8 kQuicStreamFinShift = 1; |
| const uint8 kQuicStreamFinMask = 0x01; |
| |
| // Sequence number size shift used in AckFrames. |
| const uint8 kQuicSequenceNumberLengthShift = 2; |
| |
| // Acks may be truncated. |
| const uint8 kQuicAckTruncatedShift = 1; |
| const uint8 kQuicAckTruncatedMask = 0x01; |
| |
| // Acks may not have any nacks. |
| const uint8 kQuicHasNacksMask = 0x01; |
| |
| // Returns the absolute value of the difference between |a| and |b|. |
| QuicPacketSequenceNumber Delta(QuicPacketSequenceNumber a, |
| QuicPacketSequenceNumber b) { |
| // Since these are unsigned numbers, we can't just return abs(a - b) |
| if (a < b) { |
| return b - a; |
| } |
| return a - b; |
| } |
| |
| QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target, |
| QuicPacketSequenceNumber a, |
| QuicPacketSequenceNumber b) { |
| return (Delta(target, a) < Delta(target, b)) ? a : b; |
| } |
| |
| QuicSequenceNumberLength ReadSequenceNumberLength(uint8 flags) { |
| switch (flags & PACKET_FLAGS_6BYTE_SEQUENCE) { |
| case PACKET_FLAGS_6BYTE_SEQUENCE: |
| return PACKET_6BYTE_SEQUENCE_NUMBER; |
| case PACKET_FLAGS_4BYTE_SEQUENCE: |
| return PACKET_4BYTE_SEQUENCE_NUMBER; |
| case PACKET_FLAGS_2BYTE_SEQUENCE: |
| return PACKET_2BYTE_SEQUENCE_NUMBER; |
| case PACKET_FLAGS_1BYTE_SEQUENCE: |
| return PACKET_1BYTE_SEQUENCE_NUMBER; |
| default: |
| LOG(DFATAL) << "Unreachable case statement."; |
| return PACKET_6BYTE_SEQUENCE_NUMBER; |
| } |
| } |
| |
| bool CanTruncate(const QuicFrame& frame, size_t free_bytes) { |
| if ((frame.type == ACK_FRAME || frame.type == CONNECTION_CLOSE_FRAME) && |
| free_bytes >= |
| QuicFramer::GetMinAckFrameSize(PACKET_6BYTE_SEQUENCE_NUMBER, |
| PACKET_6BYTE_SEQUENCE_NUMBER)) { |
| return true; |
| } |
| return false; |
| } |
| |
| } // namespace |
| |
| bool QuicFramerVisitorInterface::OnWindowUpdateFrame( |
| const QuicWindowUpdateFrame& frame) { |
| return true; |
| } |
| |
| bool QuicFramerVisitorInterface::OnBlockedFrame(const QuicBlockedFrame& frame) { |
| return true; |
| } |
| |
| QuicFramer::QuicFramer(const QuicVersionVector& supported_versions, |
| QuicTime creation_time, |
| bool is_server) |
| : visitor_(NULL), |
| fec_builder_(NULL), |
| entropy_calculator_(NULL), |
| error_(QUIC_NO_ERROR), |
| last_sequence_number_(0), |
| last_serialized_connection_id_(0), |
| supported_versions_(supported_versions), |
| decrypter_level_(ENCRYPTION_NONE), |
| alternative_decrypter_level_(ENCRYPTION_NONE), |
| alternative_decrypter_latch_(false), |
| is_server_(is_server), |
| validate_flags_(true), |
| creation_time_(creation_time) { |
| DCHECK(!supported_versions.empty()); |
| quic_version_ = supported_versions_[0]; |
| decrypter_.reset(QuicDecrypter::Create(kNULL)); |
| encrypter_[ENCRYPTION_NONE].reset( |
| QuicEncrypter::Create(kNULL)); |
| } |
| |
| QuicFramer::~QuicFramer() {} |
| |
| // static |
| size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id, |
| QuicStreamOffset offset, |
| bool last_frame_in_packet, |
| InFecGroup is_in_fec_group) { |
| bool no_stream_frame_length = last_frame_in_packet && |
| is_in_fec_group == NOT_IN_FEC_GROUP; |
| return kQuicFrameTypeSize + GetStreamIdSize(stream_id) + |
| GetStreamOffsetSize(offset) + |
| (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize); |
| } |
| |
| // static |
| size_t QuicFramer::GetMinAckFrameSize( |
| QuicSequenceNumberLength sequence_number_length, |
| QuicSequenceNumberLength largest_observed_length) { |
| return kQuicFrameTypeSize + kQuicEntropyHashSize + |
| largest_observed_length + kQuicDeltaTimeLargestObservedSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetStopWaitingFrameSize( |
| QuicSequenceNumberLength sequence_number_length) { |
| return kQuicFrameTypeSize + kQuicEntropyHashSize + |
| sequence_number_length; |
| } |
| |
| // static |
| size_t QuicFramer::GetMinRstStreamFrameSize() { |
| return kQuicFrameTypeSize + kQuicMaxStreamIdSize + |
| kQuicMaxStreamOffsetSize + kQuicErrorCodeSize + |
| kQuicErrorDetailsLengthSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetMinConnectionCloseFrameSize() { |
| return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetMinGoAwayFrameSize() { |
| return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize + |
| kQuicMaxStreamIdSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetWindowUpdateFrameSize() { |
| return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetBlockedFrameSize() { |
| return kQuicFrameTypeSize + kQuicMaxStreamIdSize; |
| } |
| |
| // static |
| size_t QuicFramer::GetStreamIdSize(QuicStreamId stream_id) { |
| // Sizes are 1 through 4 bytes. |
| for (int i = 1; i <= 4; ++i) { |
| stream_id >>= 8; |
| if (stream_id == 0) { |
| return i; |
| } |
| } |
| LOG(DFATAL) << "Failed to determine StreamIDSize."; |
| return 4; |
| } |
| |
| // static |
| size_t QuicFramer::GetStreamOffsetSize(QuicStreamOffset offset) { |
| // 0 is a special case. |
| if (offset == 0) { |
| return 0; |
| } |
| // 2 through 8 are the remaining sizes. |
| offset >>= 8; |
| for (int i = 2; i <= 8; ++i) { |
| offset >>= 8; |
| if (offset == 0) { |
| return i; |
| } |
| } |
| LOG(DFATAL) << "Failed to determine StreamOffsetSize."; |
| return 8; |
| } |
| |
| // static |
| size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) { |
| return kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + |
| number_versions * kQuicVersionSize; |
| } |
| |
| bool QuicFramer::IsSupportedVersion(const QuicVersion version) const { |
| for (size_t i = 0; i < supported_versions_.size(); ++i) { |
| if (version == supported_versions_[i]) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| size_t QuicFramer::GetSerializedFrameLength( |
| const QuicFrame& frame, |
| size_t free_bytes, |
| bool first_frame, |
| bool last_frame, |
| InFecGroup is_in_fec_group, |
| QuicSequenceNumberLength sequence_number_length) { |
| if (frame.type == PADDING_FRAME) { |
| // PADDING implies end of packet. |
| return free_bytes; |
| } |
| size_t frame_len = |
| ComputeFrameLength(frame, last_frame, is_in_fec_group, |
| sequence_number_length); |
| if (frame_len <= free_bytes) { |
| // Frame fits within packet. Note that acks may be truncated. |
| return frame_len; |
| } |
| // Only truncate the first frame in a packet, so if subsequent ones go |
| // over, stop including more frames. |
| if (!first_frame) { |
| return 0; |
| } |
| if (CanTruncate(frame, free_bytes)) { |
| // Truncate the frame so the packet will not exceed kMaxPacketSize. |
| // Note that we may not use every byte of the writer in this case. |
| DVLOG(1) << "Truncating large frame, free bytes: " << free_bytes; |
| return free_bytes; |
| } |
| if (!FLAGS_quic_allow_oversized_packets_for_test) { |
| return 0; |
| } |
| LOG(DFATAL) << "Packet size too small to fit frame."; |
| return frame_len; |
| } |
| |
| QuicFramer::AckFrameInfo::AckFrameInfo() : max_delta(0) {} |
| |
| QuicFramer::AckFrameInfo::~AckFrameInfo() {} |
| |
| QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash( |
| const QuicPacketHeader& header) const { |
| return header.entropy_flag << (header.packet_sequence_number % 8); |
| } |
| |
| SerializedPacket QuicFramer::BuildDataPacket( |
| const QuicPacketHeader& header, |
| const QuicFrames& frames, |
| size_t packet_size) { |
| QuicDataWriter writer(packet_size); |
| const SerializedPacket kNoPacket( |
| 0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL); |
| if (!AppendPacketHeader(header, &writer)) { |
| LOG(DFATAL) << "AppendPacketHeader failed"; |
| return kNoPacket; |
| } |
| |
| for (size_t i = 0; i < frames.size(); ++i) { |
| const QuicFrame& frame = frames[i]; |
| |
| // Determine if we should write stream frame length in header. |
| const bool no_stream_frame_length = |
| (header.is_in_fec_group == NOT_IN_FEC_GROUP) && |
| (i == frames.size() - 1); |
| if (!AppendTypeByte(frame, no_stream_frame_length, &writer)) { |
| LOG(DFATAL) << "AppendTypeByte failed"; |
| return kNoPacket; |
| } |
| |
| switch (frame.type) { |
| case PADDING_FRAME: |
| writer.WritePadding(); |
| break; |
| case STREAM_FRAME: |
| if (!AppendStreamFrame( |
| *frame.stream_frame, no_stream_frame_length, &writer)) { |
| LOG(DFATAL) << "AppendStreamFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case ACK_FRAME: |
| if (!AppendAckFrameAndTypeByte( |
| header, *frame.ack_frame, &writer)) { |
| LOG(DFATAL) << "AppendAckFrameAndTypeByte failed"; |
| return kNoPacket; |
| } |
| break; |
| case CONGESTION_FEEDBACK_FRAME: |
| if (!AppendCongestionFeedbackFrame( |
| *frame.congestion_feedback_frame, &writer)) { |
| LOG(DFATAL) << "AppendCongestionFeedbackFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case STOP_WAITING_FRAME: |
| if (!AppendStopWaitingFrame( |
| header, *frame.stop_waiting_frame, &writer)) { |
| LOG(DFATAL) << "AppendStopWaitingFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case PING_FRAME: |
| if (quic_version_ == QUIC_VERSION_16) { |
| LOG(DFATAL) << "Attempt to add a PingFrame in " |
| << QuicVersionToString(quic_version_); |
| return kNoPacket; |
| } |
| // Ping has no payload. |
| break; |
| case RST_STREAM_FRAME: |
| if (!AppendRstStreamFrame(*frame.rst_stream_frame, &writer)) { |
| LOG(DFATAL) << "AppendRstStreamFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case CONNECTION_CLOSE_FRAME: |
| if (!AppendConnectionCloseFrame( |
| *frame.connection_close_frame, &writer)) { |
| LOG(DFATAL) << "AppendConnectionCloseFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case GOAWAY_FRAME: |
| if (!AppendGoAwayFrame(*frame.goaway_frame, &writer)) { |
| LOG(DFATAL) << "AppendGoAwayFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case WINDOW_UPDATE_FRAME: |
| if (!AppendWindowUpdateFrame(*frame.window_update_frame, &writer)) { |
| LOG(DFATAL) << "AppendWindowUpdateFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| case BLOCKED_FRAME: |
| if (!AppendBlockedFrame(*frame.blocked_frame, &writer)) { |
| LOG(DFATAL) << "AppendBlockedFrame failed"; |
| return kNoPacket; |
| } |
| break; |
| default: |
| RaiseError(QUIC_INVALID_FRAME_DATA); |
| LOG(DFATAL) << "QUIC_INVALID_FRAME_DATA"; |
| return kNoPacket; |
| } |
| } |
| |
| // Save the length before writing, because take clears it. |
| const size_t len = writer.length(); |
| // Less than or equal because truncated acks end up with max_plaintex_size |
| // length, even though they're typically slightly shorter. |
| DCHECK_LE(len, packet_size); |
| QuicPacket* packet = QuicPacket::NewDataPacket( |
| writer.take(), len, true, header.public_header.connection_id_length, |
| header.public_header.version_flag, |
| header.public_header.sequence_number_length); |
| |
| if (fec_builder_) { |
| fec_builder_->OnBuiltFecProtectedPayload(header, |
| packet->FecProtectedData()); |
| } |
| |
| return SerializedPacket(header.packet_sequence_number, |
| header.public_header.sequence_number_length, packet, |
| GetPacketEntropyHash(header), NULL); |
| } |
| |
| SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header, |
| const QuicFecData& fec) { |
| DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group); |
| DCHECK_NE(0u, header.fec_group); |
| size_t len = GetPacketHeaderSize(header); |
| len += fec.redundancy.length(); |
| |
| QuicDataWriter writer(len); |
| const SerializedPacket kNoPacket( |
| 0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL); |
| if (!AppendPacketHeader(header, &writer)) { |
| LOG(DFATAL) << "AppendPacketHeader failed"; |
| return kNoPacket; |
| } |
| |
| if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) { |
| LOG(DFATAL) << "Failed to add FEC"; |
| return kNoPacket; |
| } |
| |
| return SerializedPacket( |
| header.packet_sequence_number, |
| header.public_header.sequence_number_length, |
| QuicPacket::NewFecPacket(writer.take(), len, true, |
| header.public_header.connection_id_length, |
| header.public_header.version_flag, |
| header.public_header.sequence_number_length), |
| GetPacketEntropyHash(header), NULL); |
| } |
| |
| // static |
| QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket( |
| const QuicPublicResetPacket& packet) { |
| DCHECK(packet.public_header.reset_flag); |
| |
| CryptoHandshakeMessage reset; |
| reset.set_tag(kPRST); |
| reset.SetValue(kRNON, packet.nonce_proof); |
| reset.SetValue(kRSEQ, packet.rejected_sequence_number); |
| if (!packet.client_address.address().empty()) { |
| // packet.client_address is non-empty. |
| QuicSocketAddressCoder address_coder(packet.client_address); |
| string serialized_address = address_coder.Encode(); |
| if (serialized_address.empty()) { |
| return NULL; |
| } |
| reset.SetStringPiece(kCADR, serialized_address); |
| } |
| const QuicData& reset_serialized = reset.GetSerialized(); |
| |
| size_t len = |
| kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length(); |
| QuicDataWriter writer(len); |
| |
| uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST | |
| PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID); |
| if (!writer.WriteUInt8(flags)) { |
| return NULL; |
| } |
| |
| if (!writer.WriteUInt64(packet.public_header.connection_id)) { |
| return NULL; |
| } |
| |
| if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) { |
| return NULL; |
| } |
| |
| return new QuicEncryptedPacket(writer.take(), len, true); |
| } |
| |
| QuicEncryptedPacket* QuicFramer::BuildVersionNegotiationPacket( |
| const QuicPacketPublicHeader& header, |
| const QuicVersionVector& supported_versions) { |
| DCHECK(header.version_flag); |
| size_t len = GetVersionNegotiationPacketSize(supported_versions.size()); |
| QuicDataWriter writer(len); |
| |
| uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION | |
| PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID); |
| if (!writer.WriteUInt8(flags)) { |
| return NULL; |
| } |
| |
| if (!writer.WriteUInt64(header.connection_id)) { |
| return NULL; |
| } |
| |
| for (size_t i = 0; i < supported_versions.size(); ++i) { |
| if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) { |
| return NULL; |
| } |
| } |
| |
| return new QuicEncryptedPacket(writer.take(), len, true); |
| } |
| |
| bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) { |
| DCHECK(!reader_.get()); |
| reader_.reset(new QuicDataReader(packet.data(), packet.length())); |
| |
| visitor_->OnPacket(); |
| |
| // First parse the public header. |
| QuicPacketPublicHeader public_header; |
| if (!ProcessPublicHeader(&public_header)) { |
| DLOG(WARNING) << "Unable to process public header."; |
| DCHECK_NE("", detailed_error_); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| |
| if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) { |
| // The visitor suppresses further processing of the packet. |
| reader_.reset(NULL); |
| return true; |
| } |
| |
| if (is_server_ && public_header.version_flag && |
| public_header.versions[0] != quic_version_) { |
| if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) { |
| reader_.reset(NULL); |
| return true; |
| } |
| } |
| |
| bool rv; |
| if (!is_server_ && public_header.version_flag) { |
| rv = ProcessVersionNegotiationPacket(&public_header); |
| } else if (public_header.reset_flag) { |
| rv = ProcessPublicResetPacket(public_header); |
| } else { |
| rv = ProcessDataPacket(public_header, packet); |
| } |
| |
| reader_.reset(NULL); |
| return rv; |
| } |
| |
| bool QuicFramer::ProcessVersionNegotiationPacket( |
| QuicPacketPublicHeader* public_header) { |
| DCHECK(!is_server_); |
| // Try reading at least once to raise error if the packet is invalid. |
| do { |
| QuicTag version; |
| if (!reader_->ReadBytes(&version, kQuicVersionSize)) { |
| set_detailed_error("Unable to read supported version in negotiation."); |
| return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET); |
| } |
| public_header->versions.push_back(QuicTagToQuicVersion(version)); |
| } while (!reader_->IsDoneReading()); |
| |
| visitor_->OnVersionNegotiationPacket(*public_header); |
| return true; |
| } |
| |
| bool QuicFramer::ProcessDataPacket( |
| const QuicPacketPublicHeader& public_header, |
| const QuicEncryptedPacket& packet) { |
| QuicPacketHeader header(public_header); |
| if (!ProcessPacketHeader(&header, packet)) { |
| DLOG(WARNING) << "Unable to process data packet header."; |
| return false; |
| } |
| |
| if (!visitor_->OnPacketHeader(header)) { |
| // The visitor suppresses further processing of the packet. |
| return true; |
| } |
| |
| if (packet.length() > kMaxPacketSize) { |
| DLOG(WARNING) << "Packet too large: " << packet.length(); |
| return RaiseError(QUIC_PACKET_TOO_LARGE); |
| } |
| |
| // Handle the payload. |
| if (!header.fec_flag) { |
| if (header.is_in_fec_group == IN_FEC_GROUP) { |
| StringPiece payload = reader_->PeekRemainingPayload(); |
| visitor_->OnFecProtectedPayload(payload); |
| } |
| if (!ProcessFrameData(header)) { |
| DCHECK_NE(QUIC_NO_ERROR, error_); // ProcessFrameData sets the error. |
| DLOG(WARNING) << "Unable to process frame data."; |
| return false; |
| } |
| } else { |
| QuicFecData fec_data; |
| fec_data.fec_group = header.fec_group; |
| fec_data.redundancy = reader_->ReadRemainingPayload(); |
| visitor_->OnFecData(fec_data); |
| } |
| |
| visitor_->OnPacketComplete(); |
| return true; |
| } |
| |
| bool QuicFramer::ProcessPublicResetPacket( |
| const QuicPacketPublicHeader& public_header) { |
| QuicPublicResetPacket packet(public_header); |
| |
| scoped_ptr<CryptoHandshakeMessage> reset( |
| CryptoFramer::ParseMessage(reader_->ReadRemainingPayload())); |
| if (!reset.get()) { |
| set_detailed_error("Unable to read reset message."); |
| return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); |
| } |
| if (reset->tag() != kPRST) { |
| set_detailed_error("Incorrect message tag."); |
| return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); |
| } |
| |
| if (reset->GetUint64(kRNON, &packet.nonce_proof) != QUIC_NO_ERROR) { |
| set_detailed_error("Unable to read nonce proof."); |
| return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); |
| } |
| // TODO(satyamshekhar): validate nonce to protect against DoS. |
| |
| if (reset->GetUint64(kRSEQ, &packet.rejected_sequence_number) != |
| QUIC_NO_ERROR) { |
| set_detailed_error("Unable to read rejected sequence number."); |
| return RaiseError(QUIC_INVALID_PUBLIC_RST_PACKET); |
| } |
| |
| StringPiece address; |
| if (reset->GetStringPiece(kCADR, &address)) { |
| QuicSocketAddressCoder address_coder; |
| if (address_coder.Decode(address.data(), address.length())) { |
| packet.client_address = IPEndPoint(address_coder.ip(), |
| address_coder.port()); |
| } |
| } |
| |
| visitor_->OnPublicResetPacket(packet); |
| return true; |
| } |
| |
| bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header, |
| StringPiece payload) { |
| DCHECK(!reader_.get()); |
| |
| visitor_->OnRevivedPacket(); |
| |
| header->entropy_hash = GetPacketEntropyHash(*header); |
| |
| if (!visitor_->OnPacketHeader(*header)) { |
| return true; |
| } |
| |
| if (payload.length() > kMaxPacketSize) { |
| set_detailed_error("Revived packet too large."); |
| return RaiseError(QUIC_PACKET_TOO_LARGE); |
| } |
| |
| reader_.reset(new QuicDataReader(payload.data(), payload.length())); |
| if (!ProcessFrameData(*header)) { |
| DCHECK_NE(QUIC_NO_ERROR, error_); // ProcessFrameData sets the error. |
| DLOG(WARNING) << "Unable to process frame data."; |
| return false; |
| } |
| |
| visitor_->OnPacketComplete(); |
| reader_.reset(NULL); |
| return true; |
| } |
| |
| bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header, |
| QuicDataWriter* writer) { |
| DVLOG(1) << "Appending header: " << header; |
| DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP); |
| uint8 public_flags = 0; |
| if (header.public_header.reset_flag) { |
| public_flags |= PACKET_PUBLIC_FLAGS_RST; |
| } |
| if (header.public_header.version_flag) { |
| public_flags |= PACKET_PUBLIC_FLAGS_VERSION; |
| } |
| |
| public_flags |= |
| GetSequenceNumberFlags(header.public_header.sequence_number_length) |
| << kPublicHeaderSequenceNumberShift; |
| |
| switch (header.public_header.connection_id_length) { |
| case PACKET_0BYTE_CONNECTION_ID: |
| if (!writer->WriteUInt8( |
| public_flags | PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID)) { |
| return false; |
| } |
| break; |
| case PACKET_1BYTE_CONNECTION_ID: |
| if (!writer->WriteUInt8( |
| public_flags | PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID)) { |
| return false; |
| } |
| if (!writer->WriteUInt8( |
| header.public_header.connection_id & k1ByteConnectionIdMask)) { |
| return false; |
| } |
| break; |
| case PACKET_4BYTE_CONNECTION_ID: |
| if (!writer->WriteUInt8( |
| public_flags | PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID)) { |
| return false; |
| } |
| if (!writer->WriteUInt32( |
| header.public_header.connection_id & k4ByteConnectionIdMask)) { |
| return false; |
| } |
| break; |
| case PACKET_8BYTE_CONNECTION_ID: |
| if (!writer->WriteUInt8( |
| public_flags | PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID)) { |
| return false; |
| } |
| if (!writer->WriteUInt64(header.public_header.connection_id)) { |
| return false; |
| } |
| break; |
| } |
| last_serialized_connection_id_ = header.public_header.connection_id; |
| |
| if (header.public_header.version_flag) { |
| DCHECK(!is_server_); |
| writer->WriteUInt32(QuicVersionToQuicTag(quic_version_)); |
| } |
| |
| if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length, |
| header.packet_sequence_number, writer)) { |
| return false; |
| } |
| |
| uint8 private_flags = 0; |
| if (header.entropy_flag) { |
| private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY; |
| } |
| if (header.is_in_fec_group == IN_FEC_GROUP) { |
| private_flags |= PACKET_PRIVATE_FLAGS_FEC_GROUP; |
| } |
| if (header.fec_flag) { |
| private_flags |= PACKET_PRIVATE_FLAGS_FEC; |
| } |
| if (!writer->WriteUInt8(private_flags)) { |
| return false; |
| } |
| |
| // The FEC group number is the sequence number of the first fec |
| // protected packet, or 0 if this packet is not protected. |
| if (header.is_in_fec_group == IN_FEC_GROUP) { |
| DCHECK_GE(header.packet_sequence_number, header.fec_group); |
| DCHECK_GT(255u, header.packet_sequence_number - header.fec_group); |
| // Offset from the current packet sequence number to the first fec |
| // protected packet. |
| uint8 first_fec_protected_packet_offset = |
| header.packet_sequence_number - header.fec_group; |
| if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire( |
| QuicSequenceNumberLength sequence_number_length, |
| QuicPacketSequenceNumber packet_sequence_number) const { |
| // The new sequence number might have wrapped to the next epoch, or |
| // it might have reverse wrapped to the previous epoch, or it might |
| // remain in the same epoch. Select the sequence number closest to the |
| // next expected sequence number, the previous sequence number plus 1. |
| |
| // epoch_delta is the delta between epochs the sequence number was serialized |
| // with, so the correct value is likely the same epoch as the last sequence |
| // number or an adjacent epoch. |
| const QuicPacketSequenceNumber epoch_delta = |
| GG_UINT64_C(1) << (8 * sequence_number_length); |
| QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1; |
| QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1); |
| QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta; |
| QuicPacketSequenceNumber next_epoch = epoch + epoch_delta; |
| |
| return ClosestTo(next_sequence_number, |
| epoch + packet_sequence_number, |
| ClosestTo(next_sequence_number, |
| prev_epoch + packet_sequence_number, |
| next_epoch + packet_sequence_number)); |
| } |
| |
| bool QuicFramer::ProcessPublicHeader( |
| QuicPacketPublicHeader* public_header) { |
| uint8 public_flags; |
| if (!reader_->ReadBytes(&public_flags, 1)) { |
| set_detailed_error("Unable to read public flags."); |
| return false; |
| } |
| |
| public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0; |
| public_header->version_flag = |
| (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0; |
| |
| if (validate_flags_ && |
| !public_header->version_flag && public_flags > PACKET_PUBLIC_FLAGS_MAX) { |
| set_detailed_error("Illegal public flags value."); |
| return false; |
| } |
| |
| if (public_header->reset_flag && public_header->version_flag) { |
| set_detailed_error("Got version flag in reset packet"); |
| return false; |
| } |
| |
| switch (public_flags & PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID) { |
| case PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID: |
| if (!reader_->ReadUInt64(&public_header->connection_id)) { |
| set_detailed_error("Unable to read ConnectionId."); |
| return false; |
| } |
| public_header->connection_id_length = PACKET_8BYTE_CONNECTION_ID; |
| break; |
| case PACKET_PUBLIC_FLAGS_4BYTE_CONNECTION_ID: |
| // If the connection_id is truncated, expect to read the last serialized |
| // connection_id. |
| if (!reader_->ReadBytes(&public_header->connection_id, |
| PACKET_4BYTE_CONNECTION_ID)) { |
| set_detailed_error("Unable to read ConnectionId."); |
| return false; |
| } |
| if ((public_header->connection_id & k4ByteConnectionIdMask) != |
| (last_serialized_connection_id_ & k4ByteConnectionIdMask)) { |
| set_detailed_error("Truncated 4 byte ConnectionId does not match " |
| "previous connection_id."); |
| return false; |
| } |
| public_header->connection_id_length = PACKET_4BYTE_CONNECTION_ID; |
| public_header->connection_id = last_serialized_connection_id_; |
| break; |
| case PACKET_PUBLIC_FLAGS_1BYTE_CONNECTION_ID: |
| if (!reader_->ReadBytes(&public_header->connection_id, |
| PACKET_1BYTE_CONNECTION_ID)) { |
| set_detailed_error("Unable to read ConnectionId."); |
| return false; |
| } |
| if ((public_header->connection_id & k1ByteConnectionIdMask) != |
| (last_serialized_connection_id_ & k1ByteConnectionIdMask)) { |
| set_detailed_error("Truncated 1 byte ConnectionId does not match " |
| "previous connection_id."); |
| return false; |
| } |
| public_header->connection_id_length = PACKET_1BYTE_CONNECTION_ID; |
| public_header->connection_id = last_serialized_connection_id_; |
| break; |
| case PACKET_PUBLIC_FLAGS_0BYTE_CONNECTION_ID: |
| public_header->connection_id_length = PACKET_0BYTE_CONNECTION_ID; |
| public_header->connection_id = last_serialized_connection_id_; |
| break; |
| } |
| |
| public_header->sequence_number_length = |
| ReadSequenceNumberLength( |
| public_flags >> kPublicHeaderSequenceNumberShift); |
| |
| // Read the version only if the packet is from the client. |
| // version flag from the server means version negotiation packet. |
| if (public_header->version_flag && is_server_) { |
| QuicTag version_tag; |
| if (!reader_->ReadUInt32(&version_tag)) { |
| set_detailed_error("Unable to read protocol version."); |
| return false; |
| } |
| |
| // If the version from the new packet is the same as the version of this |
| // framer, then the public flags should be set to something we understand. |
| // If not, this raises an error. |
| QuicVersion version = QuicTagToQuicVersion(version_tag); |
| if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) { |
| set_detailed_error("Illegal public flags value."); |
| return false; |
| } |
| public_header->versions.push_back(version); |
| } |
| return true; |
| } |
| |
| // static |
| QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength( |
| QuicPacketSequenceNumber sequence_number) { |
| if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) { |
| return PACKET_1BYTE_SEQUENCE_NUMBER; |
| } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) { |
| return PACKET_2BYTE_SEQUENCE_NUMBER; |
| } else if (sequence_number < |
| GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) { |
| return PACKET_4BYTE_SEQUENCE_NUMBER; |
| } else { |
| return PACKET_6BYTE_SEQUENCE_NUMBER; |
| } |
| } |
| |
| // static |
| uint8 QuicFramer::GetSequenceNumberFlags( |
| QuicSequenceNumberLength sequence_number_length) { |
| switch (sequence_number_length) { |
| case PACKET_1BYTE_SEQUENCE_NUMBER: |
| return PACKET_FLAGS_1BYTE_SEQUENCE; |
| case PACKET_2BYTE_SEQUENCE_NUMBER: |
| return PACKET_FLAGS_2BYTE_SEQUENCE; |
| case PACKET_4BYTE_SEQUENCE_NUMBER: |
| return PACKET_FLAGS_4BYTE_SEQUENCE; |
| case PACKET_6BYTE_SEQUENCE_NUMBER: |
| return PACKET_FLAGS_6BYTE_SEQUENCE; |
| default: |
| LOG(DFATAL) << "Unreachable case statement."; |
| return PACKET_FLAGS_6BYTE_SEQUENCE; |
| } |
| } |
| |
| // static |
| QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo( |
| const QuicAckFrame& frame) { |
| AckFrameInfo ack_info; |
| if (!frame.missing_packets.empty()) { |
| DCHECK_GE(frame.largest_observed, *frame.missing_packets.rbegin()); |
| size_t cur_range_length = 0; |
| SequenceNumberSet::const_iterator iter = frame.missing_packets.begin(); |
| QuicPacketSequenceNumber last_missing = *iter; |
| ++iter; |
| for (; iter != frame.missing_packets.end(); ++iter) { |
| if (cur_range_length != numeric_limits<uint8>::max() && |
| *iter == (last_missing + 1)) { |
| ++cur_range_length; |
| } else { |
| ack_info.nack_ranges[last_missing - cur_range_length] = |
| cur_range_length; |
| cur_range_length = 0; |
| } |
| ack_info.max_delta = max(ack_info.max_delta, *iter - last_missing); |
| last_missing = *iter; |
| } |
| // Include the last nack range. |
| ack_info.nack_ranges[last_missing - cur_range_length] = cur_range_length; |
| // Include the range to the largest observed. |
| ack_info.max_delta = max(ack_info.max_delta, |
| frame.largest_observed - last_missing); |
| } |
| return ack_info; |
| } |
| |
| bool QuicFramer::ProcessPacketHeader( |
| QuicPacketHeader* header, |
| const QuicEncryptedPacket& packet) { |
| if (!ProcessPacketSequenceNumber(header->public_header.sequence_number_length, |
| &header->packet_sequence_number)) { |
| set_detailed_error("Unable to read sequence number."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| |
| if (header->packet_sequence_number == 0u) { |
| set_detailed_error("Packet sequence numbers cannot be 0."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| |
| if (!visitor_->OnUnauthenticatedHeader(*header)) { |
| return false; |
| } |
| |
| if (!DecryptPayload(*header, packet)) { |
| set_detailed_error("Unable to decrypt payload."); |
| return RaiseError(QUIC_DECRYPTION_FAILURE); |
| } |
| |
| uint8 private_flags; |
| if (!reader_->ReadBytes(&private_flags, 1)) { |
| set_detailed_error("Unable to read private flags."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| |
| if (private_flags > PACKET_PRIVATE_FLAGS_MAX) { |
| set_detailed_error("Illegal private flags value."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| |
| header->entropy_flag = (private_flags & PACKET_PRIVATE_FLAGS_ENTROPY) != 0; |
| header->fec_flag = (private_flags & PACKET_PRIVATE_FLAGS_FEC) != 0; |
| |
| if ((private_flags & PACKET_PRIVATE_FLAGS_FEC_GROUP) != 0) { |
| header->is_in_fec_group = IN_FEC_GROUP; |
| uint8 first_fec_protected_packet_offset; |
| if (!reader_->ReadBytes(&first_fec_protected_packet_offset, 1)) { |
| set_detailed_error("Unable to read first fec protected packet offset."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| if (first_fec_protected_packet_offset >= header->packet_sequence_number) { |
| set_detailed_error("First fec protected packet offset must be less " |
| "than the sequence number."); |
| return RaiseError(QUIC_INVALID_PACKET_HEADER); |
| } |
| header->fec_group = |
| header->packet_sequence_number - first_fec_protected_packet_offset; |
| } |
| |
| header->entropy_hash = GetPacketEntropyHash(*header); |
| // Set the last sequence number after we have decrypted the packet |
| // so we are confident is not attacker controlled. |
| last_sequence_number_ = header->packet_sequence_number; |
| return true; |
| } |
| |
| bool QuicFramer::ProcessPacketSequenceNumber( |
| QuicSequenceNumberLength sequence_number_length, |
| QuicPacketSequenceNumber* sequence_number) { |
| QuicPacketSequenceNumber wire_sequence_number = 0u; |
| if (!reader_->ReadBytes(&wire_sequence_number, sequence_number_length)) { |
| return false; |
| } |
| |
| // TODO(ianswett): Explore the usefulness of trying multiple sequence numbers |
| // in case the first guess is incorrect. |
| *sequence_number = |
| CalculatePacketSequenceNumberFromWire(sequence_number_length, |
| wire_sequence_number); |
| return true; |
| } |
| |
| bool QuicFramer::ProcessFrameData(const QuicPacketHeader& header) { |
| if (reader_->IsDoneReading()) { |
| set_detailed_error("Packet has no frames."); |
| return RaiseError(QUIC_MISSING_PAYLOAD); |
| } |
| while (!reader_->IsDoneReading()) { |
| uint8 frame_type; |
| if (!reader_->ReadBytes(&frame_type, 1)) { |
| set_detailed_error("Unable to read frame type."); |
| return RaiseError(QUIC_INVALID_FRAME_DATA); |
| } |
| |
| if (frame_type & kQuicFrameTypeSpecialMask) { |
| // Stream Frame |
| if (frame_type & kQuicFrameTypeStreamMask) { |
| QuicStreamFrame frame; |
| if (!ProcessStreamFrame(frame_type, &frame)) { |
| return RaiseError(QUIC_INVALID_STREAM_DATA); |
| } |
| if (!visitor_->OnStreamFrame(frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| // Ack Frame |
| if (frame_type & kQuicFrameTypeAckMask) { |
| QuicAckFrame frame; |
| if (!ProcessAckFrame(frame_type, &frame)) { |
| return RaiseError(QUIC_INVALID_ACK_DATA); |
| } |
| if (!visitor_->OnAckFrame(frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| // Congestion Feedback Frame |
| if (frame_type & kQuicFrameTypeCongestionFeedbackMask) { |
| QuicCongestionFeedbackFrame frame; |
| if (!ProcessQuicCongestionFeedbackFrame(&frame)) { |
| return RaiseError(QUIC_INVALID_CONGESTION_FEEDBACK_DATA); |
| } |
| if (!visitor_->OnCongestionFeedbackFrame(frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| // This was a special frame type that did not match any |
| // of the known ones. Error. |
| set_detailed_error("Illegal frame type."); |
| DLOG(WARNING) << "Illegal frame type: " |
| << static_cast<int>(frame_type); |
| return RaiseError(QUIC_INVALID_FRAME_DATA); |
| } |
| |
| switch (frame_type) { |
| case PADDING_FRAME: |
| // We're done with the packet. |
| return true; |
| |
| case RST_STREAM_FRAME: { |
| QuicRstStreamFrame frame; |
| if (!ProcessRstStreamFrame(&frame)) { |
| return RaiseError(QUIC_INVALID_RST_STREAM_DATA); |
| } |
| if (!visitor_->OnRstStreamFrame(frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| case CONNECTION_CLOSE_FRAME: { |
| QuicConnectionCloseFrame frame; |
| if (!ProcessConnectionCloseFrame(&frame)) { |
| return RaiseError(QUIC_INVALID_CONNECTION_CLOSE_DATA); |
| } |
| |
| if (!visitor_->OnConnectionCloseFrame(frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| case GOAWAY_FRAME: { |
| QuicGoAwayFrame goaway_frame; |
| if (!ProcessGoAwayFrame(&goaway_frame)) { |
| return RaiseError(QUIC_INVALID_GOAWAY_DATA); |
| } |
| if (!visitor_->OnGoAwayFrame(goaway_frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| case WINDOW_UPDATE_FRAME: { |
| QuicWindowUpdateFrame window_update_frame; |
| if (!ProcessWindowUpdateFrame(&window_update_frame)) { |
| return RaiseError(QUIC_INVALID_WINDOW_UPDATE_DATA); |
| } |
| if (!visitor_->OnWindowUpdateFrame(window_update_frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| case BLOCKED_FRAME: { |
| QuicBlockedFrame blocked_frame; |
| if (!ProcessBlockedFrame(&blocked_frame)) { |
| return RaiseError(QUIC_INVALID_BLOCKED_DATA); |
| } |
| if (!visitor_->OnBlockedFrame(blocked_frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| case STOP_WAITING_FRAME: { |
| QuicStopWaitingFrame stop_waiting_frame; |
| if (!ProcessStopWaitingFrame(header, &stop_waiting_frame)) { |
| return RaiseError(QUIC_INVALID_STOP_WAITING_DATA); |
| } |
| if (!visitor_->OnStopWaitingFrame(stop_waiting_frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| case PING_FRAME: { |
| if (quic_version_ == QUIC_VERSION_16) { |
| LOG(DFATAL) << "Trying to read a Ping in " |
| << QuicVersionToString(quic_version_); |
| return RaiseError(QUIC_INTERNAL_ERROR); |
| } |
| // Ping has no payload. |
| QuicPingFrame ping_frame; |
| if (!visitor_->OnPingFrame(ping_frame)) { |
| DVLOG(1) << "Visitor asked to stop further processing."; |
| // Returning true since there was no parsing error. |
| return true; |
| } |
| continue; |
| } |
| |
| default: |
| set_detailed_error("Illegal frame type."); |
| DLOG(WARNING) << "Illegal frame type: " |
| << static_cast<int>(frame_type); |
| return RaiseError(QUIC_INVALID_FRAME_DATA); |
| } |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessStreamFrame(uint8 frame_type, |
| QuicStreamFrame* frame) { |
| uint8 stream_flags = frame_type; |
| |
| stream_flags &= ~kQuicFrameTypeStreamMask; |
| |
| // Read from right to left: StreamID, Offset, Data Length, Fin. |
| const uint8 stream_id_length = (stream_flags & kQuicStreamIDLengthMask) + 1; |
| stream_flags >>= kQuicStreamIdShift; |
| |
| uint8 offset_length = (stream_flags & kQuicStreamOffsetMask); |
| // There is no encoding for 1 byte, only 0 and 2 through 8. |
| if (offset_length > 0) { |
| offset_length += 1; |
| } |
| stream_flags >>= kQuicStreamOffsetShift; |
| |
| bool has_data_length = |
| (stream_flags & kQuicStreamDataLengthMask) == kQuicStreamDataLengthMask; |
| stream_flags >>= kQuicStreamDataLengthShift; |
| |
| frame->fin = (stream_flags & kQuicStreamFinMask) == kQuicStreamFinShift; |
| |
| frame->stream_id = 0; |
| if (!reader_->ReadBytes(&frame->stream_id, stream_id_length)) { |
| set_detailed_error("Unable to read stream_id."); |
| return false; |
| } |
| |
| frame->offset = 0; |
| if (!reader_->ReadBytes(&frame->offset, offset_length)) { |
| set_detailed_error("Unable to read offset."); |
| return false; |
| } |
| |
| StringPiece frame_data; |
| if (has_data_length) { |
| if (!reader_->ReadStringPiece16(&frame_data)) { |
| set_detailed_error("Unable to read frame data."); |
| return false; |
| } |
| } else { |
| if (!reader_->ReadStringPiece(&frame_data, reader_->BytesRemaining())) { |
| set_detailed_error("Unable to read frame data."); |
| return false; |
| } |
| } |
| // Point frame to the right data. |
| frame->data.Clear(); |
| if (!frame_data.empty()) { |
| frame->data.Append(const_cast<char*>(frame_data.data()), frame_data.size()); |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessAckFrame(uint8 frame_type, QuicAckFrame* ack_frame) { |
| // Determine the three lengths from the frame type: largest observed length, |
| // missing sequence number length, and missing range length. |
| const QuicSequenceNumberLength missing_sequence_number_length = |
| ReadSequenceNumberLength(frame_type); |
| frame_type >>= kQuicSequenceNumberLengthShift; |
| const QuicSequenceNumberLength largest_observed_sequence_number_length = |
| ReadSequenceNumberLength(frame_type); |
| frame_type >>= kQuicSequenceNumberLengthShift; |
| ack_frame->is_truncated = frame_type & kQuicAckTruncatedMask; |
| frame_type >>= kQuicAckTruncatedShift; |
| bool has_nacks = frame_type & kQuicHasNacksMask; |
| |
| if (!reader_->ReadBytes(&ack_frame->entropy_hash, 1)) { |
| set_detailed_error("Unable to read entropy hash for received packets."); |
| return false; |
| } |
| |
| if (!reader_->ReadBytes(&ack_frame->largest_observed, |
| largest_observed_sequence_number_length)) { |
| set_detailed_error("Unable to read largest observed."); |
| return false; |
| } |
| |
| uint64 delta_time_largest_observed_us; |
| if (!reader_->ReadUFloat16(&delta_time_largest_observed_us)) { |
| set_detailed_error("Unable to read delta time largest observed."); |
| return false; |
| } |
| |
| if (delta_time_largest_observed_us == kUFloat16MaxValue) { |
| ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite(); |
| } else { |
| ack_frame->delta_time_largest_observed = |
| QuicTime::Delta::FromMicroseconds(delta_time_largest_observed_us); |
| } |
| |
| if (!has_nacks) { |
| return true; |
| } |
| |
| uint8 num_missing_ranges; |
| if (!reader_->ReadBytes(&num_missing_ranges, 1)) { |
| set_detailed_error("Unable to read num missing packet ranges."); |
| return false; |
| } |
| |
| QuicPacketSequenceNumber last_sequence_number = ack_frame->largest_observed; |
| for (size_t i = 0; i < num_missing_ranges; ++i) { |
| QuicPacketSequenceNumber missing_delta = 0; |
| if (!reader_->ReadBytes(&missing_delta, missing_sequence_number_length)) { |
| set_detailed_error("Unable to read missing sequence number delta."); |
| return false; |
| } |
| last_sequence_number -= missing_delta; |
| QuicPacketSequenceNumber range_length = 0; |
| if (!reader_->ReadBytes(&range_length, PACKET_1BYTE_SEQUENCE_NUMBER)) { |
| set_detailed_error("Unable to read missing sequence number range."); |
| return false; |
| } |
| for (size_t i = 0; i <= range_length; ++i) { |
| ack_frame->missing_packets.insert(last_sequence_number - i); |
| } |
| // Subtract an extra 1 to ensure ranges are represented efficiently and |
| // can't overlap by 1 sequence number. This allows a missing_delta of 0 |
| // to represent an adjacent nack range. |
| last_sequence_number -= (range_length + 1); |
| } |
| |
| // Parse the revived packets list. |
| uint8 num_revived_packets; |
| if (!reader_->ReadBytes(&num_revived_packets, 1)) { |
| set_detailed_error("Unable to read num revived packets."); |
| return false; |
| } |
| |
| for (size_t i = 0; i < num_revived_packets; ++i) { |
| QuicPacketSequenceNumber revived_packet = 0; |
| if (!reader_->ReadBytes(&revived_packet, |
| largest_observed_sequence_number_length)) { |
| set_detailed_error("Unable to read revived packet."); |
| return false; |
| } |
| |
| ack_frame->revived_packets.insert(revived_packet); |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessStopWaitingFrame(const QuicPacketHeader& header, |
| QuicStopWaitingFrame* stop_waiting) { |
| if (!reader_->ReadBytes(&stop_waiting->entropy_hash, 1)) { |
| set_detailed_error("Unable to read entropy hash for sent packets."); |
| return false; |
| } |
| |
| QuicPacketSequenceNumber least_unacked_delta = 0; |
| if (!reader_->ReadBytes(&least_unacked_delta, |
| header.public_header.sequence_number_length)) { |
| set_detailed_error("Unable to read least unacked delta."); |
| return false; |
| } |
| DCHECK_GE(header.packet_sequence_number, least_unacked_delta); |
| stop_waiting->least_unacked = |
| header.packet_sequence_number - least_unacked_delta; |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessQuicCongestionFeedbackFrame( |
| QuicCongestionFeedbackFrame* frame) { |
| uint8 feedback_type; |
| if (!reader_->ReadBytes(&feedback_type, 1)) { |
| set_detailed_error("Unable to read congestion feedback type."); |
| return false; |
| } |
| frame->type = |
| static_cast<CongestionFeedbackType>(feedback_type); |
| |
| switch (frame->type) { |
| case kTimestamp: { |
| set_detailed_error("Timestamp feedback not supported."); |
| return false; |
| } |
| case kTCP: { |
| CongestionFeedbackMessageTCP* tcp = &frame->tcp; |
| uint16 receive_window = 0; |
| if (!reader_->ReadUInt16(&receive_window)) { |
| set_detailed_error("Unable to read receive window."); |
| return false; |
| } |
| // Simple bit packing, don't send the 4 least significant bits. |
| tcp->receive_window = static_cast<QuicByteCount>(receive_window) << 4; |
| break; |
| } |
| default: |
| set_detailed_error("Illegal congestion feedback type."); |
| DLOG(WARNING) << "Illegal congestion feedback type: " |
| << frame->type; |
| return RaiseError(QUIC_INVALID_FRAME_DATA); |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessRstStreamFrame(QuicRstStreamFrame* frame) { |
| if (!reader_->ReadUInt32(&frame->stream_id)) { |
| set_detailed_error("Unable to read stream_id."); |
| return false; |
| } |
| |
| if (!reader_->ReadUInt64(&frame->byte_offset)) { |
| set_detailed_error("Unable to read rst stream sent byte offset."); |
| return false; |
| } |
| |
| uint32 error_code; |
| if (!reader_->ReadUInt32(&error_code)) { |
| set_detailed_error("Unable to read rst stream error code."); |
| return false; |
| } |
| |
| if (error_code >= QUIC_STREAM_LAST_ERROR || |
| error_code < QUIC_STREAM_NO_ERROR) { |
| set_detailed_error("Invalid rst stream error code."); |
| return false; |
| } |
| |
| frame->error_code = static_cast<QuicRstStreamErrorCode>(error_code); |
| |
| StringPiece error_details; |
| if (!reader_->ReadStringPiece16(&error_details)) { |
| set_detailed_error("Unable to read rst stream error details."); |
| return false; |
| } |
| frame->error_details = error_details.as_string(); |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessConnectionCloseFrame(QuicConnectionCloseFrame* frame) { |
| uint32 error_code; |
| if (!reader_->ReadUInt32(&error_code)) { |
| set_detailed_error("Unable to read connection close error code."); |
| return false; |
| } |
| |
| if (error_code >= QUIC_LAST_ERROR || |
| error_code < QUIC_NO_ERROR) { |
| set_detailed_error("Invalid error code."); |
| return false; |
| } |
| |
| frame->error_code = static_cast<QuicErrorCode>(error_code); |
| |
| StringPiece error_details; |
| if (!reader_->ReadStringPiece16(&error_details)) { |
| set_detailed_error("Unable to read connection close error details."); |
| return false; |
| } |
| frame->error_details = error_details.as_string(); |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessGoAwayFrame(QuicGoAwayFrame* frame) { |
| uint32 error_code; |
| if (!reader_->ReadUInt32(&error_code)) { |
| set_detailed_error("Unable to read go away error code."); |
| return false; |
| } |
| frame->error_code = static_cast<QuicErrorCode>(error_code); |
| |
| if (error_code >= QUIC_LAST_ERROR || |
| error_code < QUIC_NO_ERROR) { |
| set_detailed_error("Invalid error code."); |
| return false; |
| } |
| |
| uint32 stream_id; |
| if (!reader_->ReadUInt32(&stream_id)) { |
| set_detailed_error("Unable to read last good stream id."); |
| return false; |
| } |
| frame->last_good_stream_id = static_cast<QuicStreamId>(stream_id); |
| |
| StringPiece reason_phrase; |
| if (!reader_->ReadStringPiece16(&reason_phrase)) { |
| set_detailed_error("Unable to read goaway reason."); |
| return false; |
| } |
| frame->reason_phrase = reason_phrase.as_string(); |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessWindowUpdateFrame(QuicWindowUpdateFrame* frame) { |
| if (!reader_->ReadUInt32(&frame->stream_id)) { |
| set_detailed_error("Unable to read stream_id."); |
| return false; |
| } |
| |
| if (!reader_->ReadUInt64(&frame->byte_offset)) { |
| set_detailed_error("Unable to read window byte_offset."); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::ProcessBlockedFrame(QuicBlockedFrame* frame) { |
| if (!reader_->ReadUInt32(&frame->stream_id)) { |
| set_detailed_error("Unable to read stream_id."); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // static |
| StringPiece QuicFramer::GetAssociatedDataFromEncryptedPacket( |
| const QuicEncryptedPacket& encrypted, |
| QuicConnectionIdLength connection_id_length, |
| bool includes_version, |
| QuicSequenceNumberLength sequence_number_length) { |
| return StringPiece( |
| encrypted.data() + kStartOfHashData, GetStartOfEncryptedData( |
| connection_id_length, includes_version, sequence_number_length) |
| - kStartOfHashData); |
| } |
| |
| void QuicFramer::SetDecrypter(QuicDecrypter* decrypter, |
| EncryptionLevel level) { |
| DCHECK(alternative_decrypter_.get() == NULL); |
| DCHECK_GE(level, decrypter_level_); |
| decrypter_.reset(decrypter); |
| decrypter_level_ = level; |
| } |
| |
| void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter, |
| EncryptionLevel level, |
| bool latch_once_used) { |
| alternative_decrypter_.reset(decrypter); |
| alternative_decrypter_level_ = level; |
| alternative_decrypter_latch_ = latch_once_used; |
| } |
| |
| const QuicDecrypter* QuicFramer::decrypter() const { |
| return decrypter_.get(); |
| } |
| |
| const QuicDecrypter* QuicFramer::alternative_decrypter() const { |
| return alternative_decrypter_.get(); |
| } |
| |
| void QuicFramer::SetEncrypter(EncryptionLevel level, |
| QuicEncrypter* encrypter) { |
| DCHECK_GE(level, 0); |
| DCHECK_LT(level, NUM_ENCRYPTION_LEVELS); |
| encrypter_[level].reset(encrypter); |
| } |
| |
| const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const { |
| DCHECK_GE(level, 0); |
| DCHECK_LT(level, NUM_ENCRYPTION_LEVELS); |
| DCHECK(encrypter_[level].get() != NULL); |
| return encrypter_[level].get(); |
| } |
| |
| QuicEncryptedPacket* QuicFramer::EncryptPacket( |
| EncryptionLevel level, |
| QuicPacketSequenceNumber packet_sequence_number, |
| const QuicPacket& packet) { |
| DCHECK(encrypter_[level].get() != NULL); |
| |
| scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket( |
| packet_sequence_number, packet.AssociatedData(), packet.Plaintext())); |
| if (out.get() == NULL) { |
| RaiseError(QUIC_ENCRYPTION_FAILURE); |
| return NULL; |
| } |
| StringPiece header_data = packet.BeforePlaintext(); |
| size_t len = header_data.length() + out->length(); |
| char* buffer = new char[len]; |
| // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt(). |
| memcpy(buffer, header_data.data(), header_data.length()); |
| memcpy(buffer + header_data.length(), out->data(), out->length()); |
| return new QuicEncryptedPacket(buffer, len, true); |
| } |
| |
| size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) { |
| // In order to keep the code simple, we don't have the current encryption |
| // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12. |
| size_t min_plaintext_size = ciphertext_size; |
| |
| for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; i++) { |
| if (encrypter_[i].get() != NULL) { |
| size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size); |
| if (size < min_plaintext_size) { |
| min_plaintext_size = size; |
| } |
| } |
| } |
| |
| return min_plaintext_size; |
| } |
| |
| bool QuicFramer::DecryptPayload(const QuicPacketHeader& header, |
| const QuicEncryptedPacket& packet) { |
| StringPiece encrypted; |
| if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) { |
| return false; |
| } |
| DCHECK(decrypter_.get() != NULL); |
| decrypted_.reset(decrypter_->DecryptPacket( |
| header.packet_sequence_number, |
| GetAssociatedDataFromEncryptedPacket( |
| packet, |
| header.public_header.connection_id_length, |
| header.public_header.version_flag, |
| header.public_header.sequence_number_length), |
| encrypted)); |
| if (decrypted_.get() != NULL) { |
| visitor_->OnDecryptedPacket(decrypter_level_); |
| } else if (alternative_decrypter_.get() != NULL) { |
| decrypted_.reset(alternative_decrypter_->DecryptPacket( |
| header.packet_sequence_number, |
| GetAssociatedDataFromEncryptedPacket( |
| packet, |
| header.public_header.connection_id_length, |
| header.public_header.version_flag, |
| header.public_header.sequence_number_length), |
| encrypted)); |
| if (decrypted_.get() != NULL) { |
| visitor_->OnDecryptedPacket(alternative_decrypter_level_); |
| if (alternative_decrypter_latch_) { |
| // Switch to the alternative decrypter and latch so that we cannot |
| // switch back. |
| decrypter_.reset(alternative_decrypter_.release()); |
| decrypter_level_ = alternative_decrypter_level_; |
| alternative_decrypter_level_ = ENCRYPTION_NONE; |
| } else { |
| // Switch the alternative decrypter so that we use it first next time. |
| decrypter_.swap(alternative_decrypter_); |
| EncryptionLevel level = alternative_decrypter_level_; |
| alternative_decrypter_level_ = decrypter_level_; |
| decrypter_level_ = level; |
| } |
| } |
| } |
| |
| if (decrypted_.get() == NULL) { |
| DLOG(WARNING) << "DecryptPacket failed for sequence_number:" |
| << header.packet_sequence_number; |
| return false; |
| } |
| |
| reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length())); |
| return true; |
| } |
| |
| size_t QuicFramer::GetAckFrameSize( |
| const QuicAckFrame& ack, |
| QuicSequenceNumberLength sequence_number_length) { |
| AckFrameInfo ack_info = GetAckFrameInfo(ack); |
| QuicSequenceNumberLength largest_observed_length = |
| GetMinSequenceNumberLength(ack.largest_observed); |
| QuicSequenceNumberLength missing_sequence_number_length = |
| GetMinSequenceNumberLength(ack_info.max_delta); |
| |
| size_t ack_size = GetMinAckFrameSize(sequence_number_length, |
| largest_observed_length); |
| if (!ack_info.nack_ranges.empty()) { |
| ack_size += kNumberOfNackRangesSize + kNumberOfRevivedPacketsSize; |
| ack_size += min(ack_info.nack_ranges.size(), kMaxNackRanges) * |
| (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); |
| ack_size += min(ack.revived_packets.size(), |
| kMaxRevivedPackets) * largest_observed_length; |
| } |
| return ack_size; |
| } |
| |
| size_t QuicFramer::ComputeFrameLength( |
| const QuicFrame& frame, |
| bool last_frame_in_packet, |
| InFecGroup is_in_fec_group, |
| QuicSequenceNumberLength sequence_number_length) { |
| switch (frame.type) { |
| case STREAM_FRAME: |
| return GetMinStreamFrameSize(frame.stream_frame->stream_id, |
| frame.stream_frame->offset, |
| last_frame_in_packet, |
| is_in_fec_group) + |
| frame.stream_frame->data.TotalBufferSize(); |
| case ACK_FRAME: { |
| return GetAckFrameSize(*frame.ack_frame, sequence_number_length); |
| } |
| case CONGESTION_FEEDBACK_FRAME: { |
| size_t len = kQuicFrameTypeSize; |
| const QuicCongestionFeedbackFrame& congestion_feedback = |
| *frame.congestion_feedback_frame; |
| len += 1; // Congestion feedback type. |
| |
| switch (congestion_feedback.type) { |
| case kTimestamp: { |
| set_detailed_error("Timestamp feedback not supported."); |
| break; |
| } |
| case kTCP: |
| len += 2; // Receive window. |
| break; |
| default: |
| set_detailed_error("Illegal feedback type."); |
| DVLOG(1) << "Illegal feedback type: " << congestion_feedback.type; |
| break; |
| } |
| return len; |
| } |
| case STOP_WAITING_FRAME: |
| return GetStopWaitingFrameSize(sequence_number_length); |
| case PING_FRAME: |
| // Ping has no payload. |
| return kQuicFrameTypeSize; |
| case RST_STREAM_FRAME: |
| return GetMinRstStreamFrameSize() + |
| frame.rst_stream_frame->error_details.size(); |
| case CONNECTION_CLOSE_FRAME: |
| return GetMinConnectionCloseFrameSize() + |
| frame.connection_close_frame->error_details.size(); |
| case GOAWAY_FRAME: |
| return GetMinGoAwayFrameSize() + frame.goaway_frame->reason_phrase.size(); |
| case WINDOW_UPDATE_FRAME: |
| return GetWindowUpdateFrameSize(); |
| case BLOCKED_FRAME: |
| return GetBlockedFrameSize(); |
| case PADDING_FRAME: |
| DCHECK(false); |
| return 0; |
| case NUM_FRAME_TYPES: |
| DCHECK(false); |
| return 0; |
| } |
| |
| // Not reachable, but some Chrome compilers can't figure that out. *sigh* |
| DCHECK(false); |
| return 0; |
| } |
| |
| bool QuicFramer::AppendTypeByte(const QuicFrame& frame, |
| bool no_stream_frame_length, |
| QuicDataWriter* writer) { |
| uint8 type_byte = 0; |
| switch (frame.type) { |
| case STREAM_FRAME: { |
| if (frame.stream_frame == NULL) { |
| LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame."; |
| } |
| // Fin bit. |
| type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0; |
| |
| // Data Length bit. |
| type_byte <<= kQuicStreamDataLengthShift; |
| type_byte |= no_stream_frame_length ? 0: kQuicStreamDataLengthMask; |
| |
| // Offset 3 bits. |
| type_byte <<= kQuicStreamOffsetShift; |
| const size_t offset_len = GetStreamOffsetSize(frame.stream_frame->offset); |
| if (offset_len > 0) { |
| type_byte |= offset_len - 1; |
| } |
| |
| // stream id 2 bits. |
| type_byte <<= kQuicStreamIdShift; |
| type_byte |= GetStreamIdSize(frame.stream_frame->stream_id) - 1; |
| type_byte |= kQuicFrameTypeStreamMask; // Set Stream Frame Type to 1. |
| break; |
| } |
| case ACK_FRAME: |
| return true; |
| case CONGESTION_FEEDBACK_FRAME: { |
| // TODO(ianswett): Use extra 5 bits in the congestion feedback framing. |
| type_byte = kQuicFrameTypeCongestionFeedbackMask; |
| break; |
| } |
| default: |
| type_byte = frame.type; |
| break; |
| } |
| |
| return writer->WriteUInt8(type_byte); |
| } |
| |
| // static |
| bool QuicFramer::AppendPacketSequenceNumber( |
| QuicSequenceNumberLength sequence_number_length, |
| QuicPacketSequenceNumber packet_sequence_number, |
| QuicDataWriter* writer) { |
| // Ensure the entire sequence number can be written. |
| if (writer->capacity() - writer->length() < |
| static_cast<size_t>(sequence_number_length)) { |
| return false; |
| } |
| switch (sequence_number_length) { |
| case PACKET_1BYTE_SEQUENCE_NUMBER: |
| return writer->WriteUInt8( |
| packet_sequence_number & k1ByteSequenceNumberMask); |
| break; |
| case PACKET_2BYTE_SEQUENCE_NUMBER: |
| return writer->WriteUInt16( |
| packet_sequence_number & k2ByteSequenceNumberMask); |
| break; |
| case PACKET_4BYTE_SEQUENCE_NUMBER: |
| return writer->WriteUInt32( |
| packet_sequence_number & k4ByteSequenceNumberMask); |
| break; |
| case PACKET_6BYTE_SEQUENCE_NUMBER: |
| return writer->WriteUInt48( |
| packet_sequence_number & k6ByteSequenceNumberMask); |
| break; |
| default: |
| DCHECK(false) << "sequence_number_length: " << sequence_number_length; |
| return false; |
| } |
| } |
| |
| bool QuicFramer::AppendStreamFrame( |
| const QuicStreamFrame& frame, |
| bool no_stream_frame_length, |
| QuicDataWriter* writer) { |
| if (!writer->WriteBytes(&frame.stream_id, GetStreamIdSize(frame.stream_id))) { |
| LOG(DFATAL) << "Writing stream id size failed."; |
| return false; |
| } |
| if (!writer->WriteBytes(&frame.offset, GetStreamOffsetSize(frame.offset))) { |
| LOG(DFATAL) << "Writing offset size failed."; |
| return false; |
| } |
| if (!no_stream_frame_length) { |
| if (!writer->WriteUInt16(frame.data.TotalBufferSize())) { |
| LOG(DFATAL) << "Writing stream frame length failed"; |
| return false; |
| } |
| } |
| |
| if (!writer->WriteIOVector(frame.data)) { |
| LOG(DFATAL) << "Writing frame data failed."; |
| return false; |
| } |
| return true; |
| } |
| |
| // static |
| void QuicFramer::set_version(const QuicVersion version) { |
| DCHECK(IsSupportedVersion(version)) << QuicVersionToString(version); |
| quic_version_ = version; |
| } |
| |
| bool QuicFramer::AppendAckFrameAndTypeByte( |
| const QuicPacketHeader& header, |
| const QuicAckFrame& frame, |
| QuicDataWriter* writer) { |
| AckFrameInfo ack_info = GetAckFrameInfo(frame); |
| QuicPacketSequenceNumber ack_largest_observed = frame.largest_observed; |
| QuicSequenceNumberLength largest_observed_length = |
| GetMinSequenceNumberLength(ack_largest_observed); |
| QuicSequenceNumberLength missing_sequence_number_length = |
| GetMinSequenceNumberLength(ack_info.max_delta); |
| // Determine whether we need to truncate ranges. |
| size_t available_range_bytes = writer->capacity() - writer->length() - |
| kNumberOfRevivedPacketsSize - kNumberOfNackRangesSize - |
| GetMinAckFrameSize(header.public_header.sequence_number_length, |
| largest_observed_length); |
| size_t max_num_ranges = available_range_bytes / |
| (missing_sequence_number_length + PACKET_1BYTE_SEQUENCE_NUMBER); |
| max_num_ranges = min(kMaxNackRanges, max_num_ranges); |
| bool truncated = ack_info.nack_ranges.size() > max_num_ranges; |
| DVLOG_IF(1, truncated) << "Truncating ack from " |
| << ack_info.nack_ranges.size() << " ranges to " |
| << max_num_ranges; |
| // Write out the type byte by setting the low order bits and doing shifts |
| // to make room for the next bit flags to be set. |
| // Whether there are any nacks. |
| uint8 type_byte = ack_info.nack_ranges.empty() ? 0 : kQuicHasNacksMask; |
| |
| // truncating bit. |
| type_byte <<= kQuicAckTruncatedShift; |
| type_byte |= truncated ? kQuicAckTruncatedMask : 0; |
| |
| // Largest observed sequence number length. |
| type_byte <<= kQuicSequenceNumberLengthShift; |
| type_byte |= GetSequenceNumberFlags(largest_observed_length); |
| |
| // Missing sequence number length. |
| type_byte <<= kQuicSequenceNumberLengthShift; |
| type_byte |= GetSequenceNumberFlags(missing_sequence_number_length); |
| |
| type_byte |= kQuicFrameTypeAckMask; |
| |
| if (!writer->WriteUInt8(type_byte)) { |
| return false; |
| } |
| |
| QuicPacketEntropyHash ack_entropy_hash = frame.entropy_hash; |
| NackRangeMap::reverse_iterator ack_iter = ack_info.nack_ranges.rbegin(); |
| if (truncated) { |
| // Skip the nack ranges which the truncated ack won't include and set |
| // a correct largest observed for the truncated ack. |
| for (size_t i = 1; i < (ack_info.nack_ranges.size() - max_num_ranges); |
| ++i) { |
| ++ack_iter; |
| } |
| // If the last range is followed by acks, include them. |
| // If the last range is followed by another range, specify the end of the |
| // range as the largest_observed. |
| ack_largest_observed = ack_iter->first - 1; |
| // Also update the entropy so it matches the largest observed. |
| ack_entropy_hash = entropy_calculator_->EntropyHash(ack_largest_observed); |
| ++ack_iter; |
| } |
| |
| if (!writer->WriteUInt8(ack_entropy_hash)) { |
| return false; |
| } |
| |
| if (!AppendPacketSequenceNumber(largest_observed_length, |
| ack_largest_observed, writer)) { |
| return false; |
| } |
| |
| uint64 delta_time_largest_observed_us = kUFloat16MaxValue; |
| if (!frame.delta_time_largest_observed.IsInfinite()) { |
| DCHECK_LE(0u, frame.delta_time_largest_observed.ToMicroseconds()); |
| delta_time_largest_observed_us = |
| frame.delta_time_largest_observed.ToMicroseconds(); |
| } |
| |
| if (!writer->WriteUFloat16(delta_time_largest_observed_us)) { |
| return false; |
| } |
| |
| if (ack_info.nack_ranges.empty()) { |
| return true; |
| } |
| |
| const uint8 num_missing_ranges = |
| min(ack_info.nack_ranges.size(), max_num_ranges); |
| if (!writer->WriteBytes(&num_missing_ranges, 1)) { |
| return false; |
| } |
| |
| int num_ranges_written = 0; |
| QuicPacketSequenceNumber last_sequence_written = ack_largest_observed; |
| for (; ack_iter != ack_info.nack_ranges.rend(); ++ack_iter) { |
| // Calculate the delta to the last number in the range. |
| QuicPacketSequenceNumber missing_delta = |
| last_sequence_written - (ack_iter->first + ack_iter->second); |
| if (!AppendPacketSequenceNumber(missing_sequence_number_length, |
| missing_delta, writer)) { |
| return false; |
| } |
| if (!AppendPacketSequenceNumber(PACKET_1BYTE_SEQUENCE_NUMBER, |
| ack_iter->second, writer)) { |
| return false; |
| } |
| // Subtract 1 so a missing_delta of 0 means an adjacent range. |
| last_sequence_written = ack_iter->first - 1; |
| ++num_ranges_written; |
| } |
| DCHECK_EQ(num_missing_ranges, num_ranges_written); |
| |
| // Append revived packets. |
| // If not all the revived packets fit, only mention the ones that do. |
| uint8 num_revived_packets = min(frame.revived_packets.size(), |
| kMaxRevivedPackets); |
| num_revived_packets = min( |
| static_cast<size_t>(num_revived_packets), |
| (writer->capacity() - writer->length()) / largest_observed_length); |
| if (!writer->WriteBytes(&num_revived_packets, 1)) { |
| return false; |
| } |
| |
| SequenceNumberSet::const_iterator iter = frame.revived_packets.begin(); |
| for (int i = 0; i < num_revived_packets; ++i, ++iter) { |
| LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter)); |
| if (!AppendPacketSequenceNumber(largest_observed_length, |
| *iter, writer)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::AppendCongestionFeedbackFrame( |
| const QuicCongestionFeedbackFrame& frame, |
| QuicDataWriter* writer) { |
| if (!writer->WriteBytes(&frame.type, 1)) { |
| return false; |
| } |
| |
| switch (frame.type) { |
| case kTimestamp: { |
| // Timestamp feedback not supported. |
| return false; |
| } |
| case kTCP: { |
| const CongestionFeedbackMessageTCP& tcp = frame.tcp; |
| DCHECK_LE(tcp.receive_window, 1u << 20); |
| // Simple bit packing, don't send the 4 least significant bits. |
| uint16 receive_window = static_cast<uint16>(tcp.receive_window >> 4); |
| if (!writer->WriteUInt16(receive_window)) { |
| return false; |
| } |
| break; |
| } |
| default: |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::AppendStopWaitingFrame( |
| const QuicPacketHeader& header, |
| const QuicStopWaitingFrame& frame, |
| QuicDataWriter* writer) { |
| DCHECK_GE(header.packet_sequence_number, frame.least_unacked); |
| const QuicPacketSequenceNumber least_unacked_delta = |
| header.packet_sequence_number - frame.least_unacked; |
| const QuicPacketSequenceNumber length_shift = |
| header.public_header.sequence_number_length * 8; |
| if (!writer->WriteUInt8(frame.entropy_hash)) { |
| LOG(DFATAL) << " hash failed"; |
| return false; |
| } |
| |
| if (least_unacked_delta >> length_shift > 0) { |
| LOG(DFATAL) << "sequence_number_length " |
| << header.public_header.sequence_number_length |
| << " is too small for least_unacked_delta: " |
| << least_unacked_delta; |
| return false; |
| } |
| if (!AppendPacketSequenceNumber(header.public_header.sequence_number_length, |
| least_unacked_delta, writer)) { |
| LOG(DFATAL) << " seq failed: " |
| << header.public_header.sequence_number_length; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool QuicFramer::AppendRstStreamFrame( |
| const QuicRstStreamFrame& frame, |
| QuicDataWriter* writer) { |
| if (!writer->WriteUInt32(frame.stream_id)) { |
| return false; |
| } |
| |
| if (!writer->WriteUInt64(frame.byte_offset)) { |
| return false; |
| } |
| |
| uint32 error_code = static_cast<uint32>(frame.error_code); |
| if (!writer->WriteUInt32(error_code)) { |
| return false; |
| } |
| |
| if (!writer->WriteStringPiece16(frame.error_details)) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool QuicFramer::AppendConnectionCloseFrame( |
| const QuicConnectionCloseFrame& frame, |
| QuicDataWriter* writer) { |
| uint32 error_code = static_cast<uint32>(frame.error_code); |
| if (!writer->WriteUInt32(error_code)) { |
| return false; |
| } |
| if (!writer->WriteStringPiece16(frame.error_details)) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool QuicFramer::AppendGoAwayFrame(const QuicGoAwayFrame& frame, |
| QuicDataWriter* writer) { |
| uint32 error_code = static_cast<uint32>(frame.error_code); |
| if (!writer->WriteUInt32(error_code)) { |
| return false; |
| } |
| uint32 stream_id = static_cast<uint32>(frame.last_good_stream_id); |
| if (!writer->WriteUInt32(stream_id)) { |
| return false; |
| } |
| if (!writer->WriteStringPiece16(frame.reason_phrase)) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool QuicFramer::AppendWindowUpdateFrame(const QuicWindowUpdateFrame& frame, |
| QuicDataWriter* writer) { |
| uint32 stream_id = static_cast<uint32>(frame.stream_id); |
| if (!writer->WriteUInt32(stream_id)) { |
| return false; |
| } |
| if (!writer->WriteUInt64(frame.byte_offset)) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool QuicFramer::AppendBlockedFrame(const QuicBlockedFrame& frame, |
| QuicDataWriter* writer) { |
| uint32 stream_id = static_cast<uint32>(frame.stream_id); |
| if (!writer->WriteUInt32(stream_id)) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool QuicFramer::RaiseError(QuicErrorCode error) { |
| DVLOG(1) << "Error detail: " << detailed_error_; |
| set_error(error); |
| visitor_->OnError(this); |
| reader_.reset(NULL); |
| return false; |
| } |
| |
| } // namespace net |