OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_frame_builder.h" | 5 #include "net/spdy/spdy_frame_builder.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "net/spdy/spdy_framer.h" | 10 #include "net/spdy/spdy_framer.h" |
11 #include "net/spdy/spdy_protocol.h" | 11 #include "net/spdy/spdy_protocol.h" |
12 | 12 |
13 namespace net { | 13 namespace net { |
14 | 14 |
15 namespace { | 15 namespace { |
16 | 16 |
17 // A special structure for the 8 bit flags and 24 bit length fields. | 17 // A special structure for the 8 bit flags and 24 bit length fields. |
18 union FlagsAndLength { | 18 union FlagsAndLength { |
19 uint8 flags[4]; // 8 bits | 19 uint8_t flags[4]; // 8 bits |
20 uint32 length; // 24 bits | 20 uint32_t length; // 24 bits |
21 }; | 21 }; |
22 | 22 |
23 // Creates a FlagsAndLength. | 23 // Creates a FlagsAndLength. |
24 FlagsAndLength CreateFlagsAndLength(uint8 flags, size_t length) { | 24 FlagsAndLength CreateFlagsAndLength(uint8_t flags, size_t length) { |
25 DCHECK_EQ(0u, length & ~static_cast<size_t>(kLengthMask)); | 25 DCHECK_EQ(0u, length & ~static_cast<size_t>(kLengthMask)); |
26 FlagsAndLength flags_length; | 26 FlagsAndLength flags_length; |
27 flags_length.length = base::HostToNet32(static_cast<uint32>(length)); | 27 flags_length.length = base::HostToNet32(static_cast<uint32_t>(length)); |
28 DCHECK_EQ(0, flags & ~kControlFlagsMask); | 28 DCHECK_EQ(0, flags & ~kControlFlagsMask); |
29 flags_length.flags[0] = flags; | 29 flags_length.flags[0] = flags; |
30 return flags_length; | 30 return flags_length; |
31 } | 31 } |
32 | 32 |
33 } // namespace | 33 } // namespace |
34 | 34 |
35 SpdyFrameBuilder::SpdyFrameBuilder(size_t size, SpdyMajorVersion version) | 35 SpdyFrameBuilder::SpdyFrameBuilder(size_t size, SpdyMajorVersion version) |
36 : buffer_(new char[size]), | 36 : buffer_(new char[size]), |
37 capacity_(size), | 37 capacity_(size), |
(...skipping 16 matching lines...) Expand all Loading... |
54 if (!CanWrite(length)) { | 54 if (!CanWrite(length)) { |
55 return false; | 55 return false; |
56 } | 56 } |
57 | 57 |
58 length_ += length; | 58 length_ += length; |
59 return true; | 59 return true; |
60 } | 60 } |
61 | 61 |
62 bool SpdyFrameBuilder::WriteControlFrameHeader(const SpdyFramer& framer, | 62 bool SpdyFrameBuilder::WriteControlFrameHeader(const SpdyFramer& framer, |
63 SpdyFrameType type, | 63 SpdyFrameType type, |
64 uint8 flags) { | 64 uint8_t flags) { |
65 DCHECK_GE(SPDY3, version_); | 65 DCHECK_GE(SPDY3, version_); |
66 DCHECK(SpdyConstants::IsValidFrameType( | 66 DCHECK(SpdyConstants::IsValidFrameType( |
67 version_, SpdyConstants::SerializeFrameType(version_, type))); | 67 version_, SpdyConstants::SerializeFrameType(version_, type))); |
68 bool success = true; | 68 bool success = true; |
69 FlagsAndLength flags_length = CreateFlagsAndLength( | 69 FlagsAndLength flags_length = CreateFlagsAndLength( |
70 flags, capacity_ - framer.GetControlFrameHeaderSize()); | 70 flags, capacity_ - framer.GetControlFrameHeaderSize()); |
71 success &= WriteUInt16(kControlFlagMask | | 71 success &= WriteUInt16(kControlFlagMask | |
72 SpdyConstants::SerializeMajorVersion(version_)); | 72 SpdyConstants::SerializeMajorVersion(version_)); |
73 success &= WriteUInt16( | 73 success &= WriteUInt16( |
74 SpdyConstants::SerializeFrameType(framer.protocol_version(), type)); | 74 SpdyConstants::SerializeFrameType(framer.protocol_version(), type)); |
75 success &= WriteBytes(&flags_length, sizeof(flags_length)); | 75 success &= WriteBytes(&flags_length, sizeof(flags_length)); |
76 DCHECK_EQ(framer.GetControlFrameHeaderSize(), length()); | 76 DCHECK_EQ(framer.GetControlFrameHeaderSize(), length()); |
77 return success; | 77 return success; |
78 } | 78 } |
79 | 79 |
80 bool SpdyFrameBuilder::WriteDataFrameHeader(const SpdyFramer& framer, | 80 bool SpdyFrameBuilder::WriteDataFrameHeader(const SpdyFramer& framer, |
81 SpdyStreamId stream_id, | 81 SpdyStreamId stream_id, |
82 uint8 flags) { | 82 uint8_t flags) { |
83 if (version_ > SPDY3) { | 83 if (version_ > SPDY3) { |
84 return BeginNewFrame(framer, DATA, flags, stream_id); | 84 return BeginNewFrame(framer, DATA, flags, stream_id); |
85 } | 85 } |
86 DCHECK_EQ(0u, stream_id & ~kStreamIdMask); | 86 DCHECK_EQ(0u, stream_id & ~kStreamIdMask); |
87 bool success = true; | 87 bool success = true; |
88 success &= WriteUInt32(stream_id); | 88 success &= WriteUInt32(stream_id); |
89 size_t length_field = capacity_ - framer.GetDataFrameMinimumSize(); | 89 size_t length_field = capacity_ - framer.GetDataFrameMinimumSize(); |
90 DCHECK_EQ(0u, length_field & ~static_cast<size_t>(kLengthMask)); | 90 DCHECK_EQ(0u, length_field & ~static_cast<size_t>(kLengthMask)); |
91 FlagsAndLength flags_length; | 91 FlagsAndLength flags_length; |
92 flags_length.length = base::HostToNet32(static_cast<uint32>(length_field)); | 92 flags_length.length = base::HostToNet32(static_cast<uint32_t>(length_field)); |
93 DCHECK_EQ(0, flags & ~kDataFlagsMask); | 93 DCHECK_EQ(0, flags & ~kDataFlagsMask); |
94 flags_length.flags[0] = flags; | 94 flags_length.flags[0] = flags; |
95 success &= WriteBytes(&flags_length, sizeof(flags_length)); | 95 success &= WriteBytes(&flags_length, sizeof(flags_length)); |
96 DCHECK_EQ(framer.GetDataFrameMinimumSize(), length()); | 96 DCHECK_EQ(framer.GetDataFrameMinimumSize(), length()); |
97 return success; | 97 return success; |
98 } | 98 } |
99 | 99 |
100 bool SpdyFrameBuilder::BeginNewFrame(const SpdyFramer& framer, | 100 bool SpdyFrameBuilder::BeginNewFrame(const SpdyFramer& framer, |
101 SpdyFrameType type, | 101 SpdyFrameType type, |
102 uint8 flags, | 102 uint8_t flags, |
103 SpdyStreamId stream_id) { | 103 SpdyStreamId stream_id) { |
104 DCHECK(SpdyConstants::IsValidFrameType( | 104 DCHECK(SpdyConstants::IsValidFrameType( |
105 version_, SpdyConstants::SerializeFrameType(version_, type))); | 105 version_, SpdyConstants::SerializeFrameType(version_, type))); |
106 DCHECK_EQ(0u, stream_id & ~kStreamIdMask); | 106 DCHECK_EQ(0u, stream_id & ~kStreamIdMask); |
107 DCHECK_GT(framer.protocol_version(), SPDY3); | 107 DCHECK_GT(framer.protocol_version(), SPDY3); |
108 bool success = true; | 108 bool success = true; |
109 if (length_ > 0) { | 109 if (length_ > 0) { |
110 // Update length field for previous frame. | 110 // Update length field for previous frame. |
111 OverwriteLength(framer, length_ - framer.GetPrefixLength(type)); | 111 OverwriteLength(framer, length_ - framer.GetPrefixLength(type)); |
112 DLOG_IF(DFATAL, SpdyConstants::GetFrameMaximumSize(version_) < length_) | 112 DLOG_IF(DFATAL, SpdyConstants::GetFrameMaximumSize(version_) < length_) |
(...skipping 16 matching lines...) Expand all Loading... |
129 DCHECK_EQ(framer.GetDataFrameMinimumSize(), length_); | 129 DCHECK_EQ(framer.GetDataFrameMinimumSize(), length_); |
130 return success; | 130 return success; |
131 } | 131 } |
132 | 132 |
133 bool SpdyFrameBuilder::WriteStringPiece16(const base::StringPiece& value) { | 133 bool SpdyFrameBuilder::WriteStringPiece16(const base::StringPiece& value) { |
134 if (value.size() > 0xffff) { | 134 if (value.size() > 0xffff) { |
135 DCHECK(false) << "Tried to write string with length > 16bit."; | 135 DCHECK(false) << "Tried to write string with length > 16bit."; |
136 return false; | 136 return false; |
137 } | 137 } |
138 | 138 |
139 if (!WriteUInt16(static_cast<uint16>(value.size()))) { | 139 if (!WriteUInt16(static_cast<uint16_t>(value.size()))) { |
140 return false; | 140 return false; |
141 } | 141 } |
142 | 142 |
143 return WriteBytes(value.data(), static_cast<uint16>(value.size())); | 143 return WriteBytes(value.data(), static_cast<uint16_t>(value.size())); |
144 } | 144 } |
145 | 145 |
146 bool SpdyFrameBuilder::WriteStringPiece32(const base::StringPiece& value) { | 146 bool SpdyFrameBuilder::WriteStringPiece32(const base::StringPiece& value) { |
147 if (!WriteUInt32(value.size())) { | 147 if (!WriteUInt32(value.size())) { |
148 return false; | 148 return false; |
149 } | 149 } |
150 | 150 |
151 return WriteBytes(value.data(), value.size()); | 151 return WriteBytes(value.data(), value.size()); |
152 } | 152 } |
153 | 153 |
154 bool SpdyFrameBuilder::WriteBytes(const void* data, uint32 data_len) { | 154 bool SpdyFrameBuilder::WriteBytes(const void* data, uint32_t data_len) { |
155 if (!CanWrite(data_len)) { | 155 if (!CanWrite(data_len)) { |
156 return false; | 156 return false; |
157 } | 157 } |
158 | 158 |
159 char* dest = GetWritableBuffer(data_len); | 159 char* dest = GetWritableBuffer(data_len); |
160 memcpy(dest, data, data_len); | 160 memcpy(dest, data, data_len); |
161 Seek(data_len); | 161 Seek(data_len); |
162 return true; | 162 return true; |
163 } | 163 } |
164 | 164 |
(...skipping 25 matching lines...) Expand all Loading... |
190 sizeof(flags_length) - 1); | 190 sizeof(flags_length) - 1); |
191 } else { | 191 } else { |
192 length_ = 0; | 192 length_ = 0; |
193 success = WriteUInt24(length); | 193 success = WriteUInt24(length); |
194 } | 194 } |
195 | 195 |
196 length_ = old_length; | 196 length_ = old_length; |
197 return success; | 197 return success; |
198 } | 198 } |
199 | 199 |
200 bool SpdyFrameBuilder::OverwriteFlags(const SpdyFramer& framer, | 200 bool SpdyFrameBuilder::OverwriteFlags(const SpdyFramer& framer, uint8_t flags) { |
201 uint8 flags) { | |
202 DCHECK_GT(framer.protocol_version(), SPDY3); | 201 DCHECK_GT(framer.protocol_version(), SPDY3); |
203 bool success = false; | 202 bool success = false; |
204 const size_t old_length = length_; | 203 const size_t old_length = length_; |
205 // Flags are the fifth octet in the frame prefix. | 204 // Flags are the fifth octet in the frame prefix. |
206 length_ = 4; | 205 length_ = 4; |
207 success = WriteUInt8(flags); | 206 success = WriteUInt8(flags); |
208 length_ = old_length; | 207 length_ = old_length; |
209 return success; | 208 return success; |
210 } | 209 } |
211 | 210 |
212 bool SpdyFrameBuilder::CanWrite(size_t length) const { | 211 bool SpdyFrameBuilder::CanWrite(size_t length) const { |
213 if (length > kLengthMask) { | 212 if (length > kLengthMask) { |
214 DCHECK(false); | 213 DCHECK(false); |
215 return false; | 214 return false; |
216 } | 215 } |
217 | 216 |
218 if (offset_ + length_ + length > capacity_) { | 217 if (offset_ + length_ + length > capacity_) { |
219 DCHECK(false); | 218 DCHECK(false); |
220 return false; | 219 return false; |
221 } | 220 } |
222 | 221 |
223 return true; | 222 return true; |
224 } | 223 } |
225 | 224 |
226 } // namespace net | 225 } // namespace net |
OLD | NEW |