blob: 43e9c1d1cebf72cb2155ed78f33613868d67cb1e [file] [log] [blame] [edit]
// Copyright (c) 2020 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_COMMON_QUICHE_DATA_READER_H_
#define QUICHE_COMMON_QUICHE_DATA_READER_H_
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string>
#include "absl/strings/string_view.h"
#include "quiche/common/platform/api/quiche_export.h"
#include "quiche/common/platform/api/quiche_logging.h"
#include "quiche/common/quiche_endian.h"
namespace quiche {
// To use, simply construct a QuicheDataReader 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 QuicheDataReader 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 QUICHE_EXPORT QuicheDataReader {
public:
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
explicit QuicheDataReader(absl::string_view data);
// Constructs a reader using NETWORK_BYTE_ORDER endianness.
// Caller must provide an underlying buffer to work on.
QuicheDataReader(const char* data, const size_t len);
// Constructs a reader using the specified endianness.
// Caller must provide an underlying buffer to work on.
QuicheDataReader(const char* data, const size_t len,
quiche::Endianness endianness);
QuicheDataReader(const QuicheDataReader&) = delete;
QuicheDataReader& operator=(const QuicheDataReader&) = delete;
// Empty destructor.
~QuicheDataReader() {}
// Reads an 8/16/24/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 ReadUInt24(uint32_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 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(absl::string_view* result);
// Reads a string prefixed with 8-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 ReadStringPiece8(absl::string_view* 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(absl::string_view* result, size_t size);
// Reads at most a given number of bytes into the provided view.
absl::string_view ReadAtMost(size_t size);
// 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);
// Reads a sequence of a fixed number of decimal digits, parses them as an
// unsigned integer and returns them as a uint64_t. Forwards internal
// iterator on success, may forward it even in case of failure.
bool ReadDecimal64(size_t num_digits, uint64_t* result);
// 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.
QuicheVariableLengthIntegerLength PeekVarInt62Length();
// Read an RFC 9000 62-bit Variable Length Integer and place the result in
// |*result|. Returns false if there is not enough space in the buffer to read
// the number, true otherwise. If false is returned, |*result| is not altered.
bool ReadVarInt62(uint64_t* result);
// Reads a string prefixed with a RFC 9000 62-bit variable Length integer
// 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!
//
// Returns false if there is not enough space in the buffer to read
// the number and subsequent string, true otherwise.
bool ReadStringPieceVarInt62(absl::string_view* result);
// Reads a string prefixed with a RFC 9000 varint length prefix, and copies it
// into the provided string.
//
// Returns false if there is not enough space in the buffer to read
// the number and subsequent string, true otherwise.
bool ReadStringVarInt62(std::string& result);
// Returns the remaining payload as a absl::string_view.
//
// 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.
absl::string_view ReadRemainingPayload();
// Returns the remaining payload as a absl::string_view.
//
// 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.
absl::string_view PeekRemainingPayload() const;
// Returns the entire payload as a absl::string_view.
//
// 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.
absl::string_view FullPayload() const;
// Returns the part of the payload that has been already read as a
// absl::string_view.
//
// 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.
absl::string_view PreviouslyReadPayload() 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);
// Skips over |size| bytes from the buffer and forwards the internal iterator.
// Returns true if there are at least |size| bytes remaining to read, false
// otherwise.
bool Seek(size_t size);
// Returns true if the entirety of the underlying buffer has been read via
// Read*() calls.
bool IsDoneReading() const;
// 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 greater 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;
std::string DebugString() const;
protected:
// 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();
const char* data() const { return data_; }
size_t pos() const { return pos_; }
void AdvancePos(size_t amount) {
QUICHE_DCHECK_LE(pos_, std::numeric_limits<size_t>::max() - amount);
QUICHE_DCHECK_LE(pos_, len_ - amount);
pos_ += amount;
}
quiche::Endianness endianness() const { return endianness_; }
private:
// 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.
quiche::Endianness endianness_;
};
} // namespace quiche
#endif // QUICHE_COMMON_QUICHE_DATA_READER_H_