| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/websockets/websocket_frame_parser.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/basictypes.h" | |
| 11 #include "base/memory/scoped_vector.h" | |
| 12 #include "base/port.h" | |
| 13 #include "net/base/io_buffer.h" | |
| 14 #include "net/websockets/websocket_frame.h" | |
| 15 #include "testing/gtest/include/gtest/gtest.h" | |
| 16 | |
| 17 namespace net { | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 const char kHello[] = "Hello, world!"; | |
| 22 const uint64 kHelloLength = arraysize(kHello) - 1; | |
| 23 const char kHelloFrame[] = "\x81\x0DHello, world!"; | |
| 24 const uint64 kHelloFrameLength = arraysize(kHelloFrame) - 1; | |
| 25 const char kMaskedHelloFrame[] = | |
| 26 "\x81\x8D\xDE\xAD\xBE\xEF" | |
| 27 "\x96\xC8\xD2\x83\xB1\x81\x9E\x98\xB1\xDF\xD2\x8B\xFF"; | |
| 28 const uint64 kMaskedHelloFrameLength = arraysize(kMaskedHelloFrame) - 1; | |
| 29 | |
| 30 struct FrameHeaderTestCase { | |
| 31 const char* frame_header; | |
| 32 size_t frame_header_length; | |
| 33 uint64 frame_length; | |
| 34 WebSocketError error_code; | |
| 35 }; | |
| 36 | |
| 37 const FrameHeaderTestCase kFrameHeaderTests[] = { | |
| 38 { "\x81\x00", 2, GG_UINT64_C(0), kWebSocketNormalClosure }, | |
| 39 { "\x81\x7D", 2, GG_UINT64_C(125), kWebSocketNormalClosure }, | |
| 40 { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126), kWebSocketNormalClosure }, | |
| 41 { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF), kWebSocketNormalClosure }, | |
| 42 { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000), | |
| 43 kWebSocketNormalClosure }, | |
| 44 { "\x81\x7F\x00\x00\x00\x00\x7F\xFF\xFF\xFF", 10, GG_UINT64_C(0x7FFFFFFF), | |
| 45 kWebSocketNormalClosure }, | |
| 46 { "\x81\x7F\x00\x00\x00\x00\x80\x00\x00\x00", 10, GG_UINT64_C(0x80000000), | |
| 47 kWebSocketErrorMessageTooBig }, | |
| 48 { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10, | |
| 49 GG_UINT64_C(0x7FFFFFFFFFFFFFFF), kWebSocketErrorMessageTooBig } | |
| 50 }; | |
| 51 const int kNumFrameHeaderTests = arraysize(kFrameHeaderTests); | |
| 52 | |
| 53 TEST(WebSocketFrameParserTest, DecodeNormalFrame) { | |
| 54 WebSocketFrameParser parser; | |
| 55 | |
| 56 ScopedVector<WebSocketFrameChunk> frames; | |
| 57 EXPECT_TRUE(parser.Decode(kHelloFrame, kHelloFrameLength, &frames)); | |
| 58 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 59 ASSERT_EQ(1u, frames.size()); | |
| 60 WebSocketFrameChunk* frame = frames[0]; | |
| 61 ASSERT_TRUE(frame != NULL); | |
| 62 const WebSocketFrameHeader* header = frame->header.get(); | |
| 63 EXPECT_TRUE(header != NULL); | |
| 64 if (header) { | |
| 65 EXPECT_TRUE(header->final); | |
| 66 EXPECT_FALSE(header->reserved1); | |
| 67 EXPECT_FALSE(header->reserved2); | |
| 68 EXPECT_FALSE(header->reserved3); | |
| 69 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 70 EXPECT_FALSE(header->masked); | |
| 71 EXPECT_EQ(kHelloLength, header->payload_length); | |
| 72 } | |
| 73 EXPECT_TRUE(frame->final_chunk); | |
| 74 | |
| 75 ASSERT_EQ(static_cast<int>(kHelloLength), frame->data->size()); | |
| 76 EXPECT_TRUE(std::equal(kHello, kHello + kHelloLength, frame->data->data())); | |
| 77 } | |
| 78 | |
| 79 TEST(WebSocketFrameParserTest, DecodeMaskedFrame) { | |
| 80 WebSocketFrameParser parser; | |
| 81 | |
| 82 ScopedVector<WebSocketFrameChunk> frames; | |
| 83 EXPECT_TRUE( | |
| 84 parser.Decode(kMaskedHelloFrame, kMaskedHelloFrameLength, &frames)); | |
| 85 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 86 ASSERT_EQ(1u, frames.size()); | |
| 87 WebSocketFrameChunk* frame = frames[0]; | |
| 88 ASSERT_TRUE(frame != NULL); | |
| 89 const WebSocketFrameHeader* header = frame->header.get(); | |
| 90 EXPECT_TRUE(header != NULL); | |
| 91 if (header) { | |
| 92 EXPECT_TRUE(header->final); | |
| 93 EXPECT_FALSE(header->reserved1); | |
| 94 EXPECT_FALSE(header->reserved2); | |
| 95 EXPECT_FALSE(header->reserved3); | |
| 96 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 97 EXPECT_TRUE(header->masked); | |
| 98 EXPECT_EQ(kHelloLength, header->payload_length); | |
| 99 } | |
| 100 EXPECT_TRUE(frame->final_chunk); | |
| 101 | |
| 102 ASSERT_EQ(static_cast<int>(kHelloLength), frame->data->size()); | |
| 103 EXPECT_TRUE(std::equal(kHello, kHello + kHelloLength, frame->data->data())); | |
| 104 } | |
| 105 | |
| 106 TEST(WebSocketFrameParserTest, DecodeManyFrames) { | |
| 107 struct Input { | |
| 108 const char* frame; | |
| 109 size_t frame_length; | |
| 110 const char* expected_payload; | |
| 111 size_t expected_payload_length; | |
| 112 }; | |
| 113 static const Input kInputs[] = { | |
| 114 // Each |frame| data is split into two string literals because C++ lexers | |
| 115 // consume unlimited number of hex characters in a hex character escape | |
| 116 // (e.g. "\x05F" is not treated as { '\x5', 'F', '\0' } but as | |
| 117 // { '\x5F', '\0' }). | |
| 118 { "\x81\x05" "First", 7, "First", 5 }, | |
| 119 { "\x81\x06" "Second", 8, "Second", 6 }, | |
| 120 { "\x81\x05" "Third", 7, "Third", 5 }, | |
| 121 { "\x81\x06" "Fourth", 8, "Fourth", 6 }, | |
| 122 { "\x81\x05" "Fifth", 7, "Fifth", 5 }, | |
| 123 { "\x81\x05" "Sixth", 7, "Sixth", 5 }, | |
| 124 { "\x81\x07" "Seventh", 9, "Seventh", 7 }, | |
| 125 { "\x81\x06" "Eighth", 8, "Eighth", 6 }, | |
| 126 { "\x81\x05" "Ninth", 7, "Ninth", 5 }, | |
| 127 { "\x81\x05" "Tenth", 7, "Tenth", 5 } | |
| 128 }; | |
| 129 static const int kNumInputs = arraysize(kInputs); | |
| 130 | |
| 131 std::vector<char> input; | |
| 132 // Concatenate all frames. | |
| 133 for (int i = 0; i < kNumInputs; ++i) { | |
| 134 input.insert(input.end(), | |
| 135 kInputs[i].frame, | |
| 136 kInputs[i].frame + kInputs[i].frame_length); | |
| 137 } | |
| 138 | |
| 139 WebSocketFrameParser parser; | |
| 140 | |
| 141 ScopedVector<WebSocketFrameChunk> frames; | |
| 142 EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames)); | |
| 143 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 144 ASSERT_EQ(static_cast<size_t>(kNumInputs), frames.size()); | |
| 145 | |
| 146 for (int i = 0; i < kNumInputs; ++i) { | |
| 147 WebSocketFrameChunk* frame = frames[i]; | |
| 148 EXPECT_TRUE(frame != NULL); | |
| 149 if (!frame) | |
| 150 continue; | |
| 151 EXPECT_TRUE(frame->final_chunk); | |
| 152 ASSERT_EQ(kInputs[i].expected_payload_length, | |
| 153 static_cast<uint64>(frame->data->size())); | |
| 154 EXPECT_TRUE(std::equal( | |
| 155 kInputs[i].expected_payload, | |
| 156 kInputs[i].expected_payload + kInputs[i].expected_payload_length, | |
| 157 frame->data->data())); | |
| 158 | |
| 159 const WebSocketFrameHeader* header = frame->header.get(); | |
| 160 EXPECT_TRUE(header != NULL); | |
| 161 if (!header) | |
| 162 continue; | |
| 163 EXPECT_TRUE(header->final); | |
| 164 EXPECT_FALSE(header->reserved1); | |
| 165 EXPECT_FALSE(header->reserved2); | |
| 166 EXPECT_FALSE(header->reserved3); | |
| 167 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 168 EXPECT_FALSE(header->masked); | |
| 169 EXPECT_EQ(kInputs[i].expected_payload_length, header->payload_length); | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 TEST(WebSocketFrameParserTest, DecodePartialFrame) { | |
| 174 static const size_t kFrameHeaderSize = 2; | |
| 175 | |
| 176 for (size_t cutting_pos = 0; cutting_pos < kHelloLength; ++cutting_pos) { | |
| 177 std::vector<char> input1(kHelloFrame, | |
| 178 kHelloFrame + kFrameHeaderSize + cutting_pos); | |
| 179 std::vector<char> input2(kHelloFrame + input1.size(), | |
| 180 kHelloFrame + kHelloFrameLength); | |
| 181 | |
| 182 std::vector<char> expected1(kHello, kHello + cutting_pos); | |
| 183 std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength); | |
| 184 | |
| 185 WebSocketFrameParser parser; | |
| 186 | |
| 187 ScopedVector<WebSocketFrameChunk> frames1; | |
| 188 EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1)); | |
| 189 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 190 EXPECT_EQ(1u, frames1.size()); | |
| 191 if (frames1.size() != 1u) | |
| 192 continue; | |
| 193 WebSocketFrameChunk* frame1 = frames1[0]; | |
| 194 EXPECT_TRUE(frame1 != NULL); | |
| 195 if (!frame1) | |
| 196 continue; | |
| 197 EXPECT_FALSE(frame1->final_chunk); | |
| 198 if (expected1.size() == 0) { | |
| 199 EXPECT_EQ(NULL, frame1->data.get()); | |
| 200 } else { | |
| 201 ASSERT_EQ(cutting_pos, static_cast<size_t>(frame1->data->size())); | |
| 202 EXPECT_TRUE( | |
| 203 std::equal(expected1.begin(), expected1.end(), frame1->data->data())); | |
| 204 } | |
| 205 const WebSocketFrameHeader* header1 = frame1->header.get(); | |
| 206 EXPECT_TRUE(header1 != NULL); | |
| 207 if (!header1) | |
| 208 continue; | |
| 209 EXPECT_TRUE(header1->final); | |
| 210 EXPECT_FALSE(header1->reserved1); | |
| 211 EXPECT_FALSE(header1->reserved2); | |
| 212 EXPECT_FALSE(header1->reserved3); | |
| 213 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode); | |
| 214 EXPECT_FALSE(header1->masked); | |
| 215 EXPECT_EQ(kHelloLength, header1->payload_length); | |
| 216 | |
| 217 ScopedVector<WebSocketFrameChunk> frames2; | |
| 218 EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2)); | |
| 219 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 220 EXPECT_EQ(1u, frames2.size()); | |
| 221 if (frames2.size() != 1u) | |
| 222 continue; | |
| 223 WebSocketFrameChunk* frame2 = frames2[0]; | |
| 224 EXPECT_TRUE(frame2 != NULL); | |
| 225 if (!frame2) | |
| 226 continue; | |
| 227 EXPECT_TRUE(frame2->final_chunk); | |
| 228 if (expected2.size() == 0) { | |
| 229 EXPECT_EQ(NULL, frame2->data.get()); | |
| 230 } else { | |
| 231 ASSERT_EQ(expected2.size(), static_cast<uint64>(frame2->data->size())); | |
| 232 EXPECT_TRUE( | |
| 233 std::equal(expected2.begin(), expected2.end(), frame2->data->data())); | |
| 234 } | |
| 235 const WebSocketFrameHeader* header2 = frame2->header.get(); | |
| 236 EXPECT_TRUE(header2 == NULL); | |
| 237 } | |
| 238 } | |
| 239 | |
| 240 TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) { | |
| 241 static const size_t kFrameHeaderSize = 6; | |
| 242 | |
| 243 for (size_t cutting_pos = 0; cutting_pos < kHelloLength; ++cutting_pos) { | |
| 244 std::vector<char> input1( | |
| 245 kMaskedHelloFrame, kMaskedHelloFrame + kFrameHeaderSize + cutting_pos); | |
| 246 std::vector<char> input2(kMaskedHelloFrame + input1.size(), | |
| 247 kMaskedHelloFrame + kMaskedHelloFrameLength); | |
| 248 | |
| 249 std::vector<char> expected1(kHello, kHello + cutting_pos); | |
| 250 std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength); | |
| 251 | |
| 252 WebSocketFrameParser parser; | |
| 253 | |
| 254 ScopedVector<WebSocketFrameChunk> frames1; | |
| 255 EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1)); | |
| 256 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 257 EXPECT_EQ(1u, frames1.size()); | |
| 258 if (frames1.size() != 1u) | |
| 259 continue; | |
| 260 WebSocketFrameChunk* frame1 = frames1[0]; | |
| 261 EXPECT_TRUE(frame1 != NULL); | |
| 262 if (!frame1) | |
| 263 continue; | |
| 264 EXPECT_FALSE(frame1->final_chunk); | |
| 265 if (expected1.size() == 0) { | |
| 266 EXPECT_EQ(NULL, frame1->data.get()); | |
| 267 } else { | |
| 268 ASSERT_EQ(expected1.size(), static_cast<uint64>(frame1->data->size())); | |
| 269 EXPECT_TRUE( | |
| 270 std::equal(expected1.begin(), expected1.end(), frame1->data->data())); | |
| 271 } | |
| 272 const WebSocketFrameHeader* header1 = frame1->header.get(); | |
| 273 EXPECT_TRUE(header1 != NULL); | |
| 274 if (!header1) | |
| 275 continue; | |
| 276 EXPECT_TRUE(header1->final); | |
| 277 EXPECT_FALSE(header1->reserved1); | |
| 278 EXPECT_FALSE(header1->reserved2); | |
| 279 EXPECT_FALSE(header1->reserved3); | |
| 280 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode); | |
| 281 EXPECT_TRUE(header1->masked); | |
| 282 EXPECT_EQ(kHelloLength, header1->payload_length); | |
| 283 | |
| 284 ScopedVector<WebSocketFrameChunk> frames2; | |
| 285 EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2)); | |
| 286 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 287 EXPECT_EQ(1u, frames2.size()); | |
| 288 if (frames2.size() != 1u) | |
| 289 continue; | |
| 290 WebSocketFrameChunk* frame2 = frames2[0]; | |
| 291 EXPECT_TRUE(frame2 != NULL); | |
| 292 if (!frame2) | |
| 293 continue; | |
| 294 EXPECT_TRUE(frame2->final_chunk); | |
| 295 if (expected2.size() == 0) { | |
| 296 EXPECT_EQ(NULL, frame2->data.get()); | |
| 297 } else { | |
| 298 ASSERT_EQ(expected2.size(), static_cast<uint64>(frame2->data->size())); | |
| 299 EXPECT_TRUE( | |
| 300 std::equal(expected2.begin(), expected2.end(), frame2->data->data())); | |
| 301 } | |
| 302 const WebSocketFrameHeader* header2 = frame2->header.get(); | |
| 303 EXPECT_TRUE(header2 == NULL); | |
| 304 } | |
| 305 } | |
| 306 | |
| 307 TEST(WebSocketFrameParserTest, DecodeFramesOfVariousLengths) { | |
| 308 for (int i = 0; i < kNumFrameHeaderTests; ++i) { | |
| 309 const char* frame_header = kFrameHeaderTests[i].frame_header; | |
| 310 size_t frame_header_length = kFrameHeaderTests[i].frame_header_length; | |
| 311 uint64 frame_length = kFrameHeaderTests[i].frame_length; | |
| 312 | |
| 313 std::vector<char> input(frame_header, frame_header + frame_header_length); | |
| 314 // Limit the payload size not to flood the console on failure. | |
| 315 static const uint64 kMaxPayloadSize = 200; | |
| 316 uint64 input_payload_size = std::min(frame_length, kMaxPayloadSize); | |
| 317 input.insert(input.end(), input_payload_size, 'a'); | |
| 318 | |
| 319 WebSocketFrameParser parser; | |
| 320 | |
| 321 ScopedVector<WebSocketFrameChunk> frames; | |
| 322 EXPECT_EQ(kFrameHeaderTests[i].error_code == kWebSocketNormalClosure, | |
| 323 parser.Decode(&input.front(), input.size(), &frames)); | |
| 324 EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error()); | |
| 325 if (kFrameHeaderTests[i].error_code != kWebSocketNormalClosure) { | |
| 326 EXPECT_EQ(0u, frames.size()); | |
| 327 } else { | |
| 328 EXPECT_EQ(1u, frames.size()); | |
| 329 } | |
| 330 if (frames.size() != 1u) | |
| 331 continue; | |
| 332 WebSocketFrameChunk* frame = frames[0]; | |
| 333 EXPECT_TRUE(frame != NULL); | |
| 334 if (!frame) | |
| 335 continue; | |
| 336 if (frame_length == input_payload_size) { | |
| 337 EXPECT_TRUE(frame->final_chunk); | |
| 338 } else { | |
| 339 EXPECT_FALSE(frame->final_chunk); | |
| 340 } | |
| 341 std::vector<char> expected_payload(input_payload_size, 'a'); | |
| 342 if (expected_payload.size() == 0) { | |
| 343 EXPECT_EQ(NULL, frame->data.get()); | |
| 344 } else { | |
| 345 ASSERT_EQ(expected_payload.size(), | |
| 346 static_cast<uint64>(frame->data->size())); | |
| 347 EXPECT_TRUE(std::equal(expected_payload.begin(), | |
| 348 expected_payload.end(), | |
| 349 frame->data->data())); | |
| 350 } | |
| 351 const WebSocketFrameHeader* header = frame->header.get(); | |
| 352 EXPECT_TRUE(header != NULL); | |
| 353 if (!header) | |
| 354 continue; | |
| 355 EXPECT_TRUE(header->final); | |
| 356 EXPECT_FALSE(header->reserved1); | |
| 357 EXPECT_FALSE(header->reserved2); | |
| 358 EXPECT_FALSE(header->reserved3); | |
| 359 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 360 EXPECT_FALSE(header->masked); | |
| 361 EXPECT_EQ(frame_length, header->payload_length); | |
| 362 } | |
| 363 } | |
| 364 | |
| 365 TEST(WebSocketFrameParserTest, DecodePartialHeader) { | |
| 366 for (int i = 0; i < kNumFrameHeaderTests; ++i) { | |
| 367 const char* frame_header = kFrameHeaderTests[i].frame_header; | |
| 368 size_t frame_header_length = kFrameHeaderTests[i].frame_header_length; | |
| 369 uint64 frame_length = kFrameHeaderTests[i].frame_length; | |
| 370 | |
| 371 WebSocketFrameParser parser; | |
| 372 | |
| 373 ScopedVector<WebSocketFrameChunk> frames; | |
| 374 // Feed each byte to the parser to see if the parser behaves correctly | |
| 375 // when it receives partial frame header. | |
| 376 size_t last_byte_offset = frame_header_length - 1; | |
| 377 for (size_t j = 0; j < frame_header_length; ++j) { | |
| 378 bool failed = | |
| 379 kFrameHeaderTests[i].error_code != kWebSocketNormalClosure && | |
| 380 j == last_byte_offset; | |
| 381 EXPECT_EQ(!failed, parser.Decode(frame_header + j, 1, &frames)); | |
| 382 if (failed) { | |
| 383 EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error()); | |
| 384 } else { | |
| 385 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 386 } | |
| 387 if (kFrameHeaderTests[i].error_code == kWebSocketNormalClosure && | |
| 388 j == last_byte_offset) { | |
| 389 EXPECT_EQ(1u, frames.size()); | |
| 390 } else { | |
| 391 EXPECT_EQ(0u, frames.size()); | |
| 392 } | |
| 393 } | |
| 394 if (frames.size() != 1u) | |
| 395 continue; | |
| 396 WebSocketFrameChunk* frame = frames[0]; | |
| 397 EXPECT_TRUE(frame != NULL); | |
| 398 if (!frame) | |
| 399 continue; | |
| 400 if (frame_length == 0u) { | |
| 401 EXPECT_TRUE(frame->final_chunk); | |
| 402 } else { | |
| 403 EXPECT_FALSE(frame->final_chunk); | |
| 404 } | |
| 405 EXPECT_EQ(NULL, frame->data.get()); | |
| 406 const WebSocketFrameHeader* header = frame->header.get(); | |
| 407 EXPECT_TRUE(header != NULL); | |
| 408 if (!header) | |
| 409 continue; | |
| 410 EXPECT_TRUE(header->final); | |
| 411 EXPECT_FALSE(header->reserved1); | |
| 412 EXPECT_FALSE(header->reserved2); | |
| 413 EXPECT_FALSE(header->reserved3); | |
| 414 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 415 EXPECT_FALSE(header->masked); | |
| 416 EXPECT_EQ(frame_length, header->payload_length); | |
| 417 } | |
| 418 } | |
| 419 | |
| 420 TEST(WebSocketFrameParserTest, InvalidLengthEncoding) { | |
| 421 struct TestCase { | |
| 422 const char* frame_header; | |
| 423 size_t frame_header_length; | |
| 424 }; | |
| 425 static const TestCase kTests[] = { | |
| 426 // For frames with two-byte extended length field, the payload length | |
| 427 // should be 126 (0x7E) bytes or more. | |
| 428 { "\x81\x7E\x00\x00", 4 }, | |
| 429 { "\x81\x7E\x00\x7D", 4 }, | |
| 430 // For frames with eight-byte extended length field, the payload length | |
| 431 // should be 0x10000 bytes or more. | |
| 432 { "\x81\x7F\x00\x00\x00\x00\x00\x00\x00\x00", 10 }, | |
| 433 { "\x81\x7E\x00\x00\x00\x00\x00\x00\xFF\xFF", 10 }, | |
| 434 }; | |
| 435 static const int kNumTests = arraysize(kTests); | |
| 436 | |
| 437 for (int i = 0; i < kNumTests; ++i) { | |
| 438 const char* frame_header = kTests[i].frame_header; | |
| 439 size_t frame_header_length = kTests[i].frame_header_length; | |
| 440 | |
| 441 WebSocketFrameParser parser; | |
| 442 | |
| 443 ScopedVector<WebSocketFrameChunk> frames; | |
| 444 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 445 EXPECT_FALSE(parser.Decode(frame_header, frame_header_length, &frames)); | |
| 446 EXPECT_EQ(kWebSocketErrorProtocolError, parser.websocket_error()); | |
| 447 EXPECT_EQ(0u, frames.size()); | |
| 448 | |
| 449 // Once the parser has failed, it no longer accepts any input (even if | |
| 450 // the input is empty). | |
| 451 EXPECT_FALSE(parser.Decode("", 0, &frames)); | |
| 452 EXPECT_EQ(kWebSocketErrorProtocolError, parser.websocket_error()); | |
| 453 EXPECT_EQ(0u, frames.size()); | |
| 454 } | |
| 455 } | |
| 456 | |
| 457 TEST(WebSocketFrameParserTest, FrameTypes) { | |
| 458 struct TestCase { | |
| 459 const char* frame_header; | |
| 460 size_t frame_header_length; | |
| 461 WebSocketFrameHeader::OpCode opcode; | |
| 462 }; | |
| 463 static const TestCase kTests[] = { | |
| 464 { "\x80\x00", 2, WebSocketFrameHeader::kOpCodeContinuation }, | |
| 465 { "\x81\x00", 2, WebSocketFrameHeader::kOpCodeText }, | |
| 466 { "\x82\x00", 2, WebSocketFrameHeader::kOpCodeBinary }, | |
| 467 { "\x88\x00", 2, WebSocketFrameHeader::kOpCodeClose }, | |
| 468 { "\x89\x00", 2, WebSocketFrameHeader::kOpCodePing }, | |
| 469 { "\x8A\x00", 2, WebSocketFrameHeader::kOpCodePong }, | |
| 470 // These are undefined opcodes, but the parser needs to be able to parse | |
| 471 // them anyway. | |
| 472 { "\x83\x00", 2, 0x3 }, | |
| 473 { "\x84\x00", 2, 0x4 }, | |
| 474 { "\x85\x00", 2, 0x5 }, | |
| 475 { "\x86\x00", 2, 0x6 }, | |
| 476 { "\x87\x00", 2, 0x7 }, | |
| 477 { "\x8B\x00", 2, 0xB }, | |
| 478 { "\x8C\x00", 2, 0xC }, | |
| 479 { "\x8D\x00", 2, 0xD }, | |
| 480 { "\x8E\x00", 2, 0xE }, | |
| 481 { "\x8F\x00", 2, 0xF } | |
| 482 }; | |
| 483 static const int kNumTests = arraysize(kTests); | |
| 484 | |
| 485 for (int i = 0; i < kNumTests; ++i) { | |
| 486 const char* frame_header = kTests[i].frame_header; | |
| 487 size_t frame_header_length = kTests[i].frame_header_length; | |
| 488 WebSocketFrameHeader::OpCode opcode = kTests[i].opcode; | |
| 489 | |
| 490 WebSocketFrameParser parser; | |
| 491 | |
| 492 ScopedVector<WebSocketFrameChunk> frames; | |
| 493 EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames)); | |
| 494 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 495 EXPECT_EQ(1u, frames.size()); | |
| 496 if (frames.size() != 1u) | |
| 497 continue; | |
| 498 WebSocketFrameChunk* frame = frames[0]; | |
| 499 EXPECT_TRUE(frame != NULL); | |
| 500 if (!frame) | |
| 501 continue; | |
| 502 EXPECT_TRUE(frame->final_chunk); | |
| 503 EXPECT_EQ(NULL, frame->data.get()); | |
| 504 const WebSocketFrameHeader* header = frame->header.get(); | |
| 505 EXPECT_TRUE(header != NULL); | |
| 506 if (!header) | |
| 507 continue; | |
| 508 EXPECT_TRUE(header->final); | |
| 509 EXPECT_FALSE(header->reserved1); | |
| 510 EXPECT_FALSE(header->reserved2); | |
| 511 EXPECT_FALSE(header->reserved3); | |
| 512 EXPECT_EQ(opcode, header->opcode); | |
| 513 EXPECT_FALSE(header->masked); | |
| 514 EXPECT_EQ(0u, header->payload_length); | |
| 515 } | |
| 516 } | |
| 517 | |
| 518 TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) { | |
| 519 struct TestCase { | |
| 520 const char* frame_header; | |
| 521 size_t frame_header_length; | |
| 522 bool final; | |
| 523 bool reserved1; | |
| 524 bool reserved2; | |
| 525 bool reserved3; | |
| 526 }; | |
| 527 static const TestCase kTests[] = { | |
| 528 { "\x81\x00", 2, true, false, false, false }, | |
| 529 { "\x01\x00", 2, false, false, false, false }, | |
| 530 { "\xC1\x00", 2, true, true, false, false }, | |
| 531 { "\xA1\x00", 2, true, false, true, false }, | |
| 532 { "\x91\x00", 2, true, false, false, true }, | |
| 533 { "\x71\x00", 2, false, true, true, true }, | |
| 534 { "\xF1\x00", 2, true, true, true, true } | |
| 535 }; | |
| 536 static const int kNumTests = arraysize(kTests); | |
| 537 | |
| 538 for (int i = 0; i < kNumTests; ++i) { | |
| 539 const char* frame_header = kTests[i].frame_header; | |
| 540 size_t frame_header_length = kTests[i].frame_header_length; | |
| 541 bool final = kTests[i].final; | |
| 542 bool reserved1 = kTests[i].reserved1; | |
| 543 bool reserved2 = kTests[i].reserved2; | |
| 544 bool reserved3 = kTests[i].reserved3; | |
| 545 | |
| 546 WebSocketFrameParser parser; | |
| 547 | |
| 548 ScopedVector<WebSocketFrameChunk> frames; | |
| 549 EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames)); | |
| 550 EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error()); | |
| 551 EXPECT_EQ(1u, frames.size()); | |
| 552 if (frames.size() != 1u) | |
| 553 continue; | |
| 554 WebSocketFrameChunk* frame = frames[0]; | |
| 555 EXPECT_TRUE(frame != NULL); | |
| 556 if (!frame) | |
| 557 continue; | |
| 558 EXPECT_TRUE(frame->final_chunk); | |
| 559 EXPECT_EQ(NULL, frame->data.get()); | |
| 560 const WebSocketFrameHeader* header = frame->header.get(); | |
| 561 EXPECT_TRUE(header != NULL); | |
| 562 if (!header) | |
| 563 continue; | |
| 564 EXPECT_EQ(final, header->final); | |
| 565 EXPECT_EQ(reserved1, header->reserved1); | |
| 566 EXPECT_EQ(reserved2, header->reserved2); | |
| 567 EXPECT_EQ(reserved3, header->reserved3); | |
| 568 EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode); | |
| 569 EXPECT_FALSE(header->masked); | |
| 570 EXPECT_EQ(0u, header->payload_length); | |
| 571 } | |
| 572 } | |
| 573 | |
| 574 } // Unnamed namespace | |
| 575 | |
| 576 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master