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 <string>
   9 #include <vector>
  10
  11 #include "base/bind.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/proxy/dispatch_reply_message.h"
  14 #include "ppapi/proxy/ppapi_messages.h"
  15 #include "ppapi/shared_impl/ppapi_globals.h"
  16 #include "ppapi/shared_impl/var.h"
  17 #include "ppapi/shared_impl/var_tracker.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   if (code != PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED) {
 140     if (code != PP_WEBSOCKETSTATUSCODE_NORMAL_CLOSURE &&
 141         (code < PP_WEBSOCKETSTATUSCODE_USER_REGISTERED_MIN ||
 142         code > PP_WEBSOCKETSTATUSCODE_USER_PRIVATE_MAX))
 143       // RFC 6455 limits applications to use reserved connection close code in
 144       // section 7.4.2.. The WebSocket API (http://www.w3.org/TR/websockets/)
 145       // defines this out of range error as InvalidAccessError in JavaScript.
 146       return PP_ERROR_NOACCESS;
 147
 148     // |reason| must be ignored if it is PP_VARTYPE_UNDEFINED or |code| is
 149     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED.
 150     if (reason.type != PP_VARTYPE_UNDEFINED) {
 151       // Validate |reason|.
 152       reason_string_var = StringVar::FromPPVar(reason);
 153       if (!reason_string_var.get() ||
 154           reason_string_var->value().size() > kMaxReasonSizeInBytes)
 155         return PP_ERROR_BADARGUMENT;
 156       reason_string = reason_string_var->value();
 157     }
 158   }
 159
 160   // Check state.
 161   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING)
 162     return PP_ERROR_INPROGRESS;
 163   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
 164     return PP_OK;
 165
 166   // Install |callback|.
 167   close_callback_ = callback;
 168
 169   // Abort ongoing connect.
 170   if (TrackedCallback::IsPending(connect_callback_)) {
 171     state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
 172     // Need to do a "Post" to avoid reentering the plugin.
 173     connect_callback_->PostAbort();
 174     connect_callback_ = NULL;
 175     Post(RENDERER, PpapiHostMsg_WebSocket_Fail(
 176         "WebSocket was closed before the connection was established."));
 177     return PP_OK_COMPLETIONPENDING;
 178   }
 179
 180   // Abort ongoing receive.
 181   if (TrackedCallback::IsPending(receive_callback_)) {
 182     receive_callback_var_ = NULL;
 183     // Need to do a "Post" to avoid reentering the plugin.
 184     receive_callback_->PostAbort();
 185     receive_callback_ = NULL;
 186   }
 187
 188   // Close connection.
 189   state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
 190   PpapiHostMsg_WebSocket_Close msg(static_cast<int32_t>(code),
 191                                    reason_string);
 192   Call<PpapiPluginMsg_WebSocket_CloseReply>(RENDERER, msg,
 193       base::Bind(&WebSocketResource::OnPluginMsgCloseReply, this));
 194   return PP_OK_COMPLETIONPENDING;
 195 }
 196
 197 int32_t WebSocketResource::ReceiveMessage(
 198     PP_Var* message,
 199     scoped_refptr<TrackedCallback> callback) {
 200   if (TrackedCallback::IsPending(receive_callback_))
 201     return PP_ERROR_INPROGRESS;
 202
 203   // Check state.
 204   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
 205       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
 206     return PP_ERROR_BADARGUMENT;
 207
 208   // Just return received message if any received message is queued.
 209   if (!received_messages_.empty()) {
 210     receive_callback_var_ = message;
 211     return DoReceive();
 212   }
 213
 214   // Check state again. In CLOSED state, no more messages will be received.
 215   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
 216     return PP_ERROR_BADARGUMENT;
 217
 218   // Returns PP_ERROR_FAILED after an error is received and received messages
 219   // is exhausted.
 220   if (error_was_received_)
 221     return PP_ERROR_FAILED;
 222
 223   // Or retain |message| as buffer to store and install |callback|.
 224   receive_callback_var_ = message;
 225   receive_callback_ = callback;
 226
 227   return PP_OK_COMPLETIONPENDING;
 228 }
 229
 230 int32_t WebSocketResource::SendMessage(const PP_Var& message) {
 231   // Check state.
 232   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
 233       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
 234     return PP_ERROR_BADARGUMENT;
 235
 236   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING ||
 237       state_ == PP_WEBSOCKETREADYSTATE_CLOSED) {
 238     // Handle buffered_amount_after_close_.
 239     uint64_t payload_size = 0;
 240     if (message.type == PP_VARTYPE_STRING) {
 241       scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
 242       if (message_string.get())
 243         payload_size += message_string->value().length();
 244     } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
 245       scoped_refptr<ArrayBufferVar> message_array_buffer =
 246           ArrayBufferVar::FromPPVar(message);
 247       if (message_array_buffer.get())
 248         payload_size += message_array_buffer->ByteLength();
 249     } else {
 250       // TODO(toyoshim): Support Blob.
 251       return PP_ERROR_NOTSUPPORTED;
 252     }
 253
 254     buffered_amount_after_close_ =
 255         SaturateAdd(buffered_amount_after_close_, GetFrameSize(payload_size));
 256
 257     return PP_ERROR_FAILED;
 258   }
 259
 260   // Send the message.
 261   if (message.type == PP_VARTYPE_STRING) {
 262     // Convert message to std::string, then send it.
 263     scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
 264     if (!message_string.get())
 265       return PP_ERROR_BADARGUMENT;
 266     Post(RENDERER, PpapiHostMsg_WebSocket_SendText(message_string->value()));
 267   } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
 268     // Convert message to std::vector<uint8_t>, then send it.
 269     scoped_refptr<ArrayBufferVar> message_arraybuffer =
 270         ArrayBufferVar::FromPPVar(message);
 271     if (!message_arraybuffer.get())
 272       return PP_ERROR_BADARGUMENT;
 273     uint8_t* message_data = static_cast<uint8_t*>(message_arraybuffer->Map());
 274     uint32 message_length = message_arraybuffer->ByteLength();
 275     std::vector<uint8_t> message_vector(message_data,
 276                                         message_data + message_length);
 277     Post(RENDERER, PpapiHostMsg_WebSocket_SendBinary(message_vector));
 278   } else {
 279     // TODO(toyoshim): Support Blob.
 280     return PP_ERROR_NOTSUPPORTED;
 281   }
 282   return PP_OK;
 283 }
 284
 285 uint64_t WebSocketResource::GetBufferedAmount() {
 286   return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 287 }
 288
 289 uint16_t WebSocketResource::GetCloseCode() {
 290   return close_code_;
 291 }
 292
 293 PP_Var WebSocketResource::GetCloseReason() {
 294   if (!close_reason_.get())
 295     return empty_string_->GetPPVar();
 296   return close_reason_->GetPPVar();
 297 }
 298
 299 PP_Bool WebSocketResource::GetCloseWasClean() {
 300   return close_was_clean_;
 301 }
 302
 303 PP_Var WebSocketResource::GetExtensions() {
 304   return StringVar::StringToPPVar(std::string());
 305 }
 306
 307 PP_Var WebSocketResource::GetProtocol() {
 308   if (!protocol_.get())
 309     return empty_string_->GetPPVar();
 310   return protocol_->GetPPVar();
 311 }
 312
 313 PP_WebSocketReadyState WebSocketResource::GetReadyState() {
 314   return state_;
 315 }
 316
 317 PP_Var WebSocketResource::GetURL() {
 318   if (!url_.get())
 319     return empty_string_->GetPPVar();
 320   return url_->GetPPVar();
 321 }
 322
 323 void WebSocketResource::OnReplyReceived(
 324     const ResourceMessageReplyParams& params,
 325     const IPC::Message& msg) {
 326   if (params.sequence()) {
 327     PluginResource::OnReplyReceived(params, msg);
 328     return;
 329   }
 330
 331   PPAPI_BEGIN_MESSAGE_MAP(WebSocketResource, msg)
 332     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 333         PpapiPluginMsg_WebSocket_ReceiveTextReply,
 334         OnPluginMsgReceiveTextReply)
 335     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 336         PpapiPluginMsg_WebSocket_ReceiveBinaryReply,
 337         OnPluginMsgReceiveBinaryReply)
 338     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_0(
 339         PpapiPluginMsg_WebSocket_ErrorReply,
 340         OnPluginMsgErrorReply)
 341     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 342         PpapiPluginMsg_WebSocket_BufferedAmountReply,
 343         OnPluginMsgBufferedAmountReply)
 344     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 345         PpapiPluginMsg_WebSocket_StateReply,
 346         OnPluginMsgStateReply)
 347     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 348         PpapiPluginMsg_WebSocket_ClosedReply,
 349         OnPluginMsgClosedReply)
 350     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(NOTREACHED())
 351   PPAPI_END_MESSAGE_MAP()
 352 }
 353
 354 void WebSocketResource::OnPluginMsgConnectReply(
 355     const ResourceMessageReplyParams& params,
 356     const std::string& url,
 357     const std::string& protocol) {
 358   if (!TrackedCallback::IsPending(connect_callback_) ||
 359       TrackedCallback::IsScheduledToRun(connect_callback_)) {
 360     return;
 361   }
 362
 363   int32_t result = params.result();
 364   if (result == PP_OK) {
 365     state_ = PP_WEBSOCKETREADYSTATE_OPEN;
 366     protocol_ = new StringVar(protocol);
 367     url_ = new StringVar(url);
 368   }
 369   connect_callback_->Run(params.result());
 370 }
 371
 372 void WebSocketResource::OnPluginMsgCloseReply(
 373     const ResourceMessageReplyParams& params,
 374     unsigned long buffered_amount,
 375     bool was_clean,
 376     unsigned short code,
 377     const std::string& reason) {
 378   // Set close related properties.
 379   state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
 380   buffered_amount_ = buffered_amount;
 381   close_was_clean_ = PP_FromBool(was_clean);
 382   close_code_ = code;
 383   close_reason_ = new StringVar(reason);
 384
 385   if (TrackedCallback::IsPending(receive_callback_)) {
 386     receive_callback_var_ = NULL;
 387     if (!TrackedCallback::IsScheduledToRun(receive_callback_))
 388       receive_callback_->PostRun(PP_ERROR_FAILED);
 389     receive_callback_ = NULL;
 390   }
 391
 392   if (TrackedCallback::IsPending(close_callback_)) {
 393     if (!TrackedCallback::IsScheduledToRun(close_callback_))
 394       close_callback_->PostRun(params.result());
 395     close_callback_ = NULL;
 396   }
 397 }
 398
 399 void WebSocketResource::OnPluginMsgReceiveTextReply(
 400     const ResourceMessageReplyParams& params,
 401     const std::string& message) {
 402   // Dispose packets after receiving an error or in invalid state.
 403   if (error_was_received_ || !InValidStateToReceive(state_))
 404     return;
 405
 406   // Append received data to queue.
 407   received_messages_.push(scoped_refptr<Var>(new StringVar(message)));
 408
 409   if (!TrackedCallback::IsPending(receive_callback_) ||
 410       TrackedCallback::IsScheduledToRun(receive_callback_)) {
 411     return;
 412   }
 413
 414   receive_callback_->Run(DoReceive());
 415 }
 416
 417 void WebSocketResource::OnPluginMsgReceiveBinaryReply(
 418     const ResourceMessageReplyParams& params,
 419     const std::vector<uint8_t>& message) {
 420   // Dispose packets after receiving an error or in invalid state.
 421   if (error_was_received_ || !InValidStateToReceive(state_))
 422     return;
 423
 424   // Append received data to queue.
 425   scoped_refptr<Var> message_var(
 426       PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferVar(
 427           message.size(),
 428           &message.front()));
 429   received_messages_.push(message_var);
 430
 431   if (!TrackedCallback::IsPending(receive_callback_) ||
 432       TrackedCallback::IsScheduledToRun(receive_callback_)) {
 433     return;
 434   }
 435
 436   receive_callback_->Run(DoReceive());
 437 }
 438
 439 void WebSocketResource::OnPluginMsgErrorReply(
 440     const ResourceMessageReplyParams& params) {
 441   error_was_received_ = true;
 442
 443   if (!TrackedCallback::IsPending(receive_callback_) ||
 444       TrackedCallback::IsScheduledToRun(receive_callback_)) {
 445     return;
 446   }
 447
 448   // No more text or binary messages will be received. If there is ongoing
 449   // ReceiveMessage(), we must invoke the callback with error code here.
 450   receive_callback_var_ = NULL;
 451   receive_callback_->Run(PP_ERROR_FAILED);
 452 }
 453
 454 void WebSocketResource::OnPluginMsgBufferedAmountReply(
 455     const ResourceMessageReplyParams& params,
 456     unsigned long buffered_amount) {
 457   buffered_amount_ = buffered_amount;
 458 }
 459
 460 void WebSocketResource::OnPluginMsgStateReply(
 461     const ResourceMessageReplyParams& params,
 462     int32_t state) {
 463   state_ = static_cast<PP_WebSocketReadyState>(state);
 464 }
 465
 466 void WebSocketResource::OnPluginMsgClosedReply(
 467     const ResourceMessageReplyParams& params,
 468     unsigned long buffered_amount,
 469     bool was_clean,
 470     unsigned short code,
 471     const std::string& reason) {
 472   OnPluginMsgCloseReply(params, buffered_amount, was_clean, code, reason);
 473 }
 474
 475 int32_t WebSocketResource::DoReceive() {
 476   if (!receive_callback_var_)
 477     return PP_OK;
 478
 479   *receive_callback_var_ = received_messages_.front()->GetPPVar();
 480   received_messages_.pop();
 481   receive_callback_var_ = NULL;
 482   return PP_OK;
 483 }
 484
 485 }  // namespace proxy
 486 }  // namespace ppapi