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