| // Copyright 2018 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 QUICHE_QUIC_CORE_QPACK_QPACK_INSTRUCTION_DECODER_H_ |
| #define QUICHE_QUIC_CORE_QPACK_QPACK_INSTRUCTION_DECODER_H_ |
| |
| #include <cstddef> |
| #include <cstdint> |
| |
| #include "net/third_party/quiche/src/http2/hpack/huffman/hpack_huffman_decoder.h" |
| #include "net/third_party/quiche/src/http2/hpack/varint/hpack_varint_decoder.h" |
| #include "net/third_party/quiche/src/quic/core/qpack/qpack_constants.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_export.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_string.h" |
| #include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h" |
| |
| namespace quic { |
| |
| // Generic instruction decoder class. Takes a QpackLanguage that describes a |
| // language, that is, a set of instruction opcodes together with a list of |
| // fields that follow each instruction. |
| class QUIC_EXPORT_PRIVATE QpackInstructionDecoder { |
| public: |
| // Delegate is notified each time an instruction is decoded or when an error |
| // occurs. |
| class QUIC_EXPORT_PRIVATE Delegate { |
| public: |
| virtual ~Delegate() = default; |
| |
| // Called when an instruction (including all its fields) is decoded. |
| // |instruction| points to an entry in |language|. |
| // Returns true if decoded fields are valid. |
| // Returns false otherwise, in which case QpackInstructionDecoder stops |
| // decoding: Delegate methods will not be called, and Decode() must not be |
| // called. |
| virtual bool OnInstructionDecoded(const QpackInstruction* instruction) = 0; |
| |
| // Called by QpackInstructionDecoder if an error has occurred. |
| // No more data is processed afterwards. |
| virtual void OnError(QuicStringPiece error_message) = 0; |
| }; |
| |
| // Both |*language| and |*delegate| must outlive this object. |
| QpackInstructionDecoder(const QpackLanguage* language, Delegate* delegate); |
| QpackInstructionDecoder() = delete; |
| QpackInstructionDecoder(const QpackInstructionDecoder&) = delete; |
| QpackInstructionDecoder& operator=(const QpackInstructionDecoder&) = delete; |
| |
| // Provide a data fragment to decode. Must not be called after an error has |
| // occurred. Must not be called with empty |data|. |
| void Decode(QuicStringPiece data); |
| |
| // Returns true if no decoding has taken place yet or if the last instruction |
| // has been entirely parsed. |
| bool AtInstructionBoundary() const; |
| |
| // Accessors for decoded values. Should only be called for fields that are |
| // part of the most recently decoded instruction, and only after |this| calls |
| // Delegate::OnInstructionDecoded() but before Decode() is called again. |
| bool s_bit() const { return s_bit_; } |
| uint64_t varint() const { return varint_; } |
| uint64_t varint2() const { return varint2_; } |
| const QuicString& name() const { return name_; } |
| const QuicString& value() const { return value_; } |
| |
| private: |
| enum class State { |
| // Identify instruction. |
| kStartInstruction, |
| // Start decoding next field. |
| kStartField, |
| // Read a single bit. |
| kReadBit, |
| // Start reading integer. |
| kVarintStart, |
| // Resume reading integer. |
| kVarintResume, |
| // Done reading integer. |
| kVarintDone, |
| // Read string. |
| kReadString, |
| // Done reading string. |
| kReadStringDone |
| }; |
| |
| // One method for each state. Some take input data and return the number of |
| // octets processed. Some take input data but do have void return type |
| // because they not consume any bytes. Some do not take any arguments because |
| // they only change internal state. |
| void DoStartInstruction(QuicStringPiece data); |
| void DoStartField(); |
| void DoReadBit(QuicStringPiece data); |
| size_t DoVarintStart(QuicStringPiece data); |
| size_t DoVarintResume(QuicStringPiece data); |
| void DoVarintDone(); |
| size_t DoReadString(QuicStringPiece data); |
| void DoReadStringDone(); |
| |
| // Identify instruction based on opcode encoded in |byte|. |
| // Returns a pointer to an element of |*language_|. |
| const QpackInstruction* LookupOpcode(uint8_t byte) const; |
| |
| // Stops decoding and calls Delegate::OnError(). |
| void OnError(QuicStringPiece error_message); |
| |
| // Describes the language used for decoding. |
| const QpackLanguage* const language_; |
| |
| // The Delegate to notify of decoded instructions and errors. |
| Delegate* const delegate_; |
| |
| // Storage for decoded field values. |
| bool s_bit_; |
| uint64_t varint_; |
| uint64_t varint2_; |
| QuicString name_; |
| QuicString value_; |
| // Whether the currently decoded header name or value is Huffman encoded. |
| bool is_huffman_encoded_; |
| // Length of string being read into |name_| or |value_|. |
| size_t string_length_; |
| |
| // Decoder instance for decoding integers. |
| http2::HpackVarintDecoder varint_decoder_; |
| |
| // Decoder instance for decoding Huffman encoded strings. |
| http2::HpackHuffmanDecoder huffman_decoder_; |
| |
| // True if a decoding error has been detected either by |
| // QpackInstructionDecoder or by Delegate. |
| bool error_detected_; |
| |
| // Decoding state. |
| State state_; |
| |
| // Instruction currently being decoded. |
| const QpackInstruction* instruction_; |
| |
| // Field currently being decoded. |
| QpackInstructionFields::const_iterator field_; |
| }; |
| |
| } // namespace quic |
| |
| #endif // QUICHE_QUIC_CORE_QPACK_QPACK_INSTRUCTION_DECODER_H_ |