| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/server/web_socket_encoder.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/strings/string_number_conversions.h" | |
| 9 #include "base/strings/stringprintf.h" | |
| 10 #include "net/base/io_buffer.h" | |
| 11 #include "net/websockets/websocket_extension_parser.h" | |
| 12 | |
| 13 namespace net { | |
| 14 | |
| 15 const char WebSocketEncoder::kClientExtensions[] = | |
| 16 "Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits"; | |
| 17 | |
| 18 namespace { | |
| 19 | |
| 20 const int kInflaterChunkSize = 16 * 1024; | |
| 21 | |
| 22 // Constants for hybi-10 frame format. | |
| 23 | |
| 24 typedef int OpCode; | |
| 25 | |
| 26 const OpCode kOpCodeContinuation = 0x0; | |
| 27 const OpCode kOpCodeText = 0x1; | |
| 28 const OpCode kOpCodeBinary = 0x2; | |
| 29 const OpCode kOpCodeClose = 0x8; | |
| 30 const OpCode kOpCodePing = 0x9; | |
| 31 const OpCode kOpCodePong = 0xA; | |
| 32 | |
| 33 const unsigned char kFinalBit = 0x80; | |
| 34 const unsigned char kReserved1Bit = 0x40; | |
| 35 const unsigned char kReserved2Bit = 0x20; | |
| 36 const unsigned char kReserved3Bit = 0x10; | |
| 37 const unsigned char kOpCodeMask = 0xF; | |
| 38 const unsigned char kMaskBit = 0x80; | |
| 39 const unsigned char kPayloadLengthMask = 0x7F; | |
| 40 | |
| 41 const size_t kMaxSingleBytePayloadLength = 125; | |
| 42 const size_t kTwoBytePayloadLengthField = 126; | |
| 43 const size_t kEightBytePayloadLengthField = 127; | |
| 44 const size_t kMaskingKeyWidthInBytes = 4; | |
| 45 | |
| 46 WebSocket::ParseResult DecodeFrameHybi17(const base::StringPiece& frame, | |
| 47 bool client_frame, | |
| 48 int* bytes_consumed, | |
| 49 std::string* output, | |
| 50 bool* compressed) { | |
| 51 size_t data_length = frame.length(); | |
| 52 if (data_length < 2) | |
| 53 return WebSocket::FRAME_INCOMPLETE; | |
| 54 | |
| 55 const char* buffer_begin = const_cast<char*>(frame.data()); | |
| 56 const char* p = buffer_begin; | |
| 57 const char* buffer_end = p + data_length; | |
| 58 | |
| 59 unsigned char first_byte = *p++; | |
| 60 unsigned char second_byte = *p++; | |
| 61 | |
| 62 bool final = (first_byte & kFinalBit) != 0; | |
| 63 bool reserved1 = (first_byte & kReserved1Bit) != 0; | |
| 64 bool reserved2 = (first_byte & kReserved2Bit) != 0; | |
| 65 bool reserved3 = (first_byte & kReserved3Bit) != 0; | |
| 66 int op_code = first_byte & kOpCodeMask; | |
| 67 bool masked = (second_byte & kMaskBit) != 0; | |
| 68 *compressed = reserved1; | |
| 69 if (!final || reserved2 || reserved3) | |
| 70 return WebSocket::FRAME_ERROR; // Only compression extension is supported. | |
| 71 | |
| 72 bool closed = false; | |
| 73 switch (op_code) { | |
| 74 case kOpCodeClose: | |
| 75 closed = true; | |
| 76 break; | |
| 77 case kOpCodeText: | |
| 78 break; | |
| 79 case kOpCodeBinary: // We don't support binary frames yet. | |
| 80 case kOpCodeContinuation: // We don't support binary frames yet. | |
| 81 case kOpCodePing: // We don't support binary frames yet. | |
| 82 case kOpCodePong: // We don't support binary frames yet. | |
| 83 default: | |
| 84 return WebSocket::FRAME_ERROR; | |
| 85 } | |
| 86 | |
| 87 if (client_frame && !masked) // In Hybi-17 spec client MUST mask his frame. | |
| 88 return WebSocket::FRAME_ERROR; | |
| 89 | |
| 90 uint64 payload_length64 = second_byte & kPayloadLengthMask; | |
| 91 if (payload_length64 > kMaxSingleBytePayloadLength) { | |
| 92 int extended_payload_length_size; | |
| 93 if (payload_length64 == kTwoBytePayloadLengthField) | |
| 94 extended_payload_length_size = 2; | |
| 95 else { | |
| 96 DCHECK(payload_length64 == kEightBytePayloadLengthField); | |
| 97 extended_payload_length_size = 8; | |
| 98 } | |
| 99 if (buffer_end - p < extended_payload_length_size) | |
| 100 return WebSocket::FRAME_INCOMPLETE; | |
| 101 payload_length64 = 0; | |
| 102 for (int i = 0; i < extended_payload_length_size; ++i) { | |
| 103 payload_length64 <<= 8; | |
| 104 payload_length64 |= static_cast<unsigned char>(*p++); | |
| 105 } | |
| 106 } | |
| 107 | |
| 108 size_t actual_masking_key_length = masked ? kMaskingKeyWidthInBytes : 0; | |
| 109 static const uint64 max_payload_length = 0x7FFFFFFFFFFFFFFFull; | |
| 110 static size_t max_length = std::numeric_limits<size_t>::max(); | |
| 111 if (payload_length64 > max_payload_length || | |
| 112 payload_length64 + actual_masking_key_length > max_length) { | |
| 113 // WebSocket frame length too large. | |
| 114 return WebSocket::FRAME_ERROR; | |
| 115 } | |
| 116 size_t payload_length = static_cast<size_t>(payload_length64); | |
| 117 | |
| 118 size_t total_length = actual_masking_key_length + payload_length; | |
| 119 if (static_cast<size_t>(buffer_end - p) < total_length) | |
| 120 return WebSocket::FRAME_INCOMPLETE; | |
| 121 | |
| 122 if (masked) { | |
| 123 output->resize(payload_length); | |
| 124 const char* masking_key = p; | |
| 125 char* payload = const_cast<char*>(p + kMaskingKeyWidthInBytes); | |
| 126 for (size_t i = 0; i < payload_length; ++i) // Unmask the payload. | |
| 127 (*output)[i] = payload[i] ^ masking_key[i % kMaskingKeyWidthInBytes]; | |
| 128 } else { | |
| 129 output->assign(p, p + payload_length); | |
| 130 } | |
| 131 | |
| 132 size_t pos = p + actual_masking_key_length + payload_length - buffer_begin; | |
| 133 *bytes_consumed = pos; | |
| 134 return closed ? WebSocket::FRAME_CLOSE : WebSocket::FRAME_OK; | |
| 135 } | |
| 136 | |
| 137 void EncodeFrameHybi17(const std::string& message, | |
| 138 int masking_key, | |
| 139 bool compressed, | |
| 140 std::string* output) { | |
| 141 std::vector<char> frame; | |
| 142 OpCode op_code = kOpCodeText; | |
| 143 size_t data_length = message.length(); | |
| 144 | |
| 145 int reserved1 = compressed ? kReserved1Bit : 0; | |
| 146 frame.push_back(kFinalBit | op_code | reserved1); | |
| 147 char mask_key_bit = masking_key != 0 ? kMaskBit : 0; | |
| 148 if (data_length <= kMaxSingleBytePayloadLength) | |
| 149 frame.push_back(data_length | mask_key_bit); | |
| 150 else if (data_length <= 0xFFFF) { | |
| 151 frame.push_back(kTwoBytePayloadLengthField | mask_key_bit); | |
| 152 frame.push_back((data_length & 0xFF00) >> 8); | |
| 153 frame.push_back(data_length & 0xFF); | |
| 154 } else { | |
| 155 frame.push_back(kEightBytePayloadLengthField | mask_key_bit); | |
| 156 char extended_payload_length[8]; | |
| 157 size_t remaining = data_length; | |
| 158 // Fill the length into extended_payload_length in the network byte order. | |
| 159 for (int i = 0; i < 8; ++i) { | |
| 160 extended_payload_length[7 - i] = remaining & 0xFF; | |
| 161 remaining >>= 8; | |
| 162 } | |
| 163 frame.insert(frame.end(), extended_payload_length, | |
| 164 extended_payload_length + 8); | |
| 165 DCHECK(!remaining); | |
| 166 } | |
| 167 | |
| 168 const char* data = const_cast<char*>(message.data()); | |
| 169 if (masking_key != 0) { | |
| 170 const char* mask_bytes = reinterpret_cast<char*>(&masking_key); | |
| 171 frame.insert(frame.end(), mask_bytes, mask_bytes + 4); | |
| 172 for (size_t i = 0; i < data_length; ++i) // Mask the payload. | |
| 173 frame.push_back(data[i] ^ mask_bytes[i % kMaskingKeyWidthInBytes]); | |
| 174 } else { | |
| 175 frame.insert(frame.end(), data, data + data_length); | |
| 176 } | |
| 177 *output = std::string(&frame[0], frame.size()); | |
| 178 } | |
| 179 | |
| 180 } // anonymous namespace | |
| 181 | |
| 182 // static | |
| 183 WebSocketEncoder* WebSocketEncoder::CreateServer( | |
| 184 const std::string& request_extensions, | |
| 185 std::string* response_extensions) { | |
| 186 bool deflate; | |
| 187 int client_window_bits; | |
| 188 int server_window_bits; | |
| 189 bool client_no_context_takeover; | |
| 190 bool server_no_context_takeover; | |
| 191 ParseExtensions(request_extensions, &deflate, &client_window_bits, | |
| 192 &server_window_bits, &client_no_context_takeover, | |
| 193 &server_no_context_takeover); | |
| 194 | |
| 195 if (deflate) { | |
| 196 *response_extensions = base::StringPrintf( | |
| 197 "permessage-deflate; server_max_window_bits=%d; " | |
| 198 "client_max_window_bits=%d%s", | |
| 199 server_window_bits, client_window_bits, | |
| 200 server_no_context_takeover ? "; server_no_context_takeover" : ""); | |
| 201 return new WebSocketEncoder(true /* is_server */, server_window_bits, | |
| 202 client_window_bits, server_no_context_takeover); | |
| 203 } else { | |
| 204 *response_extensions = std::string(); | |
| 205 return new WebSocketEncoder(true /* is_server */); | |
| 206 } | |
| 207 } | |
| 208 | |
| 209 // static | |
| 210 WebSocketEncoder* WebSocketEncoder::CreateClient( | |
| 211 const std::string& response_extensions) { | |
| 212 bool deflate; | |
| 213 int client_window_bits; | |
| 214 int server_window_bits; | |
| 215 bool client_no_context_takeover; | |
| 216 bool server_no_context_takeover; | |
| 217 ParseExtensions(response_extensions, &deflate, &client_window_bits, | |
| 218 &server_window_bits, &client_no_context_takeover, | |
| 219 &server_no_context_takeover); | |
| 220 | |
| 221 if (deflate) { | |
| 222 return new WebSocketEncoder(false /* is_server */, client_window_bits, | |
| 223 server_window_bits, client_no_context_takeover); | |
| 224 } else { | |
| 225 return new WebSocketEncoder(false /* is_server */); | |
| 226 } | |
| 227 } | |
| 228 | |
| 229 // static | |
| 230 void WebSocketEncoder::ParseExtensions(const std::string& extensions, | |
| 231 bool* deflate, | |
| 232 int* client_window_bits, | |
| 233 int* server_window_bits, | |
| 234 bool* client_no_context_takeover, | |
| 235 bool* server_no_context_takeover) { | |
| 236 *deflate = false; | |
| 237 *client_window_bits = 15; | |
| 238 *server_window_bits = 15; | |
| 239 *client_no_context_takeover = false; | |
| 240 *server_no_context_takeover = false; | |
| 241 | |
| 242 if (extensions.empty()) | |
| 243 return; | |
| 244 | |
| 245 // TODO(dgozman): split extensions header if another extension is introduced. | |
| 246 WebSocketExtensionParser parser; | |
| 247 parser.Parse(extensions); | |
| 248 if (parser.has_error()) | |
| 249 return; | |
| 250 if (parser.extension().name() != "permessage-deflate") | |
| 251 return; | |
| 252 | |
| 253 const std::vector<WebSocketExtension::Parameter>& parameters = | |
| 254 parser.extension().parameters(); | |
| 255 for (const auto& param : parameters) { | |
| 256 const std::string& name = param.name(); | |
| 257 if (name == "client_max_window_bits" && param.HasValue()) { | |
| 258 int bits = 0; | |
| 259 if (base::StringToInt(param.value(), &bits) && bits >= 8 && bits <= 15) | |
| 260 *client_window_bits = bits; | |
| 261 } | |
| 262 if (name == "server_max_window_bits" && param.HasValue()) { | |
| 263 int bits = 0; | |
| 264 if (base::StringToInt(param.value(), &bits) && bits >= 8 && bits <= 15) | |
| 265 *server_window_bits = bits; | |
| 266 } | |
| 267 if (name == "client_no_context_takeover") | |
| 268 *client_no_context_takeover = true; | |
| 269 if (name == "server_no_context_takeover") | |
| 270 *server_no_context_takeover = true; | |
| 271 } | |
| 272 *deflate = true; | |
| 273 } | |
| 274 | |
| 275 WebSocketEncoder::WebSocketEncoder(bool is_server) : is_server_(is_server) { | |
| 276 } | |
| 277 | |
| 278 WebSocketEncoder::WebSocketEncoder(bool is_server, | |
| 279 int deflate_bits, | |
| 280 int inflate_bits, | |
| 281 bool no_context_takeover) | |
| 282 : is_server_(is_server) { | |
| 283 deflater_.reset(new WebSocketDeflater( | |
| 284 no_context_takeover ? WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT | |
| 285 : WebSocketDeflater::TAKE_OVER_CONTEXT)); | |
| 286 inflater_.reset( | |
| 287 new WebSocketInflater(kInflaterChunkSize, kInflaterChunkSize)); | |
| 288 | |
| 289 if (!deflater_->Initialize(deflate_bits) || | |
| 290 !inflater_->Initialize(inflate_bits)) { | |
| 291 // Disable deflate support. | |
| 292 deflater_.reset(); | |
| 293 inflater_.reset(); | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 WebSocketEncoder::~WebSocketEncoder() { | |
| 298 } | |
| 299 | |
| 300 WebSocket::ParseResult WebSocketEncoder::DecodeFrame( | |
| 301 const base::StringPiece& frame, | |
| 302 int* bytes_consumed, | |
| 303 std::string* output) { | |
| 304 bool compressed; | |
| 305 WebSocket::ParseResult result = | |
| 306 DecodeFrameHybi17(frame, is_server_, bytes_consumed, output, &compressed); | |
| 307 if (result == WebSocket::FRAME_OK && compressed) { | |
| 308 if (!Inflate(output)) | |
| 309 result = WebSocket::FRAME_ERROR; | |
| 310 } | |
| 311 return result; | |
| 312 } | |
| 313 | |
| 314 void WebSocketEncoder::EncodeFrame(const std::string& frame, | |
| 315 int masking_key, | |
| 316 std::string* output) { | |
| 317 std::string compressed; | |
| 318 if (Deflate(frame, &compressed)) | |
| 319 EncodeFrameHybi17(compressed, masking_key, true, output); | |
| 320 else | |
| 321 EncodeFrameHybi17(frame, masking_key, false, output); | |
| 322 } | |
| 323 | |
| 324 bool WebSocketEncoder::Inflate(std::string* message) { | |
| 325 if (!inflater_) | |
| 326 return false; | |
| 327 if (!inflater_->AddBytes(message->data(), message->length())) | |
| 328 return false; | |
| 329 if (!inflater_->Finish()) | |
| 330 return false; | |
| 331 | |
| 332 std::vector<char> output; | |
| 333 while (inflater_->CurrentOutputSize() > 0) { | |
| 334 scoped_refptr<IOBufferWithSize> chunk = | |
| 335 inflater_->GetOutput(inflater_->CurrentOutputSize()); | |
| 336 if (!chunk.get()) | |
| 337 return false; | |
| 338 output.insert(output.end(), chunk->data(), chunk->data() + chunk->size()); | |
| 339 } | |
| 340 | |
| 341 *message = | |
| 342 output.size() ? std::string(&output[0], output.size()) : std::string(); | |
| 343 return true; | |
| 344 } | |
| 345 | |
| 346 bool WebSocketEncoder::Deflate(const std::string& message, | |
| 347 std::string* output) { | |
| 348 if (!deflater_) | |
| 349 return false; | |
| 350 if (!deflater_->AddBytes(message.data(), message.length())) { | |
| 351 deflater_->Finish(); | |
| 352 return false; | |
| 353 } | |
| 354 if (!deflater_->Finish()) | |
| 355 return false; | |
| 356 scoped_refptr<IOBufferWithSize> buffer = | |
| 357 deflater_->GetOutput(deflater_->CurrentOutputSize()); | |
| 358 if (!buffer.get()) | |
| 359 return false; | |
| 360 *output = std::string(buffer->data(), buffer->size()); | |
| 361 return true; | |
| 362 } | |
| 363 | |
| 364 } // 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