OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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_headers_block_parser.h" | 5 #include "net/spdy/spdy_headers_block_parser.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
(...skipping 24 matching lines...) Expand all Loading... |
35 }; | 35 }; |
36 | 36 |
37 class SpdyHeadersBlockParserTest : | 37 class SpdyHeadersBlockParserTest : |
38 public ::testing::TestWithParam<SpdyMajorVersion> { | 38 public ::testing::TestWithParam<SpdyMajorVersion> { |
39 public: | 39 public: |
40 ~SpdyHeadersBlockParserTest() override {} | 40 ~SpdyHeadersBlockParserTest() override {} |
41 | 41 |
42 protected: | 42 protected: |
43 void SetUp() override { | 43 void SetUp() override { |
44 // Create a parser using the mock handler. | 44 // Create a parser using the mock handler. |
45 spdy_version_ = GetParam(); | 45 parser_.reset(new SpdyHeadersBlockParser(HTTP2, &handler_)); |
46 | |
47 parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_)); | |
48 } | 46 } |
49 | 47 |
50 // Create a header block with a specified number of headers. | 48 // Create a header block with a specified number of headers. |
51 string CreateHeaders(uint32_t num_headers, bool insert_nulls) { | 49 string CreateHeaders(uint32_t num_headers, bool insert_nulls) { |
52 string headers; | 50 string headers; |
53 | 51 |
54 // First, write the number of headers in the header block. | 52 // First, write the number of headers in the header block. |
55 headers += EncodeLength(num_headers); | 53 headers += EncodeLength(num_headers); |
56 | 54 |
57 // Second, write the key-value pairs. | 55 // Second, write the key-value pairs. |
(...skipping 23 matching lines...) Expand all Loading... |
81 return headers; | 79 return headers; |
82 } | 80 } |
83 | 81 |
84 string EncodeLength(uint32_t len) { | 82 string EncodeLength(uint32_t len) { |
85 char buffer[4]; | 83 char buffer[4]; |
86 uint32_t net_order_len = base::HostToNet32(len); | 84 uint32_t net_order_len = base::HostToNet32(len); |
87 memcpy(buffer, &net_order_len, sizeof(uint32_t)); | 85 memcpy(buffer, &net_order_len, sizeof(uint32_t)); |
88 return string(buffer, sizeof(uint32_t)); | 86 return string(buffer, sizeof(uint32_t)); |
89 } | 87 } |
90 | 88 |
91 SpdyMajorVersion spdy_version_; | |
92 | |
93 MockSpdyHeadersHandler handler_; | 89 MockSpdyHeadersHandler handler_; |
94 std::unique_ptr<SpdyHeadersBlockParser> parser_; | 90 std::unique_ptr<SpdyHeadersBlockParser> parser_; |
95 | 91 |
96 static const char *const kBaseKey; | 92 static const char *const kBaseKey; |
97 static const char *const kBaseValue; | 93 static const char *const kBaseValue; |
98 | 94 |
99 // Number of headers and header blocks used in the tests. | 95 // Number of headers and header blocks used in the tests. |
100 static const int kNumHeadersInBlock = 10; | 96 static const int kNumHeadersInBlock = 10; |
101 static const int kNumHeaderBlocks = 10; | 97 static const int kNumHeaderBlocks = 10; |
102 }; | 98 }; |
103 | 99 |
104 const char *const SpdyHeadersBlockParserTest::kBaseKey = "test_key"; | 100 const char *const SpdyHeadersBlockParserTest::kBaseKey = "test_key"; |
105 const char *const SpdyHeadersBlockParserTest::kBaseValue = "test_value"; | 101 const char *const SpdyHeadersBlockParserTest::kBaseValue = "test_value"; |
106 | 102 |
107 // All tests are run with SPDY/3 and HTTP/2. | 103 TEST_F(SpdyHeadersBlockParserTest, BasicTest) { |
108 INSTANTIATE_TEST_CASE_P(SpdyHeadersBlockParserTests, | |
109 SpdyHeadersBlockParserTest, | |
110 ::testing::Values(SPDY3, HTTP2)); | |
111 | |
112 TEST_P(SpdyHeadersBlockParserTest, BasicTest) { | |
113 // Sanity test, verify that we parse out correctly a block with | 104 // Sanity test, verify that we parse out correctly a block with |
114 // a single key-value pair and that we notify when we start and finish | 105 // a single key-value pair and that we notify when we start and finish |
115 // handling a headers block. | 106 // handling a headers block. |
116 EXPECT_EQ(spdy_version_, parser_->spdy_version()); | |
117 | 107 |
118 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); | 108 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); |
119 string expect_key = kBaseKey + IntToString(0); | 109 string expect_key = kBaseKey + IntToString(0); |
120 string expect_value = kBaseValue + IntToString(0); | 110 string expect_value = kBaseValue + IntToString(0); |
121 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), | 111 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), |
122 StringPiece(expect_value))).Times(1); | 112 StringPiece(expect_value))).Times(1); |
123 | 113 |
124 string headers(CreateHeaders(1, false)); | 114 string headers(CreateHeaders(1, false)); |
125 if (FLAGS_chromium_http2_flag_log_compressed_size) { | 115 if (FLAGS_chromium_http2_flag_log_compressed_size) { |
126 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); | 116 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); |
127 } else { | 117 } else { |
128 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); | 118 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); |
129 } | 119 } |
130 EXPECT_TRUE(parser_-> | 120 EXPECT_TRUE(parser_-> |
131 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); | 121 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); |
132 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); | 122 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); |
133 } | 123 } |
134 | 124 |
135 TEST_P(SpdyHeadersBlockParserTest, NullsSupportedTest) { | 125 TEST_F(SpdyHeadersBlockParserTest, NullsSupportedTest) { |
136 // Sanity test, verify that we parse out correctly a block with | 126 // Sanity test, verify that we parse out correctly a block with |
137 // a single key-value pair when the key and value contain null charecters. | 127 // a single key-value pair when the key and value contain null charecters. |
138 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); | 128 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); |
139 | 129 |
140 string expect_key = kBaseKey + string("\0", 1) + IntToString(0); | 130 string expect_key = kBaseKey + string("\0", 1) + IntToString(0); |
141 string expect_value = kBaseValue + string("\0", 1) + IntToString(0); | 131 string expect_value = kBaseValue + string("\0", 1) + IntToString(0); |
142 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), | 132 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), |
143 StringPiece(expect_value))).Times(1); | 133 StringPiece(expect_value))).Times(1); |
144 | 134 |
145 string headers(CreateHeaders(1, true)); | 135 string headers(CreateHeaders(1, true)); |
146 if (FLAGS_chromium_http2_flag_log_compressed_size) { | 136 if (FLAGS_chromium_http2_flag_log_compressed_size) { |
147 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); | 137 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); |
148 } else { | 138 } else { |
149 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); | 139 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); |
150 } | 140 } |
151 | 141 |
152 EXPECT_TRUE(parser_-> | 142 EXPECT_TRUE(parser_-> |
153 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); | 143 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); |
154 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); | 144 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); |
155 } | 145 } |
156 | 146 |
157 TEST_P(SpdyHeadersBlockParserTest, MultipleBlocksAndHeadersWithPartialData) { | 147 TEST_F(SpdyHeadersBlockParserTest, MultipleBlocksAndHeadersWithPartialData) { |
158 testing::InSequence s; | 148 testing::InSequence s; |
159 | 149 |
160 // CreateHeaders is deterministic; we can call it once for the whole test. | 150 // CreateHeaders is deterministic; we can call it once for the whole test. |
161 string headers(CreateHeaders(kNumHeadersInBlock, false)); | 151 string headers(CreateHeaders(kNumHeadersInBlock, false)); |
162 | 152 |
163 // The mock doesn't retain storage of arguments, so keep them in scope. | 153 // The mock doesn't retain storage of arguments, so keep them in scope. |
164 std::vector<string> retained_arguments; | 154 std::vector<string> retained_arguments; |
165 for (int i = 0; i < kNumHeadersInBlock; i++) { | 155 for (int i = 0; i < kNumHeadersInBlock; i++) { |
166 retained_arguments.push_back(kBaseKey + IntToString(i)); | 156 retained_arguments.push_back(kBaseKey + IntToString(i)); |
167 retained_arguments.push_back(kBaseValue + IntToString(i)); | 157 retained_arguments.push_back(kBaseValue + IntToString(i)); |
(...skipping 21 matching lines...) Expand all Loading... |
189 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, | 179 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, |
190 parser_->get_error()); | 180 parser_->get_error()); |
191 } else { | 181 } else { |
192 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(i, &(*it), 1)); | 182 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(i, &(*it), 1)); |
193 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); | 183 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); |
194 } | 184 } |
195 } | 185 } |
196 } | 186 } |
197 } | 187 } |
198 | 188 |
199 TEST_P(SpdyHeadersBlockParserTest, HandlesEmptyCallsTest) { | 189 TEST_F(SpdyHeadersBlockParserTest, HandlesEmptyCallsTest) { |
200 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); | 190 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); |
201 | 191 |
202 string expect_key = kBaseKey + IntToString(0); | 192 string expect_key = kBaseKey + IntToString(0); |
203 string expect_value = kBaseValue + IntToString(0); | 193 string expect_value = kBaseValue + IntToString(0); |
204 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), | 194 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), |
205 StringPiece(expect_value))).Times(1); | 195 StringPiece(expect_value))).Times(1); |
206 | 196 |
207 string headers(CreateHeaders(1, false)); | 197 string headers(CreateHeaders(1, false)); |
208 if (FLAGS_chromium_http2_flag_log_compressed_size) { | 198 if (FLAGS_chromium_http2_flag_log_compressed_size) { |
209 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); | 199 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); |
210 } else { | 200 } else { |
211 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); | 201 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); |
212 } | 202 } |
213 | 203 |
214 // Send a header in pieces with intermediate empty calls. | 204 // Send a header in pieces with intermediate empty calls. |
215 for (string::iterator it = headers.begin(); it != headers.end(); ++it) { | 205 for (string::iterator it = headers.begin(); it != headers.end(); ++it) { |
216 if ((it + 1) == headers.end()) { | 206 if ((it + 1) == headers.end()) { |
217 // Last byte completes the block. | 207 // Last byte completes the block. |
218 EXPECT_TRUE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); | 208 EXPECT_TRUE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); |
219 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); | 209 EXPECT_EQ(SpdyHeadersBlockParser::NO_PARSER_ERROR, parser_->get_error()); |
220 } else { | 210 } else { |
221 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); | 211 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, &(*it), 1)); |
222 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); | 212 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); |
223 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, NULL, 0)); | 213 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, NULL, 0)); |
224 } | 214 } |
225 } | 215 } |
226 } | 216 } |
227 | 217 |
228 TEST_P(SpdyHeadersBlockParserTest, LargeBlocksDiscardedTest) { | 218 TEST_F(SpdyHeadersBlockParserTest, LargeBlocksDiscardedTest) { |
229 // Header block with too many headers. | 219 // Header block with too many headers. |
230 { | 220 { |
231 string headers = EncodeLength(parser_->MaxNumberOfHeaders() + 1); | 221 string headers = EncodeLength(parser_->MaxNumberOfHeaders() + 1); |
232 EXPECT_FALSE(parser_-> | 222 EXPECT_FALSE(parser_-> |
233 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); | 223 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); |
234 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_BLOCK_TOO_LARGE, | 224 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_BLOCK_TOO_LARGE, |
235 parser_->get_error()); | 225 parser_->get_error()); |
236 } | 226 } |
237 parser_.reset(new SpdyHeadersBlockParser(spdy_version_, &handler_)); | 227 parser_.reset(new SpdyHeadersBlockParser(HTTP2, &handler_)); |
238 // Header block with one header, which has a too-long key. | 228 // Header block with one header, which has a too-long key. |
239 { | 229 { |
240 string headers = EncodeLength(1) + EncodeLength( | 230 string headers = EncodeLength(1) + EncodeLength( |
241 SpdyHeadersBlockParser::kMaximumFieldLength + 1); | 231 SpdyHeadersBlockParser::kMaximumFieldLength + 1); |
242 EXPECT_FALSE(parser_-> | 232 EXPECT_FALSE(parser_-> |
243 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); | 233 HandleControlFrameHeadersData(1, headers.c_str(), headers.length())); |
244 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_FIELD_TOO_LARGE, | 234 EXPECT_EQ(SpdyHeadersBlockParser::HEADER_FIELD_TOO_LARGE, |
245 parser_->get_error()); | 235 parser_->get_error()); |
246 } | 236 } |
247 } | 237 } |
248 | 238 |
249 TEST_P(SpdyHeadersBlockParserTest, ExtraDataTest) { | 239 TEST_F(SpdyHeadersBlockParserTest, ExtraDataTest) { |
250 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); | 240 EXPECT_CALL(handler_, OnHeaderBlockStart()).Times(1); |
251 | 241 |
252 string expect_key = kBaseKey + IntToString(0); | 242 string expect_key = kBaseKey + IntToString(0); |
253 string expect_value = kBaseValue + IntToString(0); | 243 string expect_value = kBaseValue + IntToString(0); |
254 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), | 244 EXPECT_CALL(handler_, OnHeader(StringPiece(expect_key), |
255 StringPiece(expect_value))).Times(1); | 245 StringPiece(expect_value))).Times(1); |
256 | 246 |
257 string headers = CreateHeaders(1, false) + "foobar"; | 247 string headers = CreateHeaders(1, false) + "foobar"; |
258 if (FLAGS_chromium_http2_flag_log_compressed_size) { | 248 if (FLAGS_chromium_http2_flag_log_compressed_size) { |
259 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); | 249 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length(), _)).Times(1); |
260 } else { | 250 } else { |
261 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); | 251 EXPECT_CALL(handler_, OnHeaderBlockEnd(headers.length())).Times(1); |
262 } | 252 } |
263 | 253 |
264 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.c_str(), | 254 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.c_str(), |
265 headers.length())); | 255 headers.length())); |
266 EXPECT_EQ(SpdyHeadersBlockParser::TOO_MUCH_DATA, parser_->get_error()); | 256 EXPECT_EQ(SpdyHeadersBlockParser::TOO_MUCH_DATA, parser_->get_error()); |
267 } | 257 } |
268 | 258 |
269 TEST_P(SpdyHeadersBlockParserTest, WrongStreamIdTest) { | 259 TEST_F(SpdyHeadersBlockParserTest, WrongStreamIdTest) { |
270 string headers(CreateHeaders(kNumHeadersInBlock, false)); | 260 string headers(CreateHeaders(kNumHeadersInBlock, false)); |
271 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.data(), 1)); | 261 EXPECT_FALSE(parser_->HandleControlFrameHeadersData(1, headers.data(), 1)); |
272 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); | 262 EXPECT_EQ(SpdyHeadersBlockParser::NEED_MORE_DATA, parser_->get_error()); |
273 bool result; | 263 bool result; |
274 EXPECT_SPDY_BUG( | 264 EXPECT_SPDY_BUG( |
275 result = parser_->HandleControlFrameHeadersData(2, headers.data() + 1, 1), | 265 result = parser_->HandleControlFrameHeadersData(2, headers.data() + 1, 1), |
276 "Unexpected stream id: 2 \\(expected 1\\)"); | 266 "Unexpected stream id: 2 \\(expected 1\\)"); |
277 EXPECT_FALSE(result); | 267 EXPECT_FALSE(result); |
278 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); | 268 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); |
279 } | 269 } |
280 | 270 |
281 TEST_P(SpdyHeadersBlockParserTest, InvalidStreamIdTest) { | 271 TEST_F(SpdyHeadersBlockParserTest, InvalidStreamIdTest) { |
282 string headers(CreateHeaders(kNumHeadersInBlock, false)); | 272 string headers(CreateHeaders(kNumHeadersInBlock, false)); |
283 bool result; | 273 bool result; |
284 EXPECT_SPDY_BUG( | 274 EXPECT_SPDY_BUG( |
285 result = parser_->HandleControlFrameHeadersData(0, headers.data(), 1), | 275 result = parser_->HandleControlFrameHeadersData(0, headers.data(), 1), |
286 "Expected nonzero stream id, saw: 0"); | 276 "Expected nonzero stream id, saw: 0"); |
287 EXPECT_FALSE(result); | 277 EXPECT_FALSE(result); |
288 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); | 278 EXPECT_EQ(SpdyHeadersBlockParser::UNEXPECTED_STREAM_ID, parser_->get_error()); |
289 } | 279 } |
290 | 280 |
291 } // namespace net | 281 } // namespace net |
OLD | NEW |