| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 "net/spdy/spdy_protocol.h" | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "net/spdy/spdy_bitmasks.h" | |
| 9 #include "net/spdy/spdy_framer.h" | |
| 10 #include "testing/platform_test.h" | |
| 11 | |
| 12 using spdy::CONTROL_FLAG_FIN; | |
| 13 using spdy::CONTROL_FLAG_NONE; | |
| 14 using spdy::GOAWAY; | |
| 15 using spdy::HEADERS; | |
| 16 using spdy::NOOP; | |
| 17 using spdy::NUM_CONTROL_FRAME_TYPES; | |
| 18 using spdy::PING; | |
| 19 using spdy::RST_STREAM; | |
| 20 using spdy::SETTINGS; | |
| 21 using spdy::SYN_REPLY; | |
| 22 using spdy::SYN_STREAM; | |
| 23 using spdy::WINDOW_UPDATE; | |
| 24 using spdy::FlagsAndLength; | |
| 25 using spdy::SpdyControlFrame; | |
| 26 using spdy::SpdyControlType; | |
| 27 using spdy::SpdyDataFrame; | |
| 28 using spdy::SpdyFrame; | |
| 29 using spdy::SpdyFramer; | |
| 30 using spdy::SpdyHeaderBlock; | |
| 31 using spdy::SpdyHeadersControlFrame; | |
| 32 using spdy::SpdyGoAwayControlFrame; | |
| 33 using spdy::SpdyNoOpControlFrame; | |
| 34 using spdy::SpdyPingControlFrame; | |
| 35 using spdy::SpdyRstStreamControlFrame; | |
| 36 using spdy::SpdySettings; | |
| 37 using spdy::SpdySettingsControlFrame; | |
| 38 using spdy::SpdyStatusCodes; | |
| 39 using spdy::SpdySynReplyControlFrame; | |
| 40 using spdy::SpdySynStreamControlFrame; | |
| 41 using spdy::SpdyWindowUpdateControlFrame; | |
| 42 using spdy::SettingsFlagsAndId; | |
| 43 using spdy::kLengthMask; | |
| 44 using spdy::kSpdyProtocolVersion; | |
| 45 using spdy::kStreamIdMask; | |
| 46 | |
| 47 namespace { | |
| 48 | |
| 49 // Test our protocol constants | |
| 50 TEST(SpdyProtocolTest, ProtocolConstants) { | |
| 51 EXPECT_EQ(8u, SpdyFrame::kHeaderSize); | |
| 52 EXPECT_EQ(8u, SpdyDataFrame::size()); | |
| 53 EXPECT_EQ(8u, SpdyControlFrame::kHeaderSize); | |
| 54 EXPECT_EQ(18u, SpdySynStreamControlFrame::size()); | |
| 55 EXPECT_EQ(14u, SpdySynReplyControlFrame::size()); | |
| 56 EXPECT_EQ(16u, SpdyRstStreamControlFrame::size()); | |
| 57 EXPECT_EQ(12u, SpdySettingsControlFrame::size()); | |
| 58 EXPECT_EQ(8u, SpdyNoOpControlFrame::size()); | |
| 59 EXPECT_EQ(12u, SpdyPingControlFrame::size()); | |
| 60 EXPECT_EQ(12u, SpdyGoAwayControlFrame::size()); | |
| 61 EXPECT_EQ(14u, SpdyHeadersControlFrame::size()); | |
| 62 EXPECT_EQ(16u, SpdyWindowUpdateControlFrame::size()); | |
| 63 EXPECT_EQ(4u, sizeof(FlagsAndLength)); | |
| 64 EXPECT_EQ(1, SYN_STREAM); | |
| 65 EXPECT_EQ(2, SYN_REPLY); | |
| 66 EXPECT_EQ(3, RST_STREAM); | |
| 67 EXPECT_EQ(4, SETTINGS); | |
| 68 EXPECT_EQ(5, NOOP); | |
| 69 EXPECT_EQ(6, PING); | |
| 70 EXPECT_EQ(7, GOAWAY); | |
| 71 EXPECT_EQ(8, HEADERS); | |
| 72 EXPECT_EQ(9, WINDOW_UPDATE); | |
| 73 } | |
| 74 | |
| 75 // Test some of the protocol helper functions | |
| 76 TEST(SpdyProtocolTest, FrameStructs) { | |
| 77 SpdyFrame frame(SpdyFrame::kHeaderSize); | |
| 78 frame.set_length(12345); | |
| 79 frame.set_flags(10); | |
| 80 EXPECT_EQ(12345u, frame.length()); | |
| 81 EXPECT_EQ(10u, frame.flags()); | |
| 82 EXPECT_FALSE(frame.is_control_frame()); | |
| 83 | |
| 84 frame.set_length(0); | |
| 85 frame.set_flags(10); | |
| 86 EXPECT_EQ(0u, frame.length()); | |
| 87 EXPECT_EQ(10u, frame.flags()); | |
| 88 EXPECT_FALSE(frame.is_control_frame()); | |
| 89 } | |
| 90 | |
| 91 TEST(SpdyProtocolTest, DataFrameStructs) { | |
| 92 SpdyDataFrame data_frame; | |
| 93 data_frame.set_stream_id(12345); | |
| 94 EXPECT_EQ(12345u, data_frame.stream_id()); | |
| 95 } | |
| 96 | |
| 97 TEST(SpdyProtocolTest, ControlFrameStructs) { | |
| 98 SpdyFramer framer; | |
| 99 SpdyHeaderBlock headers; | |
| 100 | |
| 101 scoped_ptr<SpdySynStreamControlFrame> syn_frame( | |
| 102 framer.CreateSynStream(123, 456, 2, CONTROL_FLAG_FIN, false, &headers)); | |
| 103 EXPECT_EQ(kSpdyProtocolVersion, syn_frame->version()); | |
| 104 EXPECT_TRUE(syn_frame->is_control_frame()); | |
| 105 EXPECT_EQ(SYN_STREAM, syn_frame->type()); | |
| 106 EXPECT_EQ(123u, syn_frame->stream_id()); | |
| 107 EXPECT_EQ(456u, syn_frame->associated_stream_id()); | |
| 108 EXPECT_EQ(2u, syn_frame->priority()); | |
| 109 EXPECT_EQ(2, syn_frame->header_block_len()); | |
| 110 EXPECT_EQ(1u, syn_frame->flags()); | |
| 111 syn_frame->set_associated_stream_id(999u); | |
| 112 EXPECT_EQ(123u, syn_frame->stream_id()); | |
| 113 EXPECT_EQ(999u, syn_frame->associated_stream_id()); | |
| 114 | |
| 115 scoped_ptr<SpdySynReplyControlFrame> syn_reply( | |
| 116 framer.CreateSynReply(123, CONTROL_FLAG_NONE, false, &headers)); | |
| 117 EXPECT_EQ(kSpdyProtocolVersion, syn_reply->version()); | |
| 118 EXPECT_TRUE(syn_reply->is_control_frame()); | |
| 119 EXPECT_EQ(SYN_REPLY, syn_reply->type()); | |
| 120 EXPECT_EQ(123u, syn_reply->stream_id()); | |
| 121 EXPECT_EQ(2, syn_reply->header_block_len()); | |
| 122 EXPECT_EQ(0, syn_reply->flags()); | |
| 123 | |
| 124 scoped_ptr<SpdyRstStreamControlFrame> rst_frame( | |
| 125 framer.CreateRstStream(123, spdy::PROTOCOL_ERROR)); | |
| 126 EXPECT_EQ(kSpdyProtocolVersion, rst_frame->version()); | |
| 127 EXPECT_TRUE(rst_frame->is_control_frame()); | |
| 128 EXPECT_EQ(RST_STREAM, rst_frame->type()); | |
| 129 EXPECT_EQ(123u, rst_frame->stream_id()); | |
| 130 EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status()); | |
| 131 rst_frame->set_status(spdy::INVALID_STREAM); | |
| 132 EXPECT_EQ(spdy::INVALID_STREAM, rst_frame->status()); | |
| 133 EXPECT_EQ(0, rst_frame->flags()); | |
| 134 | |
| 135 scoped_ptr<SpdyNoOpControlFrame> noop_frame( | |
| 136 framer.CreateNopFrame()); | |
| 137 EXPECT_EQ(kSpdyProtocolVersion, noop_frame->version()); | |
| 138 EXPECT_TRUE(noop_frame->is_control_frame()); | |
| 139 EXPECT_EQ(NOOP, noop_frame->type()); | |
| 140 EXPECT_EQ(0, noop_frame->flags()); | |
| 141 | |
| 142 const uint32 kUniqueId = 1234567u; | |
| 143 const uint32 kUniqueId2 = 31415926u; | |
| 144 scoped_ptr<SpdyPingControlFrame> ping_frame( | |
| 145 framer.CreatePingFrame(kUniqueId)); | |
| 146 EXPECT_EQ(kSpdyProtocolVersion, ping_frame->version()); | |
| 147 EXPECT_TRUE(ping_frame->is_control_frame()); | |
| 148 EXPECT_EQ(PING, ping_frame->type()); | |
| 149 EXPECT_EQ(kUniqueId, ping_frame->unique_id()); | |
| 150 ping_frame->set_unique_id(kUniqueId2); | |
| 151 EXPECT_EQ(kUniqueId2, ping_frame->unique_id()); | |
| 152 | |
| 153 scoped_ptr<SpdyGoAwayControlFrame> goaway_frame( | |
| 154 framer.CreateGoAway(123)); | |
| 155 EXPECT_EQ(kSpdyProtocolVersion, goaway_frame->version()); | |
| 156 EXPECT_TRUE(goaway_frame->is_control_frame()); | |
| 157 EXPECT_EQ(GOAWAY, goaway_frame->type()); | |
| 158 EXPECT_EQ(123u, goaway_frame->last_accepted_stream_id()); | |
| 159 | |
| 160 scoped_ptr<SpdyHeadersControlFrame> headers_frame( | |
| 161 framer.CreateHeaders(123, CONTROL_FLAG_NONE, false, &headers)); | |
| 162 EXPECT_EQ(kSpdyProtocolVersion, headers_frame->version()); | |
| 163 EXPECT_TRUE(headers_frame->is_control_frame()); | |
| 164 EXPECT_EQ(HEADERS, headers_frame->type()); | |
| 165 EXPECT_EQ(123u, headers_frame->stream_id()); | |
| 166 EXPECT_EQ(2, headers_frame->header_block_len()); | |
| 167 EXPECT_EQ(0, headers_frame->flags()); | |
| 168 | |
| 169 scoped_ptr<SpdyWindowUpdateControlFrame> window_update_frame( | |
| 170 framer.CreateWindowUpdate(123, 456)); | |
| 171 EXPECT_EQ(kSpdyProtocolVersion, window_update_frame->version()); | |
| 172 EXPECT_TRUE(window_update_frame->is_control_frame()); | |
| 173 EXPECT_EQ(WINDOW_UPDATE, window_update_frame->type()); | |
| 174 EXPECT_EQ(123u, window_update_frame->stream_id()); | |
| 175 EXPECT_EQ(456u, window_update_frame->delta_window_size()); | |
| 176 } | |
| 177 | |
| 178 TEST(SpdyProtocolTest, TestDataFrame) { | |
| 179 SpdyDataFrame frame; | |
| 180 | |
| 181 // Set the stream ID to various values. | |
| 182 frame.set_stream_id(0); | |
| 183 EXPECT_EQ(0u, frame.stream_id()); | |
| 184 EXPECT_FALSE(frame.is_control_frame()); | |
| 185 frame.set_stream_id(~0 & kStreamIdMask); | |
| 186 EXPECT_EQ(~0 & kStreamIdMask, frame.stream_id()); | |
| 187 EXPECT_FALSE(frame.is_control_frame()); | |
| 188 | |
| 189 // Set length to various values. Make sure that when you set_length(x), | |
| 190 // length() == x. Also make sure the flags are unaltered. | |
| 191 memset(frame.data(), '1', SpdyDataFrame::size()); | |
| 192 int8 flags = frame.flags(); | |
| 193 frame.set_length(0); | |
| 194 EXPECT_EQ(0u, frame.length()); | |
| 195 EXPECT_EQ(flags, frame.flags()); | |
| 196 frame.set_length(kLengthMask); | |
| 197 EXPECT_EQ(kLengthMask, frame.length()); | |
| 198 EXPECT_EQ(flags, frame.flags()); | |
| 199 frame.set_length(5u); | |
| 200 EXPECT_EQ(5u, frame.length()); | |
| 201 EXPECT_EQ(flags, frame.flags()); | |
| 202 | |
| 203 // Set flags to various values. Make sure that when you set_flags(x), | |
| 204 // flags() == x. Also make sure the length is unaltered. | |
| 205 memset(frame.data(), '1', SpdyDataFrame::size()); | |
| 206 uint32 length = frame.length(); | |
| 207 frame.set_flags(0u); | |
| 208 EXPECT_EQ(0u, frame.flags()); | |
| 209 EXPECT_EQ(length, frame.length()); | |
| 210 int8 all_flags = ~0; | |
| 211 frame.set_flags(all_flags); | |
| 212 flags = frame.flags(); | |
| 213 EXPECT_EQ(all_flags, flags); | |
| 214 EXPECT_EQ(length, frame.length()); | |
| 215 frame.set_flags(5u); | |
| 216 EXPECT_EQ(5u, frame.flags()); | |
| 217 EXPECT_EQ(length, frame.length()); | |
| 218 } | |
| 219 | |
| 220 // Test various types of SETTINGS frames. | |
| 221 TEST(SpdyProtocolTest, TestSpdySettingsFrame) { | |
| 222 SpdyFramer framer; | |
| 223 | |
| 224 // Create a settings frame with no settings. | |
| 225 SpdySettings settings; | |
| 226 scoped_ptr<SpdySettingsControlFrame> settings_frame( | |
| 227 framer.CreateSettings(settings)); | |
| 228 EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version()); | |
| 229 EXPECT_TRUE(settings_frame->is_control_frame()); | |
| 230 EXPECT_EQ(SETTINGS, settings_frame->type()); | |
| 231 EXPECT_EQ(0u, settings_frame->num_entries()); | |
| 232 | |
| 233 // We'll add several different ID/Flag combinations and then verify | |
| 234 // that they encode and decode properly. | |
| 235 SettingsFlagsAndId ids[] = { | |
| 236 0x00000000, | |
| 237 0xffffffff, | |
| 238 0xff000001, | |
| 239 0x01000002, | |
| 240 }; | |
| 241 | |
| 242 for (size_t index = 0; index < arraysize(ids); ++index) { | |
| 243 settings.insert(settings.end(), std::make_pair(ids[index], index)); | |
| 244 settings_frame.reset(framer.CreateSettings(settings)); | |
| 245 EXPECT_EQ(kSpdyProtocolVersion, settings_frame->version()); | |
| 246 EXPECT_TRUE(settings_frame->is_control_frame()); | |
| 247 EXPECT_EQ(SETTINGS, settings_frame->type()); | |
| 248 EXPECT_EQ(index + 1, settings_frame->num_entries()); | |
| 249 | |
| 250 SpdySettings parsed_settings; | |
| 251 EXPECT_TRUE(framer.ParseSettings(settings_frame.get(), &parsed_settings)); | |
| 252 EXPECT_EQ(parsed_settings.size(), settings.size()); | |
| 253 SpdySettings::const_iterator it = parsed_settings.begin(); | |
| 254 int pos = 0; | |
| 255 while (it != parsed_settings.end()) { | |
| 256 SettingsFlagsAndId parsed = it->first; | |
| 257 uint32 value = it->second; | |
| 258 EXPECT_EQ(parsed.flags(), ids[pos].flags()); | |
| 259 EXPECT_EQ(parsed.id(), ids[pos].id()); | |
| 260 EXPECT_EQ(value, static_cast<uint32>(pos)); | |
| 261 ++it; | |
| 262 ++pos; | |
| 263 } | |
| 264 } | |
| 265 } | |
| 266 | |
| 267 TEST(SpdyProtocolTest, HasHeaderBlock) { | |
| 268 SpdyControlFrame frame(SpdyControlFrame::kHeaderSize); | |
| 269 for (SpdyControlType type = SYN_STREAM; | |
| 270 type < NUM_CONTROL_FRAME_TYPES; | |
| 271 type = static_cast<SpdyControlType>(type + 1)) { | |
| 272 frame.set_type(type); | |
| 273 if (type == SYN_STREAM || type == SYN_REPLY || type == HEADERS) { | |
| 274 EXPECT_TRUE(frame.has_header_block()); | |
| 275 } else { | |
| 276 EXPECT_FALSE(frame.has_header_block()); | |
| 277 } | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 // Make sure that overflows both die in debug mode, and do not cause problems | |
| 282 // in opt mode. Note: The EXPECT_DEBUG_DEATH call does not work on Win32 yet, | |
| 283 // so we comment it out. | |
| 284 TEST(SpdyProtocolDeathTest, TestDataFrame) { | |
| 285 SpdyDataFrame frame; | |
| 286 | |
| 287 frame.set_stream_id(0); | |
| 288 // TODO(mbelshe): implement EXPECT_DEBUG_DEATH on windows. | |
| 289 #if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST) | |
| 290 #if !defined(DCHECK_ALWAYS_ON) | |
| 291 EXPECT_DEBUG_DEATH(frame.set_stream_id(~0), ""); | |
| 292 #else | |
| 293 EXPECT_DEATH(frame.set_stream_id(~0), ""); | |
| 294 #endif | |
| 295 #endif | |
| 296 EXPECT_FALSE(frame.is_control_frame()); | |
| 297 | |
| 298 frame.set_flags(0); | |
| 299 #if !defined(WIN32) && defined(GTEST_HAS_DEATH_TEST) | |
| 300 #if !defined(DCHECK_ALWAYS_ON) | |
| 301 EXPECT_DEBUG_DEATH(frame.set_length(~0), ""); | |
| 302 #else | |
| 303 EXPECT_DEATH(frame.set_length(~0), ""); | |
| 304 #endif | |
| 305 #endif | |
| 306 EXPECT_EQ(0, frame.flags()); | |
| 307 } | |
| 308 | |
| 309 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameStreamId) { | |
| 310 SpdyControlFrame frame_store(SpdySynStreamControlFrame::size()); | |
| 311 memset(frame_store.data(), '1', SpdyControlFrame::kHeaderSize); | |
| 312 SpdySynStreamControlFrame* frame = | |
| 313 reinterpret_cast<SpdySynStreamControlFrame*>(&frame_store); | |
| 314 | |
| 315 // Set the stream ID to various values. | |
| 316 frame->set_stream_id(0); | |
| 317 EXPECT_EQ(0u, frame->stream_id()); | |
| 318 EXPECT_FALSE(frame->is_control_frame()); | |
| 319 frame->set_stream_id(kStreamIdMask); | |
| 320 EXPECT_EQ(kStreamIdMask, frame->stream_id()); | |
| 321 EXPECT_FALSE(frame->is_control_frame()); | |
| 322 } | |
| 323 | |
| 324 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameVersion) { | |
| 325 const unsigned int kVersionMask = 0x7fff; | |
| 326 SpdyControlFrame frame(SpdySynStreamControlFrame::size()); | |
| 327 memset(frame.data(), '1', SpdyControlFrame::kHeaderSize); | |
| 328 | |
| 329 // Set the version to various values, and make sure it does not affect the | |
| 330 // type. | |
| 331 frame.set_type(SYN_STREAM); | |
| 332 frame.set_version(0); | |
| 333 EXPECT_EQ(0, frame.version()); | |
| 334 EXPECT_TRUE(frame.is_control_frame()); | |
| 335 EXPECT_EQ(SYN_STREAM, frame.type()); | |
| 336 | |
| 337 SpdySynStreamControlFrame* syn_stream = | |
| 338 reinterpret_cast<SpdySynStreamControlFrame*>(&frame); | |
| 339 syn_stream->set_stream_id(~0 & kVersionMask); | |
| 340 EXPECT_EQ(~0 & kVersionMask, syn_stream->stream_id()); | |
| 341 EXPECT_TRUE(frame.is_control_frame()); | |
| 342 EXPECT_EQ(SYN_STREAM, frame.type()); | |
| 343 } | |
| 344 | |
| 345 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameType) { | |
| 346 SpdyControlFrame frame(SpdyControlFrame::kHeaderSize); | |
| 347 memset(frame.data(), 255, SpdyControlFrame::kHeaderSize); | |
| 348 | |
| 349 // type() should be out of bounds. | |
| 350 EXPECT_FALSE(frame.AppearsToBeAValidControlFrame()); | |
| 351 | |
| 352 uint16 version = frame.version(); | |
| 353 | |
| 354 for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) { | |
| 355 frame.set_type(static_cast<SpdyControlType>(i)); | |
| 356 EXPECT_EQ(i, static_cast<int>(frame.type())); | |
| 357 EXPECT_TRUE(frame.AppearsToBeAValidControlFrame()); | |
| 358 // Make sure setting type does not alter the version block. | |
| 359 EXPECT_EQ(version, frame.version()); | |
| 360 EXPECT_TRUE(frame.is_control_frame()); | |
| 361 } | |
| 362 } | |
| 363 | |
| 364 TEST(SpdyProtocolDeathTest, TestRstStreamStatusBounds) { | |
| 365 SpdyFramer framer; | |
| 366 scoped_ptr<SpdyRstStreamControlFrame> rst_frame; | |
| 367 | |
| 368 rst_frame.reset(framer.CreateRstStream(123, spdy::PROTOCOL_ERROR)); | |
| 369 EXPECT_EQ(spdy::PROTOCOL_ERROR, rst_frame->status()); | |
| 370 | |
| 371 rst_frame->set_status(spdy::INVALID); | |
| 372 EXPECT_EQ(spdy::INVALID, rst_frame->status()); | |
| 373 | |
| 374 rst_frame->set_status( | |
| 375 static_cast<spdy::SpdyStatusCodes>(spdy::INVALID - 1)); | |
| 376 EXPECT_EQ(spdy::INVALID, rst_frame->status()); | |
| 377 | |
| 378 rst_frame->set_status(spdy::NUM_STATUS_CODES); | |
| 379 EXPECT_EQ(spdy::INVALID, rst_frame->status()); | |
| 380 } | |
| 381 | |
| 382 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9618002:
SPDY - integration of spdy/3 code. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/