1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// 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 NET_QUIC_CORE_QUIC_DATA_READER_H_
#define NET_QUIC_CORE_QUIC_DATA_READER_H_
#include <cstddef>
#include <cstdint>
#include "base/macros.h"
#include "net/base/int128.h"
#include "net/quic/core/quic_types.h"
#include "net/quic/platform/api/quic_export.h"
#include "net/quic/platform/api/quic_string_piece.h"
namespace net {
// 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:
// Caller must provide an underlying buffer to work on.
QuicDataReader(const char* data, const size_t len, Perspective perspective);
// Empty destructor.
~QuicDataReader() {}
// Reads a 16-bit unsigned integer into the given output parameter.
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
bool ReadUInt16(uint16_t* result);
// Reads a 32-bit unsigned integer into the given output parameter.
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
bool ReadUInt32(uint32_t* result);
// Reads a 64-bit unsigned integer into the given output parameter.
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
bool ReadUInt64(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 represented as 64-bit unsigned integer into the given
// output parameter.
// Forwards the internal iterator on success.
// Returns true on success, false otherwise.
// TODO(fayang): Remove this method and use ReadUInt64() once deprecating
// quic_restart_flag_quic_rw_cid_in_big_endian and QuicDataReader has a mode
// indicating reading in little/big endian.
bool ReadConnectionId(uint64_t* connection_id);
// Returns the remaining payload as a QuicStringPiece.
// 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();
// 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 number of bytes remaining to be read.
size_t BytesRemaining() 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();
// The data buffer that we're reading from.
const char* data_;
// The length of the data buffer that we're reading from.
const size_t len_;
// The location of the next read from our data buffer.
size_t pos_;
// Perspective of this data reader. Please note, although client and server
// may have different in-memory representation of the same field, the on wire
// representation must be consistent.
Perspective perspective_;
DISALLOW_COPY_AND_ASSIGN(QuicDataReader);
};
} // namespace net
#endif // NET_QUIC_CORE_QUIC_DATA_READER_H_
|
