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
13namespace 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.
29class 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_
134