net/server/web_socket_encoder.cc

   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