net/quic/quic_data_reader.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_QUIC_QUIC_DATA_READER_H_
   6 #define NET_QUIC_QUIC_DATA_READER_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/strings/string_piece.h"
  10 #include "net/base/int128.h"
  11 #include "net/base/net_export.h"
  12
  13 namespace net {
  14
  15 // Used for reading QUIC data. Though there isn't really anything terribly
  16 // QUIC-specific here, it's a helper class that's useful when doing QUIC
  17 // framing.
  18 //
  19 // To use, simply construct a QuicDataReader using the underlying buffer that
  20 // you'd like to read fields from, then call one of the Read*() methods to
  21 // actually do some reading.
  22 //
  23 // This class keeps an internal iterator to keep track of what's already been
  24 // read and each successive Read*() call automatically increments said iterator
  25 // on success. On failure, internal state of the QuicDataReader should not be
  26 // trusted and it is up to the caller to throw away the failed instance and
  27 // handle the error as appropriate. None of the Read*() methods should ever be
  28 // called after failure, as they will also fail immediately.
  29 class NET_EXPORT_PRIVATE QuicDataReader {
  30  public:
  31   // Caller must provide an underlying buffer to work on.
  32   QuicDataReader(const char* data, const size_t len);
  33
  34   // Empty destructor.
  35   ~QuicDataReader() {}
  36
  37   // Reads a 16-bit unsigned integer into the given output parameter.
  38   // Forwards the internal iterator on success.
  39   // Returns true on success, false otherwise.
  40   bool ReadUInt16(uint16* result);
  41
  42   // Reads a 32-bit unsigned integer into the given output parameter.
  43   // Forwards the internal iterator on success.
  44   // Returns true on success, false otherwise.
  45   bool ReadUInt32(uint32* result);
  46
  47   // Reads a 48-bit unsigned integer into the given output parameter.
  48   // Forwards the internal iterator on success.
  49   // Returns true on success, false otherwise.
  50   bool ReadUInt48(uint64* result);
  51
  52   // Reads a 64-bit unsigned integer into the given output parameter.
  53   // Forwards the internal iterator on success.
  54   // Returns true on success, false otherwise.
  55   bool ReadUInt64(uint64* result);
  56
  57   // Reads a 128-bit unsigned integer into the given output parameter.
  58   // Forwards the internal iterator on success.
  59   // Returns true on success, false otherwise.
  60   bool ReadUInt128(uint128* result);
  61
  62   // Reads a 16-bit unsigned float into the given output parameter.
  63   // Forwards the internal iterator on success.
  64   // Returns true on success, false otherwise.
  65   bool ReadUFloat16(uint64* result);
  66
  67   // Reads a string prefixed with 16-bit length into the given output parameter.
  68   //
  69   // NOTE: Does not copy but rather references strings in the underlying buffer.
  70   // This should be kept in mind when handling memory management!
  71   //
  72   // Forwards the internal iterator on success.
  73   // Returns true on success, false otherwise.
  74   bool ReadStringPiece16(base::StringPiece* result);
  75
  76   // Reads a given number of bytes into the given buffer. The buffer
  77   // must be of adequate size.
  78   // Forwards the internal iterator on success.
  79   // Returns true on success, false otherwise.
  80   bool ReadStringPiece(base::StringPiece* result, size_t len);
  81
  82   // Returns the remaining payload as a StringPiece.
  83   //
  84   // NOTE: Does not copy but rather references strings in the underlying buffer.
  85   // This should be kept in mind when handling memory management!
  86   //
  87   // Forwards the internal iterator.
  88   base::StringPiece ReadRemainingPayload();
  89
  90   // Returns the remaining payload as a StringPiece.
  91   //
  92   // NOTE: Does not copy but rather references strings in the underlying buffer.
  93   // This should be kept in mind when handling memory management!
  94   //
  95   // DOES NOT forward the internal iterator.
  96   base::StringPiece PeekRemainingPayload();
  97
  98   // Reads a given number of bytes into the given buffer. The buffer
  99   // must be of adequate size.
 100   // Forwards the internal iterator on success.
 101   // Returns true on success, false otherwise.
 102   bool ReadBytes(void* result, size_t size);
 103
 104   // Returns true if the entirety of the underlying buffer has been read via
 105   // Read*() calls.
 106   bool IsDoneReading() const;
 107
 108   // Returns the number of bytes remaining to be read.
 109   size_t BytesRemaining() const;
 110
 111  private:
 112   // Returns true if the underlying buffer has enough room to read the given
 113   // amount of bytes.
 114   bool CanRead(size_t bytes) const;
 115
 116   // To be called when a read fails for any reason.
 117   void OnFailure();
 118
 119   // The data buffer that we're reading from.
 120   const char* data_;
 121
 122   // The length of the data buffer that we're reading from.
 123   const size_t len_;
 124
 125   // The location of the next read from our data buffer.
 126   size_t pos_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(QuicDataReader);
 129 };
 130
 131 }  // namespace net
 132
 133 #endif  // NET_QUIC_QUIC_DATA_READER_H_