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#include <limits>
6
7#include "base/sys_byteorder.h"
8#include "net/spdy/spdy_frame_reader.h"
9#include "net/spdy/spdy_protocol.h"
10
11namespace net {
12
13SpdyFrameReader::SpdyFrameReader(const char* data, const size_t len)
14    : data_(data),
15      len_(len),
16      ofs_(0) {
17}
18
19bool SpdyFrameReader::ReadUInt8(uint8* result) {
20  // Make sure that we have the whole uint8.
21  if (!CanRead(1)) {
22    OnFailure();
23    return false;
24  }
25
26  // Read into result.
27  *result = *reinterpret_cast<const uint8*>(data_ + ofs_);
28
29  // Iterate.
30  ofs_ += 1;
31
32  return true;
33}
34
35bool SpdyFrameReader::ReadUInt16(uint16* result) {
36  // Make sure that we have the whole uint16.
37  if (!CanRead(2)) {
38    OnFailure();
39    return false;
40  }
41
42  // Read into result.
43  *result = ntohs(*(reinterpret_cast<const uint16*>(data_ + ofs_)));
44
45  // Iterate.
46  ofs_ += 2;
47
48  return true;
49}
50
51bool SpdyFrameReader::ReadUInt32(uint32* result) {
52  // Make sure that we have the whole uint32.
53  if (!CanRead(4)) {
54    OnFailure();
55    return false;
56  }
57
58  // Read into result.
59  *result = ntohl(*(reinterpret_cast<const uint32*>(data_ + ofs_)));
60
61  // Iterate.
62  ofs_ += 4;
63
64  return true;
65}
66
67bool SpdyFrameReader::ReadUInt31(uint32* result) {
68  bool success = ReadUInt32(result);
69
70  // Zero out highest-order bit.
71  if (success) {
72    *result &= 0x7fffffff;
73  }
74
75  return success;
76}
77
78bool SpdyFrameReader::ReadUInt24(uint32* result) {
79  // Make sure that we have the whole uint24.
80  if (!CanRead(3)) {
81    OnFailure();
82    return false;
83  }
84
85  // Read into result.
86  *result = 0;
87  memcpy(reinterpret_cast<char*>(result) + 1, data_ + ofs_, 3);
88  *result = ntohl(*result);
89
90  // Iterate.
91  ofs_ += 3;
92
93  return true;
94}
95
96bool SpdyFrameReader::ReadStringPiece16(base::StringPiece* result) {
97  // Read resultant length.
98  uint16 result_len;
99  if (!ReadUInt16(&result_len)) {
100    // OnFailure() already called.
101    return false;
102  }
103
104  // Make sure that we have the whole string.
105  if (!CanRead(result_len)) {
106    OnFailure();
107    return false;
108  }
109
110  // Set result.
111  result->set(data_ + ofs_, result_len);
112
113  // Iterate.
114  ofs_ += result_len;
115
116  return true;
117}
118
119bool SpdyFrameReader::ReadStringPiece32(base::StringPiece* result) {
120  // Read resultant length.
121  uint32 result_len;
122  if (!ReadUInt32(&result_len)) {
123    // OnFailure() already called.
124    return false;
125  }
126
127  // Make sure that we have the whole string.
128  if (!CanRead(result_len)) {
129    OnFailure();
130    return false;
131  }
132
133  // Set result.
134  result->set(data_ + ofs_, result_len);
135
136  // Iterate.
137  ofs_ += result_len;
138
139  return true;
140}
141
142bool SpdyFrameReader::ReadBytes(void* result, size_t size) {
143  // Make sure that we have enough data to read.
144  if (!CanRead(size)) {
145    OnFailure();
146    return false;
147  }
148
149  // Read into result.
150  memcpy(result, data_ + ofs_, size);
151
152  // Iterate.
153  ofs_ += size;
154
155  return true;
156}
157
158bool SpdyFrameReader::Seek(size_t size) {
159  if (!CanRead(size)) {
160    OnFailure();
161    return false;
162  }
163
164  // Iterate.
165  ofs_ += size;
166
167  return true;
168}
169
170bool SpdyFrameReader::IsDoneReading() const {
171  return len_ == ofs_;
172}
173
174bool SpdyFrameReader::CanRead(size_t bytes) const {
175  return bytes <= (len_ - ofs_);
176}
177
178void SpdyFrameReader::OnFailure() {
179  // Set our iterator to the end of the buffer so that further reads fail
180  // immediately.
181  ofs_ = len_;
182}
183
184}  // namespace net
185