Project import generated by Copybara.
PiperOrigin-RevId: 237361882
Change-Id: I109a68f44db867b20f8c6a7732b0ce657133e52a
diff --git a/quic/core/quic_data_reader.h b/quic/core/quic_data_reader.h
new file mode 100644
index 0000000..fff0ffd
--- /dev/null
+++ b/quic/core/quic_data_reader.h
@@ -0,0 +1,178 @@
+// 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 QUICHE_QUIC_CORE_QUIC_DATA_READER_H_
+#define QUICHE_QUIC_CORE_QUIC_DATA_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#include "base/macros.h"
+#include "net/third_party/quiche/src/quic/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_endian.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
+
+namespace quic {
+
+// Used for reading QUIC data. Though there isn't really anything terribly
+// QUIC-specific here, it's a helper class that's useful when doing QUIC
+// framing.
+//
+// To use, simply construct a QuicDataReader using the underlying buffer that
+// you'd like to read fields from, then call one of the Read*() methods to
+// actually do some reading.
+//
+// This class keeps an internal iterator to keep track of what's already been
+// read and each successive Read*() call automatically increments said iterator
+// on success. On failure, internal state of the QuicDataReader should not be
+// trusted and it is up to the caller to throw away the failed instance and
+// handle the error as appropriate. None of the Read*() methods should ever be
+// called after failure, as they will also fail immediately.
+class QUIC_EXPORT_PRIVATE QuicDataReader {
+ public:
+ // Constructs a reader using NETWORK_BYTE_ORDER endianness.
+ // Caller must provide an underlying buffer to work on.
+ QuicDataReader(const char* data, const size_t len);
+ // Constructs a reader using the specified endianness.
+ // Caller must provide an underlying buffer to work on.
+ QuicDataReader(const char* data, const size_t len, Endianness endianness);
+ QuicDataReader(const QuicDataReader&) = delete;
+ QuicDataReader& operator=(const QuicDataReader&) = delete;
+
+ // Empty destructor.
+ ~QuicDataReader() {}
+
+ // Reads an 8/16/32/64-bit unsigned integer into the given output
+ // parameter. Forwards the internal iterator on success. Returns true on
+ // success, false otherwise.
+ bool ReadUInt8(uint8_t* result);
+ bool ReadUInt16(uint16_t* result);
+ bool ReadUInt32(uint32_t* result);
+ bool ReadUInt64(uint64_t* result);
+
+ // Set |result| to 0, then read |num_bytes| bytes in the correct byte order
+ // into least significant bytes of |result|.
+ bool ReadBytesToUInt64(size_t num_bytes, uint64_t* result);
+
+ // Reads a 16-bit unsigned float into the given output parameter.
+ // Forwards the internal iterator on success.
+ // Returns true on success, false otherwise.
+ bool ReadUFloat16(uint64_t* result);
+
+ // Reads a string prefixed with 16-bit length into the given output parameter.
+ //
+ // NOTE: Does not copy but rather references strings in the underlying buffer.
+ // This should be kept in mind when handling memory management!
+ //
+ // Forwards the internal iterator on success.
+ // Returns true on success, false otherwise.
+ bool ReadStringPiece16(QuicStringPiece* result);
+
+ // Reads a given number of bytes into the given buffer. The buffer
+ // must be of adequate size.
+ // Forwards the internal iterator on success.
+ // Returns true on success, false otherwise.
+ bool ReadStringPiece(QuicStringPiece* result, size_t len);
+
+ // Reads connection ID into the given output parameter.
+ // Forwards the internal iterator on success.
+ // Returns true on success, false otherwise.
+ bool ReadConnectionId(QuicConnectionId* connection_id, uint8_t length);
+
+ // Reads tag represented as 32-bit unsigned integer into given output
+ // parameter. Tags are in big endian on the wire (e.g., CHLO is
+ // 'C','H','L','O') and are read in byte order, so tags in memory are in big
+ // endian.
+ bool ReadTag(uint32_t* tag);
+
+ // Returns the remaining payload as a QuicStringPiece.
+ //
+ // NOTE: Does not copy but rather references strings in the underlying buffer.
+ // This should be kept in mind when handling memory management!
+ //
+ // Forwards the internal iterator.
+ QuicStringPiece ReadRemainingPayload();
+
+ // Returns the remaining payload as a QuicStringPiece.
+ //
+ // NOTE: Does not copy but rather references strings in the underlying buffer.
+ // This should be kept in mind when handling memory management!
+ //
+ // DOES NOT forward the internal iterator.
+ QuicStringPiece PeekRemainingPayload() const;
+
+ // Reads a given number of bytes into the given buffer. The buffer
+ // must be of adequate size.
+ // Forwards the internal iterator on success.
+ // Returns true on success, false otherwise.
+ bool ReadBytes(void* result, size_t size);
+
+ // Returns true if the entirety of the underlying buffer has been read via
+ // Read*() calls.
+ bool IsDoneReading() const;
+
+ // Returns the length in bytes of a variable length integer based on the next
+ // two bits available. Returns 1, 2, 4, or 8 on success, and 0 on failure.
+ QuicVariableLengthIntegerLength PeekVarInt62Length();
+
+ // Returns the number of bytes remaining to be read.
+ size_t BytesRemaining() const;
+
+ // Truncates the reader down by reducing its internal length.
+ // If called immediately after calling this, BytesRemaining will
+ // return |truncation_length|. If truncation_length is less than the
+ // current value of BytesRemaining, this does nothing and returns false.
+ bool TruncateRemaining(size_t truncation_length);
+
+ // Returns the next byte that to be read. Must not be called when there are no
+ // bytes to be read.
+ //
+ // DOES NOT forward the internal iterator.
+ uint8_t PeekByte() const;
+
+ void set_endianness(Endianness endianness) { endianness_ = endianness; }
+
+ // Read an IETF-encoded Variable Length Integer and place the result
+ // in |*result|.
+ // Returns true if it works, false if not. The only error is that
+ // there is not enough in the buffer to read the number.
+ // If there is an error, |*result| is not altered.
+ // Numbers are encoded per the rules in draft-ietf-quic-transport-10.txt
+ // and that the integers in the range 0 ... (2^62)-1.
+ bool ReadVarInt62(uint64_t* result);
+
+ // Convenience method that reads a StreamId.
+ // Atempts to read a Stream ID into |result| using ReadVarInt62 and
+ // returns false if there is a read error or if the value is
+ // greater than (2^32)-1.
+ bool ReadVarIntStreamId(QuicStreamId* result);
+
+ QuicString DebugString() const;
+
+ private:
+ // Returns true if the underlying buffer has enough room to read the given
+ // amount of bytes.
+ bool CanRead(size_t bytes) const;
+
+ // To be called when a read fails for any reason.
+ void OnFailure();
+
+ // TODO(fkastenholz, b/73004262) change buffer_, et al, to be uint8_t, not
+ // char. The data buffer that we're reading from.
+ const char* data_;
+
+ // The length of the data buffer that we're reading from.
+ size_t len_;
+
+ // The location of the next read from our data buffer.
+ size_t pos_;
+
+ // The endianness to read integers and floating numbers.
+ Endianness endianness_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_QUIC_DATA_READER_H_
