Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(796)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/quic_framer.h

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: io_thread_unittest.cc Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/quic_frame_list.cc ('k') | net/quic/quic_framer.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/quic_framer.h
diff --git a/net/quic/quic_framer.h b/net/quic/quic_framer.h
deleted file mode 100644
index 6ac0518d34b86ebb11da84fd8f3cbf138e002e29..0000000000000000000000000000000000000000
--- a/net/quic/quic_framer.h
+++ /dev/null
@@ -1,625 +0,0 @@
-// 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.
-
-#ifndef NET_QUIC_QUIC_FRAMER_H_
-#define NET_QUIC_QUIC_FRAMER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "net/base/net_export.h"
-#include "net/quic/quic_protocol.h"
-
-namespace net {
-
-namespace test {
-class QuicFramerPeer;
-} // namespace test
-
-class QuicDataReader;
-class QuicDataWriter;
-class QuicDecrypter;
-class QuicEncrypter;
-class QuicFramer;
-
-// Number of bytes reserved for the frame type preceding each frame.
-const size_t kQuicFrameTypeSize = 1;
-// Number of bytes reserved for error code.
-const size_t kQuicErrorCodeSize = 4;
-// Number of bytes reserved to denote the length of error details field.
-const size_t kQuicErrorDetailsLengthSize = 2;
-
-// Maximum number of bytes reserved for stream id.
-const size_t kQuicMaxStreamIdSize = 4;
-// Maximum number of bytes reserved for byte offset in stream frame.
-const size_t kQuicMaxStreamOffsetSize = 8;
-// Number of bytes reserved to store payload length in stream frame.
-const size_t kQuicStreamPayloadLengthSize = 2;
-
-// Size in bytes of the entropy hash sent in ack frames.
-const size_t kQuicEntropyHashSize = 1;
-// Size in bytes reserved for the delta time of the largest observed
-// packet number in ack frames.
-const size_t kQuicDeltaTimeLargestObservedSize = 2;
-// Size in bytes reserved for the number of received packets with timestamps.
-const size_t kQuicNumTimestampsSize = 1;
-// Size in bytes reserved for the number of missing packets in ack frames.
-const size_t kNumberOfNackRangesSize = 1;
-// Size in bytes reserved for the number of ack blocks in ack frames.
-const size_t kNumberOfAckBlocksSize = 1;
-// Maximum number of missing packet ranges that can fit within an ack frame.
-const size_t kMaxNackRanges = (1 << (kNumberOfNackRangesSize * 8)) - 1;
-// Maximum number of ack blocks that can fit within an ack frame.
-const size_t kMaxAckBlocks = (1 << (kNumberOfAckBlocksSize * 8)) - 1;
-// Size in bytes reserved for the number of revived packets in ack frames.
-const size_t kNumberOfRevivedPacketsSize = 1;
-
-// This class receives callbacks from the framer when packets
-// are processed.
-class NET_EXPORT_PRIVATE QuicFramerVisitorInterface {
- public:
- virtual ~QuicFramerVisitorInterface() {}
-
- // Called if an error is detected in the QUIC protocol.
- virtual void OnError(QuicFramer* framer) = 0;
-
- // Called only when |perspective_| is IS_SERVER and the the framer gets a
- // packet with version flag true and the version on the packet doesn't match
- // |quic_version_|. The visitor should return true after it updates the
- // version of the |framer_| to |received_version| or false to stop processing
- // this packet.
- virtual bool OnProtocolVersionMismatch(QuicVersion received_version) = 0;
-
- // Called when a new packet has been received, before it
- // has been validated or processed.
- virtual void OnPacket() = 0;
-
- // Called when a public reset packet has been parsed but has not yet
- // been validated.
- virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
-
- // Called only when |perspective_| is IS_CLIENT and a version negotiation
- // packet has been parsed.
- virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) = 0;
-
- // Called when the public header has been parsed, but has not been
- // authenticated. If it returns false, framing for this packet will cease.
- virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) = 0;
-
- // Called when the unauthenticated portion of the header has been parsed.
- // If OnUnauthenticatedHeader returns false, framing for this packet will
- // cease.
- virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) = 0;
-
- // Called when a packet has been decrypted. |level| is the encryption level
- // of the packet.
- virtual void OnDecryptedPacket(EncryptionLevel level) = 0;
-
- // Called when the complete header of a packet had been parsed.
- // If OnPacketHeader returns false, framing for this packet will cease.
- virtual bool OnPacketHeader(const QuicPacketHeader& header) = 0;
-
- // Called when a StreamFrame has been parsed.
- virtual bool OnStreamFrame(const QuicStreamFrame& frame) = 0;
-
- // Called when a AckFrame has been parsed. If OnAckFrame returns false,
- // the framer will stop parsing the current packet.
- virtual bool OnAckFrame(const QuicAckFrame& frame) = 0;
-
- // Called when a StopWaitingFrame has been parsed.
- virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) = 0;
-
- // Called when a QuicPaddingFrame has been parsed.
- virtual bool OnPaddingFrame(const QuicPaddingFrame& frame) = 0;
-
- // Called when a PingFrame has been parsed.
- virtual bool OnPingFrame(const QuicPingFrame& frame) = 0;
-
- // Called when a RstStreamFrame has been parsed.
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) = 0;
-
- // Called when a ConnectionCloseFrame has been parsed.
- virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) = 0;
-
- // Called when a GoAwayFrame has been parsed.
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) = 0;
-
- // Called when a WindowUpdateFrame has been parsed.
- virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) = 0;
-
- // Called when a BlockedFrame has been parsed.
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) = 0;
-
- // Called when a PathCloseFrame has been parsed.
- virtual bool OnPathCloseFrame(const QuicPathCloseFrame& frame) = 0;
-
- // Called when a packet has been completely processed.
- virtual void OnPacketComplete() = 0;
-};
-
-// This class calculates the received entropy of the ack packet being
-// framed, should it get truncated.
-class NET_EXPORT_PRIVATE QuicReceivedEntropyHashCalculatorInterface {
- public:
- virtual ~QuicReceivedEntropyHashCalculatorInterface() {}
-
- // When an ack frame gets truncated while being framed the received
- // entropy of the ack frame needs to be calculated since the some of the
- // missing packets are not added and the largest observed might be lowered.
- // This should return the received entropy hash of the packets received up to
- // and including |packet_number|.
- virtual QuicPacketEntropyHash EntropyHash(
- QuicPacketNumber packet_number) const = 0;
-};
-
-// Class for parsing and constructing QUIC packets. It has a
-// QuicFramerVisitorInterface that is called when packets are parsed.
-class NET_EXPORT_PRIVATE QuicFramer {
- public:
- // Constructs a new framer that installs a kNULL QuicEncrypter and
- // QuicDecrypter for level ENCRYPTION_NONE. |supported_versions| specifies the
- // list of supported QUIC versions. |quic_version_| is set to the maximum
- // version in |supported_versions|.
- QuicFramer(const QuicVersionVector& supported_versions,
- QuicTime creation_time,
- Perspective perspective);
-
- virtual ~QuicFramer();
-
- // Returns true if |version| is a supported protocol version.
- bool IsSupportedVersion(const QuicVersion version) const;
-
- // Set callbacks to be called from the framer. A visitor must be set, or
- // else the framer will likely crash. It is acceptable for the visitor
- // to do nothing. If this is called multiple times, only the last visitor
- // will be used.
- void set_visitor(QuicFramerVisitorInterface* visitor) { visitor_ = visitor; }
-
- const QuicVersionVector& supported_versions() const {
- return supported_versions_;
- }
-
- QuicVersion version() const { return quic_version_; }
-
- void set_version(const QuicVersion version);
-
- // Does not DCHECK for supported version. Used by tests to set unsupported
- // version to trigger version negotiation.
- void set_version_for_tests(const QuicVersion version) {
- quic_version_ = version;
- }
-
- // Set entropy calculator to be called from the framer when it needs the
- // entropy of a truncated ack frame. An entropy calculator must be set or else
- // the framer will likely crash. If this is called multiple times, only the
- // last calculator will be used.
- void set_received_entropy_calculator(
- QuicReceivedEntropyHashCalculatorInterface* entropy_calculator) {
- entropy_calculator_ = entropy_calculator;
- }
-
- QuicErrorCode error() const { return error_; }
-
- // Pass a UDP packet into the framer for parsing.
- // Return true if the packet was processed succesfully. |packet| must be a
- // single, complete UDP packet (not a frame of a packet). This packet
- // might be null padded past the end of the payload, which will be correctly
- // ignored.
- bool ProcessPacket(const QuicEncryptedPacket& packet);
-
- // Largest size in bytes of all stream frame fields without the payload.
- static size_t GetMinStreamFrameSize(QuicStreamId stream_id,
- QuicStreamOffset offset,
- bool last_frame_in_packet);
- // Size in bytes of all ack frame fields without the missing packets or ack
- // blocks.
- static size_t GetMinAckFrameSize(
- QuicVersion version,
- QuicPacketNumberLength largest_observed_length);
- // Size in bytes of a stop waiting frame.
- static size_t GetStopWaitingFrameSize(
- QuicVersion version,
- QuicPacketNumberLength packet_number_length);
- // Size in bytes of all reset stream frame fields.
- static size_t GetRstStreamFrameSize();
- // Size in bytes of all connection close frame fields without the error
- // details and the missing packets from the enclosed ack frame.
- static size_t GetMinConnectionCloseFrameSize();
- // Size in bytes of all GoAway frame fields without the reason phrase.
- static size_t GetMinGoAwayFrameSize();
- // Size in bytes of all WindowUpdate frame fields.
- static size_t GetWindowUpdateFrameSize();
- // Size in bytes of all Blocked frame fields.
- static size_t GetBlockedFrameSize();
- // Size in bytes of all PathClose frame fields.
- static size_t GetPathCloseFrameSize();
- // Size in bytes required to serialize the stream id.
- static size_t GetStreamIdSize(QuicStreamId stream_id);
- // Size in bytes required to serialize the stream offset.
- static size_t GetStreamOffsetSize(QuicStreamOffset offset);
- // Size in bytes required for a serialized version negotiation packet
- static size_t GetVersionNegotiationPacketSize(size_t number_versions);
-
- // Returns the number of bytes added to the packet for the specified frame,
- // and 0 if the frame doesn't fit. Includes the header size for the first
- // frame.
- size_t GetSerializedFrameLength(const QuicFrame& frame,
- size_t free_bytes,
- bool first_frame_in_packet,
- bool last_frame_in_packet,
- QuicPacketNumberLength packet_number_length);
-
- // Returns the associated data from the encrypted packet |encrypted| as a
- // stringpiece.
- static base::StringPiece GetAssociatedDataFromEncryptedPacket(
- QuicVersion version,
- const QuicEncryptedPacket& encrypted,
- QuicConnectionIdLength connection_id_length,
- bool includes_version,
- bool includes_path_id,
- bool includes_diversification_nonce,
- QuicPacketNumberLength packet_number_length);
-
- // Serializes a packet containing |frames| into |buffer|.
- // Returns the length of the packet, which must not be longer than
- // |packet_length|. Returns 0 if it fails to serialize.
- size_t BuildDataPacket(const QuicPacketHeader& header,
- const QuicFrames& frames,
- char* buffer,
- size_t packet_length);
-
- // Returns a new public reset packet, owned by the caller.
- static QuicEncryptedPacket* BuildPublicResetPacket(
- const QuicPublicResetPacket& packet);
-
- // Returns a new version negotiation packet, owned by the caller.
- static QuicEncryptedPacket* BuildVersionNegotiationPacket(
- QuicConnectionId connection_id,
- const QuicVersionVector& versions);
-
- // If header.public_header.version_flag is set, the version in the
- // packet will be set -- but it will be set from quic_version_ not
- // header.public_header.versions.
- bool AppendPacketHeader(const QuicPacketHeader& header,
- QuicDataWriter* writer);
- bool AppendTypeByte(const QuicFrame& frame,
- bool last_frame_in_packet,
- QuicDataWriter* writer);
- bool AppendStreamFrame(const QuicStreamFrame& frame,
- bool last_frame_in_packet,
- QuicDataWriter* builder);
-
- // SetDecrypter sets the primary decrypter, replacing any that already exists,
- // and takes ownership. If an alternative decrypter is in place then the
- // function DCHECKs. This is intended for cases where one knows that future
- // packets will be using the new decrypter and the previous decrypter is now
- // obsolete. |level| indicates the encryption level of the new decrypter.
- void SetDecrypter(EncryptionLevel level, QuicDecrypter* decrypter);
-
- // SetAlternativeDecrypter sets a decrypter that may be used to decrypt
- // future packets and takes ownership of it. |level| indicates the encryption
- // level of the decrypter. If |latch_once_used| is true, then the first time
- // that the decrypter is successful it will replace the primary decrypter.
- // Otherwise both decrypters will remain active and the primary decrypter
- // will be the one last used.
- void SetAlternativeDecrypter(EncryptionLevel level,
- QuicDecrypter* decrypter,
- bool latch_once_used);
-
- const QuicDecrypter* decrypter() const;
- const QuicDecrypter* alternative_decrypter() const;
-
- // Changes the encrypter used for level |level| to |encrypter|. The function
- // takes ownership of |encrypter|.
- void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
-
- // Encrypts a payload in |buffer|. |ad_len| is the length of the associated
- // data. |total_len| is the length of the associated data plus plaintext.
- // |buffer_len| is the full length of the allocated buffer.
- size_t EncryptInPlace(EncryptionLevel level,
- QuicPathId path_id,
- QuicPacketNumber packet_number,
- size_t ad_len,
- size_t total_len,
- size_t buffer_len,
- char* buffer);
-
- // Returns the length of the data encrypted into |buffer| if |buffer_len| is
- // long enough, and otherwise 0.
- size_t EncryptPayload(EncryptionLevel level,
- QuicPathId path_id,
- QuicPacketNumber packet_number,
- const QuicPacket& packet,
- char* buffer,
- size_t buffer_len);
-
- // Returns the maximum length of plaintext that can be encrypted
- // to ciphertext no larger than |ciphertext_size|.
- size_t GetMaxPlaintextSize(size_t ciphertext_size);
-
- const std::string& detailed_error() { return detailed_error_; }
-
- // The minimum packet number length required to represent |packet_number|.
- static QuicPacketNumberLength GetMinSequenceNumberLength(
- QuicPacketNumber packet_number);
-
- void SetSupportedVersions(const QuicVersionVector& versions) {
- supported_versions_ = versions;
- quic_version_ = versions[0];
- }
-
- void set_validate_flags(bool value) { validate_flags_ = value; }
-
- Perspective perspective() const { return perspective_; }
-
- static QuicPacketEntropyHash GetPacketEntropyHash(
- const QuicPacketHeader& header);
-
- // Called when a PATH_CLOSED frame has been sent/received on |path_id|.
- void OnPathClosed(QuicPathId path_id);
-
- QuicTag last_version_tag() { return last_version_tag_; }
-
- private:
- friend class test::QuicFramerPeer;
-
- typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
-
- struct AckFrameInfo {
- AckFrameInfo();
- AckFrameInfo(const AckFrameInfo& other);
- ~AckFrameInfo();
-
- // The maximum delta between ranges.
- QuicPacketNumber max_delta;
- // Nack ranges starting with start packet numbers and lengths.
- NackRangeMap nack_ranges;
- };
-
- struct AckBlock {
- AckBlock(uint8_t gap, QuicPacketNumber length);
- AckBlock(const AckBlock& other);
- ~AckBlock();
-
- // Gap to the next ack block.
- uint8_t gap;
- // Length of this ack block.
- QuicPacketNumber length;
- };
-
- struct NewAckFrameInfo {
- NewAckFrameInfo();
- NewAckFrameInfo(const NewAckFrameInfo& other);
- ~NewAckFrameInfo();
-
- // The maximum ack block length.
- QuicPacketNumber max_block_length;
- // Length of first ack block.
- QuicPacketNumber first_block_length;
- // Ack blocks starting with gaps to next block and ack block lengths.
- std::vector<AckBlock> ack_blocks;
- // Number of ACK blocks. If |ack_blocks| is generated, must equal
- // |ack_blocks.size()|.
- size_t num_ack_blocks;
- };
-
- bool ProcessDataPacket(QuicDataReader* reader,
- const QuicPacketPublicHeader& public_header,
- const QuicEncryptedPacket& packet,
- char* decrypted_buffer,
- size_t buffer_length);
-
- bool ProcessPublicResetPacket(QuicDataReader* reader,
- const QuicPacketPublicHeader& public_header);
-
- bool ProcessVersionNegotiationPacket(QuicDataReader* reader,
- QuicPacketPublicHeader* public_header);
-
- bool ProcessPublicHeader(QuicDataReader* reader,
- QuicPacketPublicHeader* header);
-
- // Processes the unauthenticated portion of the header into |header| from
- // the current QuicDataReader. Returns true on success, false on failure.
- bool ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
- QuicPacketHeader* header);
-
- // Processes the authenticated portion of the header into |header| from
- // the current QuicDataReader. Returns true on success, false on failure.
- bool ProcessAuthenticatedHeader(QuicDataReader* reader,
- QuicPacketHeader* header);
-
- bool ProcessPathId(QuicDataReader* reader, QuicPathId* path_id);
- bool ProcessPacketSequenceNumber(QuicDataReader* reader,
- QuicPacketNumberLength packet_number_length,
- QuicPacketNumber last_packet_number,
- QuicPacketNumber* packet_number);
- bool ProcessFrameData(QuicDataReader* reader, const QuicPacketHeader& header);
- bool ProcessStreamFrame(QuicDataReader* reader,
- uint8_t frame_type,
- QuicStreamFrame* frame);
- bool ProcessAckFrame(QuicDataReader* reader,
- uint8_t frame_type,
- QuicAckFrame* frame);
- bool ProcessNewAckFrame(QuicDataReader* reader,
- uint8_t frame_type,
- QuicAckFrame* frame);
- bool ProcessTimestampsInAckFrame(QuicDataReader* reader, QuicAckFrame* frame);
- bool ProcessStopWaitingFrame(QuicDataReader* reader,
- const QuicPacketHeader& public_header,
- QuicStopWaitingFrame* stop_waiting);
- bool ProcessRstStreamFrame(QuicDataReader* reader, QuicRstStreamFrame* frame);
- bool ProcessConnectionCloseFrame(QuicDataReader* reader,
- QuicConnectionCloseFrame* frame);
- bool ProcessGoAwayFrame(QuicDataReader* reader, QuicGoAwayFrame* frame);
- bool ProcessWindowUpdateFrame(QuicDataReader* reader,
- QuicWindowUpdateFrame* frame);
- bool ProcessBlockedFrame(QuicDataReader* reader, QuicBlockedFrame* frame);
- bool ProcessPathCloseFrame(QuicDataReader* reader, QuicPathCloseFrame* frame);
-
- bool DecryptPayload(QuicDataReader* encrypted_reader,
- const QuicPacketHeader& header,
- const QuicEncryptedPacket& packet,
- char* decrypted_buffer,
- size_t buffer_length,
- size_t* decrypted_length);
-
- // Checks if |path_id| is a viable path to receive packets on. Returns true
- // and sets |last_packet_number| if the path is not closed. Returns false
- // otherwise.
- bool IsValidPath(QuicPathId path_id, QuicPacketNumber* last_packet_number);
-
- // Sets last_packet_number_. This can only be called after the packet is
- // successfully decrypted.
- void SetLastPacketNumber(const QuicPacketHeader& header);
-
- // Returns the full packet number from the truncated
- // wire format version and the last seen packet number.
- QuicPacketNumber CalculatePacketNumberFromWire(
- QuicPacketNumberLength packet_number_length,
- QuicPacketNumber last_packet_number,
- QuicPacketNumber packet_number) const;
-
- // Returns the QuicTime::Delta corresponding to the time from when the framer
- // was created.
- const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
-
- // Computes the wire size in bytes of time stamps in |ack|.
- size_t GetAckFrameTimeStampSize(const QuicAckFrame& ack);
-
- // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
- size_t GetAckFrameSize(const QuicAckFrame& ack,
- QuicPacketNumberLength packet_number_length);
-
- // Computes the wire size in bytes of the |ack| frame.
- size_t GetNewAckFrameSize(const QuicAckFrame& ack);
-
- // Computes the wire size in bytes of the payload of |frame|.
- size_t ComputeFrameLength(const QuicFrame& frame,
- bool last_frame_in_packet,
- QuicPacketNumberLength packet_number_length);
-
- static bool AppendPacketSequenceNumber(
- QuicPacketNumberLength packet_number_length,
- QuicPacketNumber packet_number,
- QuicDataWriter* writer);
-
- // Appends a single ACK block to |writer| and returns true if the block was
- // successfully appended.
- static bool AppendAckBlock(uint8_t gap,
- QuicPacketNumberLength length_length,
- QuicPacketNumber length,
- QuicDataWriter* writer);
-
- static uint8_t GetSequenceNumberFlags(
- QuicPacketNumberLength packet_number_length);
-
- static AckFrameInfo GetAckFrameInfo(const QuicAckFrame& frame);
-
- static NewAckFrameInfo GetNewAckFrameInfo(const QuicAckFrame& frame,
- bool construct_blocks);
-
- // The Append* methods attempt to write the provided header or frame using the
- // |writer|, and return true if successful.
-
- bool AppendAckFrameAndTypeByte(const QuicPacketHeader& header,
- const QuicAckFrame& frame,
- QuicDataWriter* builder);
- bool AppendNewAckFrameAndTypeByte(const QuicAckFrame& frame,
- QuicDataWriter* builder);
- bool AppendTimestampToAckFrame(const QuicAckFrame& frame,
- QuicDataWriter* builder);
- bool AppendStopWaitingFrame(const QuicPacketHeader& header,
- const QuicStopWaitingFrame& frame,
- QuicDataWriter* builder);
- bool AppendRstStreamFrame(const QuicRstStreamFrame& frame,
- QuicDataWriter* builder);
- bool AppendConnectionCloseFrame(const QuicConnectionCloseFrame& frame,
- QuicDataWriter* builder);
- bool AppendGoAwayFrame(const QuicGoAwayFrame& frame, QuicDataWriter* writer);
- bool AppendWindowUpdateFrame(const QuicWindowUpdateFrame& frame,
- QuicDataWriter* writer);
- bool AppendBlockedFrame(const QuicBlockedFrame& frame,
- QuicDataWriter* writer);
- bool AppendPathCloseFrame(const QuicPathCloseFrame& frame,
- QuicDataWriter* writer);
-
- bool RaiseError(QuicErrorCode error);
-
- void set_error(QuicErrorCode error) { error_ = error; }
-
- void set_detailed_error(const char* error) { detailed_error_ = error; }
-
- std::string detailed_error_;
- QuicFramerVisitorInterface* visitor_;
- QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
- QuicErrorCode error_;
- // Set of closed paths. A path is considered as closed if a PATH_CLOSED frame
- // has been sent/received.
- // TODO(fayang): this set is never cleaned up. A possible improvement is to
- // use intervals.
- std::unordered_set<QuicPathId> closed_paths_;
- // Map mapping path id to packet number of last successfully decrypted
- // received packet.
- std::unordered_map<QuicPathId, QuicPacketNumber> last_packet_numbers_;
- // Updated by ProcessPacketHeader when it succeeds.
- QuicPacketNumber last_packet_number_;
- // The path on which last successfully decrypted packet was received.
- QuicPathId last_path_id_;
- // Updated by WritePacketHeader.
- QuicConnectionId last_serialized_connection_id_;
- // The last QUIC version tag received.
- QuicTag last_version_tag_;
- // Version of the protocol being used.
- QuicVersion quic_version_;
- // This vector contains QUIC versions which we currently support.
- // This should be ordered such that the highest supported version is the first
- // element, with subsequent elements in descending order (versions can be
- // skipped as necessary).
- QuicVersionVector supported_versions_;
- // Primary decrypter used to decrypt packets during parsing.
- std::unique_ptr<QuicDecrypter> decrypter_;
- // Alternative decrypter that can also be used to decrypt packets.
- std::unique_ptr<QuicDecrypter> alternative_decrypter_;
- // The encryption level of |decrypter_|.
- EncryptionLevel decrypter_level_;
- // The encryption level of |alternative_decrypter_|.
- EncryptionLevel alternative_decrypter_level_;
- // |alternative_decrypter_latch_| is true if, when |alternative_decrypter_|
- // successfully decrypts a packet, we should install it as the only
- // decrypter.
- bool alternative_decrypter_latch_;
- // Encrypters used to encrypt packets via EncryptPayload().
- std::unique_ptr<QuicEncrypter> encrypter_[NUM_ENCRYPTION_LEVELS];
- // Tracks if the framer is being used by the entity that received the
- // connection or the entity that initiated it.
- Perspective perspective_;
- // If false, skip validation that the public flags are set to legal values.
- bool validate_flags_;
- // The time this framer was created. Time written to the wire will be
- // written as a delta from this value.
- QuicTime creation_time_;
- // The time delta computed for the last timestamp frame. This is relative to
- // the creation_time.
- QuicTime::Delta last_timestamp_;
- // The diversification nonce from the last received packet.
- DiversificationNonce last_nonce_;
-
- DISALLOW_COPY_AND_ASSIGN(QuicFramer);
-};
-
-} // namespace net
-
-#endif // NET_QUIC_QUIC_FRAMER_H_
« no previous file with comments | « net/quic/quic_frame_list.cc ('k') | net/quic/quic_framer.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698