ppapi/proxy/websocket_resource.cc

   1 // Copyright (c) 2012 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 "ppapi/proxy/websocket_resource.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "ppapi/c/pp_errors.h"
  12 #include "ppapi/proxy/dispatch_reply_message.h"
  13 #include "ppapi/proxy/ppapi_messages.h"
  14 #include "ppapi/shared_impl/ppapi_globals.h"
  15 #include "ppapi/shared_impl/var.h"
  16 #include "ppapi/shared_impl/var_tracker.h"
  17 #include "third_party/WebKit/public/web/WebSocket.h"
  18
  19 namespace {
  20
  21 const uint32_t kMaxReasonSizeInBytes = 123;
  22 const size_t kBaseFramingOverhead = 2;
  23 const size_t kMaskingKeyLength = 4;
  24 const size_t kMinimumPayloadSizeWithTwoByteExtendedPayloadLength = 126;
  25 const size_t kMinimumPayloadSizeWithEightByteExtendedPayloadLength = 0x10000;
  26
  27 uint64_t SaturateAdd(uint64_t a, uint64_t b) {
  28   if (kuint64max - a < b)
  29     return kuint64max;
  30   return a + b;
  31 }
  32
  33 uint64_t GetFrameSize(uint64_t payload_size) {
  34   uint64_t overhead = kBaseFramingOverhead + kMaskingKeyLength;
  35   if (payload_size > kMinimumPayloadSizeWithEightByteExtendedPayloadLength)
  36     overhead += 8;
  37   else if (payload_size > kMinimumPayloadSizeWithTwoByteExtendedPayloadLength)
  38     overhead += 2;
  39   return SaturateAdd(payload_size, overhead);
  40 }
  41
  42 bool InValidStateToReceive(PP_WebSocketReadyState state) {
  43   return state == PP_WEBSOCKETREADYSTATE_OPEN ||
  44          state == PP_WEBSOCKETREADYSTATE_CLOSING;
  45 }
  46
  47 }  // namespace
  48
  49
  50 namespace ppapi {
  51 namespace proxy {
  52
  53 WebSocketResource::WebSocketResource(Connection connection,
  54                                      PP_Instance instance)
  55     : PluginResource(connection, instance),
  56       state_(PP_WEBSOCKETREADYSTATE_INVALID),
  57       error_was_received_(false),
  58       receive_callback_var_(NULL),
  59       empty_string_(new StringVar(std::string())),
  60       close_code_(0),
  61       close_reason_(NULL),
  62       close_was_clean_(PP_FALSE),
  63       extensions_(NULL),
  64       protocol_(NULL),
  65       url_(NULL),
  66       buffered_amount_(0),
  67       buffered_amount_after_close_(0) {
  68 }
  69
  70 WebSocketResource::~WebSocketResource() {
  71 }
  72
  73 thunk::PPB_WebSocket_API* WebSocketResource::AsPPB_WebSocket_API() {
  74   return this;
  75 }
  76
  77 int32_t WebSocketResource::Connect(
  78     const PP_Var& url,
  79     const PP_Var protocols[],
  80     uint32_t protocol_count,
  81     scoped_refptr<TrackedCallback> callback) {
  82   if (TrackedCallback::IsPending(connect_callback_))
  83     return PP_ERROR_INPROGRESS;
  84
  85   // Connect() can be called at most once.
  86   if (state_ != PP_WEBSOCKETREADYSTATE_INVALID)
  87     return PP_ERROR_INPROGRESS;
  88   state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
  89
  90   // Get the URL.
  91   url_ = StringVar::FromPPVar(url);
  92   if (!url_.get())
  93     return PP_ERROR_BADARGUMENT;
  94
  95   // Get the protocols.
  96   std::set<std::string> protocol_set;
  97   std::vector<std::string> protocol_strings;
  98   protocol_strings.reserve(protocol_count);
  99   for (uint32_t i = 0; i < protocol_count; ++i) {
 100     scoped_refptr<StringVar> protocol(StringVar::FromPPVar(protocols[i]));
 101
 102     // Check invalid and empty entries.
 103     if (!protocol.get() || !protocol->value().length())
 104       return PP_ERROR_BADARGUMENT;
 105
 106     // Check duplicated protocol entries.
 107     if (protocol_set.find(protocol->value()) != protocol_set.end())
 108       return PP_ERROR_BADARGUMENT;
 109     protocol_set.insert(protocol->value());
 110
 111     protocol_strings.push_back(protocol->value());
 112   }
 113
 114   // Install callback.
 115   connect_callback_ = callback;
 116
 117   // Create remote host in the renderer, then request to check the URL and
 118   // establish the connection.
 119   state_ = PP_WEBSOCKETREADYSTATE_CONNECTING;
 120   SendCreate(RENDERER, PpapiHostMsg_WebSocket_Create());
 121   PpapiHostMsg_WebSocket_Connect msg(url_->value(), protocol_strings);
 122   Call<PpapiPluginMsg_WebSocket_ConnectReply>(RENDERER, msg,
 123       base::Bind(&WebSocketResource::OnPluginMsgConnectReply, this));
 124
 125   return PP_OK_COMPLETIONPENDING;
 126 }
 127
 128 int32_t WebSocketResource::Close(uint16_t code,
 129                                  const PP_Var& reason,
 130                                  scoped_refptr<TrackedCallback> callback) {
 131   if (TrackedCallback::IsPending(close_callback_))
 132     return PP_ERROR_INPROGRESS;
 133   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID)
 134     return PP_ERROR_FAILED;
 135
 136   // Validate |code| and |reason|.
 137   scoped_refptr<StringVar> reason_string_var;
 138   std::string reason_string;
 139   WebKit::WebSocket::CloseEventCode event_code =
 140       static_cast<WebKit::WebSocket::CloseEventCode>(code);
 141   if (code == PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED) {
 142     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED and CloseEventCodeNotSpecified are
 143     // assigned to different values. A conversion is needed if
 144     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED is specified.
 145     event_code = WebKit::WebSocket::CloseEventCodeNotSpecified;
 146   } else {
 147     if (!(code == PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE ||
 148         (PP_WEBSOCKETSTATUSCODE_USER_REGISTERED_MIN <= code &&
 149         code <= PP_WEBSOCKETSTATUSCODE_USER_PRIVATE_MAX)))
 150       // RFC 6455 limits applications to use reserved connection close code in
 151       // section 7.4.2.. The WebSocket API (http://www.w3.org/TR/websockets/)
 152       // defines this out of range error as InvalidAccessError in JavaScript.
 153       return PP_ERROR_NOACCESS;
 154
 155     // |reason| must be ignored if it is PP_VARTYPE_UNDEFINED or |code| is
 156     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED.
 157     if (reason.type != PP_VARTYPE_UNDEFINED) {
 158       // Validate |reason|.
 159       reason_string_var = StringVar::FromPPVar(reason);
 160       if (!reason_string_var.get() ||
 161           reason_string_var->value().size() > kMaxReasonSizeInBytes)
 162         return PP_ERROR_BADARGUMENT;
 163       reason_string = reason_string_var->value();
 164     }
 165   }
 166
 167   // Check state.
 168   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING)
 169     return PP_ERROR_INPROGRESS;
 170   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
 171     return PP_OK;
 172
 173   // Install |callback|.
 174   close_callback_ = callback;
 175
 176   // Abort ongoing connect.
 177   if (TrackedCallback::IsPending(connect_callback_)) {
 178     state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
 179     // Need to do a "Post" to avoid reentering the plugin.
 180     connect_callback_->PostAbort();
 181     connect_callback_ = NULL;
 182     Post(RENDERER, PpapiHostMsg_WebSocket_Fail(
 183         "WebSocket was closed before the connection was established."));
 184     return PP_OK_COMPLETIONPENDING;
 185   }
 186
 187   // Abort ongoing receive.
 188   if (TrackedCallback::IsPending(receive_callback_)) {
 189     receive_callback_var_ = NULL;
 190     // Need to do a "Post" to avoid reentering the plugin.
 191     receive_callback_->PostAbort();
 192     receive_callback_ = NULL;
 193   }
 194
 195   // Close connection.
 196   state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
 197   PpapiHostMsg_WebSocket_Close msg(static_cast<int32_t>(event_code),
 198                                    reason_string);
 199   Call<PpapiPluginMsg_WebSocket_CloseReply>(RENDERER, msg,
 200       base::Bind(&WebSocketResource::OnPluginMsgCloseReply, this));
 201   return PP_OK_COMPLETIONPENDING;
 202 }
 203
 204 int32_t WebSocketResource::ReceiveMessage(
 205     PP_Var* message,
 206     scoped_refptr<TrackedCallback> callback) {
 207   if (TrackedCallback::IsPending(receive_callback_))
 208     return PP_ERROR_INPROGRESS;
 209
 210   // Check state.
 211   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
 212       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
 213     return PP_ERROR_BADARGUMENT;
 214
 215   // Just return received message if any received message is queued.
 216   if (!received_messages_.empty()) {
 217     receive_callback_var_ = message;
 218     return DoReceive();
 219   }
 220
 221   // Check state again. In CLOSED state, no more messages will be received.
 222   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
 223     return PP_ERROR_BADARGUMENT;
 224
 225   // Returns PP_ERROR_FAILED after an error is received and received messages
 226   // is exhausted.
 227   if (error_was_received_)
 228     return PP_ERROR_FAILED;
 229
 230   // Or retain |message| as buffer to store and install |callback|.
 231   receive_callback_var_ = message;
 232   receive_callback_ = callback;
 233
 234   return PP_OK_COMPLETIONPENDING;
 235 }
 236
 237 int32_t WebSocketResource::SendMessage(const PP_Var& message) {
 238   // Check state.
 239   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
 240       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
 241     return PP_ERROR_BADARGUMENT;
 242
 243   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING ||
 244       state_ == PP_WEBSOCKETREADYSTATE_CLOSED) {
 245     // Handle buffered_amount_after_close_.
 246     uint64_t payload_size = 0;
 247     if (message.type == PP_VARTYPE_STRING) {
 248       scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
 249       if (message_string.get())
 250         payload_size += message_string->value().length();
 251     } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
 252       scoped_refptr<ArrayBufferVar> message_array_buffer =
 253           ArrayBufferVar::FromPPVar(message);
 254       if (message_array_buffer.get())
 255         payload_size += message_array_buffer->ByteLength();
 256     } else {
 257       // TODO(toyoshim): Support Blob.
 258       return PP_ERROR_NOTSUPPORTED;
 259     }
 260
 261     buffered_amount_after_close_ =
 262         SaturateAdd(buffered_amount_after_close_, GetFrameSize(payload_size));
 263
 264     return PP_ERROR_FAILED;
 265   }
 266
 267   // Send the message.
 268   if (message.type == PP_VARTYPE_STRING) {
 269     // Convert message to std::string, then send it.
 270     scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
 271     if (!message_string.get())
 272       return PP_ERROR_BADARGUMENT;
 273     Post(RENDERER, PpapiHostMsg_WebSocket_SendText(message_string->value()));
 274   } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
 275     // Convert message to std::vector<uint8_t>, then send it.
 276     scoped_refptr<ArrayBufferVar> message_arraybuffer =
 277         ArrayBufferVar::FromPPVar(message);
 278     if (!message_arraybuffer.get())
 279       return PP_ERROR_BADARGUMENT;
 280     uint8_t* message_data = static_cast<uint8_t*>(message_arraybuffer->Map());
 281     uint32 message_length = message_arraybuffer->ByteLength();
 282     std::vector<uint8_t> message_vector(message_data,
 283                                         message_data + message_length);
 284     Post(RENDERER, PpapiHostMsg_WebSocket_SendBinary(message_vector));
 285   } else {
 286     // TODO(toyoshim): Support Blob.
 287     return PP_ERROR_NOTSUPPORTED;
 288   }
 289   return PP_OK;
 290 }
 291
 292 uint64_t WebSocketResource::GetBufferedAmount() {
 293   return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 294 }
 295
 296 uint16_t WebSocketResource::GetCloseCode() {
 297   return close_code_;
 298 }
 299
 300 PP_Var WebSocketResource::GetCloseReason() {
 301   if (!close_reason_.get())
 302     return empty_string_->GetPPVar();
 303   return close_reason_->GetPPVar();
 304 }
 305
 306 PP_Bool WebSocketResource::GetCloseWasClean() {
 307   return close_was_clean_;
 308 }
 309
 310 PP_Var WebSocketResource::GetExtensions() {
 311   return StringVar::StringToPPVar(std::string());
 312 }
 313
 314 PP_Var WebSocketResource::GetProtocol() {
 315   if (!protocol_.get())
 316     return empty_string_->GetPPVar();
 317   return protocol_->GetPPVar();
 318 }
 319
 320 PP_WebSocketReadyState WebSocketResource::GetReadyState() {
 321   return state_;
 322 }
 323
 324 PP_Var WebSocketResource::GetURL() {
 325   if (!url_.get())
 326     return empty_string_->GetPPVar();
 327   return url_->GetPPVar();
 328 }
 329
 330 void WebSocketResource::OnReplyReceived(
 331     const ResourceMessageReplyParams& params,
 332     const IPC::Message& msg) {
 333   if (params.sequence()) {
 334     PluginResource::OnReplyReceived(params, msg);
 335     return;
 336   }
 337
 338   IPC_BEGIN_MESSAGE_MAP(WebSocketResource, msg)
 339     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 340         PpapiPluginMsg_WebSocket_ReceiveTextReply,
 341         OnPluginMsgReceiveTextReply)
 342     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 343         PpapiPluginMsg_WebSocket_ReceiveBinaryReply,
 344         OnPluginMsgReceiveBinaryReply)
 345     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_0(
 346         PpapiPluginMsg_WebSocket_ErrorReply,
 347         OnPluginMsgErrorReply)
 348     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 349         PpapiPluginMsg_WebSocket_BufferedAmountReply,
 350         OnPluginMsgBufferedAmountReply)
 351     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 352         PpapiPluginMsg_WebSocket_StateReply,
 353         OnPluginMsgStateReply)
 354     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 355         PpapiPluginMsg_WebSocket_ClosedReply,
 356         OnPluginMsgClosedReply)
 357     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(NOTREACHED())
 358   IPC_END_MESSAGE_MAP()
 359 }
 360
 361 void WebSocketResource::OnPluginMsgConnectReply(
 362     const ResourceMessageReplyParams& params,
 363     const std::string& url,
 364     const std::string& protocol) {
 365   if (!TrackedCallback::IsPending(connect_callback_))
 366     return;
 367
 368   int32_t result = params.result();
 369   if (result == PP_OK) {
 370     state_ = PP_WEBSOCKETREADYSTATE_OPEN;
 371     protocol_ = new StringVar(protocol);
 372     url_ = new StringVar(url);
 373   }
 374   connect_callback_->Run(params.result());
 375 }
 376
 377 void WebSocketResource::OnPluginMsgCloseReply(
 378     const ResourceMessageReplyParams& params,
 379     unsigned long buffered_amount,
 380     bool was_clean,
 381     unsigned short code,
 382     const std::string& reason) {
 383   // Set close related properties.
 384   state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
 385   buffered_amount_ = buffered_amount;
 386   close_was_clean_ = PP_FromBool(was_clean);
 387   close_code_ = code;
 388   close_reason_ = new StringVar(reason);
 389
 390   if (TrackedCallback::IsPending(receive_callback_)) {
 391     receive_callback_var_ = NULL;
 392     receive_callback_->PostRun(PP_ERROR_FAILED);
 393     receive_callback_ = NULL;
 394   }
 395
 396   if (TrackedCallback::IsPending(close_callback_)) {
 397     close_callback_->PostRun(params.result());
 398     close_callback_ = NULL;
 399   }
 400 }
 401
 402 void WebSocketResource::OnPluginMsgReceiveTextReply(
 403     const ResourceMessageReplyParams& params,
 404     const std::string& message) {
 405   // Dispose packets after receiving an error or in invalid state.
 406   if (error_was_received_ || !InValidStateToReceive(state_))
 407     return;
 408
 409   // Append received data to queue.
 410   received_messages_.push(scoped_refptr<Var>(new StringVar(message)));
 411
 412   if (!TrackedCallback::IsPending(receive_callback_))
 413     return;
 414
 415   receive_callback_->Run(DoReceive());
 416 }
 417
 418 void WebSocketResource::OnPluginMsgReceiveBinaryReply(
 419     const ResourceMessageReplyParams& params,
 420     const std::vector<uint8_t>& message) {
 421   // Dispose packets after receiving an error or in invalid state.
 422   if (error_was_received_ || !InValidStateToReceive(state_))
 423     return;
 424
 425   // Append received data to queue.
 426   scoped_refptr<Var> message_var(
 427       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferVar(
 428           message.size(),
 429           &message.front()));
 430   received_messages_.push(message_var);
 431
 432   if (!TrackedCallback::IsPending(receive_callback_))
 433     return;
 434
 435   receive_callback_->Run(DoReceive());
 436 }
 437
 438 void WebSocketResource::OnPluginMsgErrorReply(
 439     const ResourceMessageReplyParams& params) {
 440   error_was_received_ = true;
 441
 442   if (!TrackedCallback::IsPending(receive_callback_))
 443     return;
 444
 445   // No more text or binary messages will be received. If there is ongoing
 446   // ReceiveMessage(), we must invoke the callback with error code here.
 447   receive_callback_var_ = NULL;
 448   receive_callback_->Run(PP_ERROR_FAILED);
 449 }
 450
 451 void WebSocketResource::OnPluginMsgBufferedAmountReply(
 452     const ResourceMessageReplyParams& params,
 453     unsigned long buffered_amount) {
 454   buffered_amount_ = buffered_amount;
 455 }
 456
 457 void WebSocketResource::OnPluginMsgStateReply(
 458     const ResourceMessageReplyParams& params,
 459     int32_t state) {
 460   state_ = static_cast<PP_WebSocketReadyState>(state);
 461 }
 462
 463 void WebSocketResource::OnPluginMsgClosedReply(
 464     const ResourceMessageReplyParams& params,
 465     unsigned long buffered_amount,
 466     bool was_clean,
 467     unsigned short code,
 468     const std::string& reason) {
 469   OnPluginMsgCloseReply(params, buffered_amount, was_clean, code, reason);
 470 }
 471
 472 int32_t WebSocketResource::DoReceive() {
 473   if (!receive_callback_var_)
 474     return PP_OK;
 475
 476   *receive_callback_var_ = received_messages_.front()->GetPPVar();
 477   received_messages_.pop();
 478   receive_callback_var_ = NULL;
 479   return PP_OK;
 480 }
 481
 482 }  // namespace proxy
 483 }  // namespace ppapi