ppapi/proxy/tcp_socket_resource_base.cc

   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 "ppapi/proxy/tcp_socket_resource_base.h"
   6
   7 #include <cstring>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "ppapi/c/pp_bool.h"
  12 #include "ppapi/c/pp_errors.h"
  13 #include "ppapi/proxy/error_conversion.h"
  14 #include "ppapi/proxy/ppapi_messages.h"
  15 #include "ppapi/shared_impl/ppapi_globals.h"
  16 #include "ppapi/shared_impl/private/ppb_x509_certificate_private_shared.h"
  17 #include "ppapi/shared_impl/socket_option_data.h"
  18 #include "ppapi/shared_impl/var.h"
  19 #include "ppapi/shared_impl/var_tracker.h"
  20 #include "ppapi/thunk/enter.h"
  21 #include "ppapi/thunk/ppb_x509_certificate_private_api.h"
  22
  23 namespace ppapi {
  24 namespace proxy {
  25
  26 const int32_t TCPSocketResourceBase::kMaxReadSize = 1024 * 1024;
  27 const int32_t TCPSocketResourceBase::kMaxWriteSize = 1024 * 1024;
  28 const int32_t TCPSocketResourceBase::kMaxSendBufferSize =
  29     1024 * TCPSocketResourceBase::kMaxWriteSize;
  30 const int32_t TCPSocketResourceBase::kMaxReceiveBufferSize =
  31     1024 * TCPSocketResourceBase::kMaxReadSize;
  32
  33 TCPSocketResourceBase::TCPSocketResourceBase(Connection connection,
  34                                              PP_Instance instance,
  35                                              TCPSocketVersion version)
  36     : PluginResource(connection, instance),
  37       state_(TCPSocketState::INITIAL),
  38       read_buffer_(NULL),
  39       bytes_to_read_(-1),
  40       accepted_tcp_socket_(NULL),
  41       version_(version) {
  42   local_addr_.size = 0;
  43   memset(local_addr_.data, 0,
  44          arraysize(local_addr_.data) * sizeof(*local_addr_.data));
  45   remote_addr_.size = 0;
  46   memset(remote_addr_.data, 0,
  47          arraysize(remote_addr_.data) * sizeof(*remote_addr_.data));
  48 }
  49
  50 TCPSocketResourceBase::TCPSocketResourceBase(
  51     Connection connection,
  52     PP_Instance instance,
  53     TCPSocketVersion version,
  54     const PP_NetAddress_Private& local_addr,
  55     const PP_NetAddress_Private& remote_addr)
  56     : PluginResource(connection, instance),
  57       state_(TCPSocketState::CONNECTED),
  58       read_buffer_(NULL),
  59       bytes_to_read_(-1),
  60       local_addr_(local_addr),
  61       remote_addr_(remote_addr),
  62       accepted_tcp_socket_(NULL),
  63       version_(version) {
  64 }
  65
  66 TCPSocketResourceBase::~TCPSocketResourceBase() {
  67   CloseImpl();
  68 }
  69
  70 int32_t TCPSocketResourceBase::BindImpl(
  71     const PP_NetAddress_Private* addr,
  72     scoped_refptr<TrackedCallback> callback) {
  73   if (!addr)
  74     return PP_ERROR_BADARGUMENT;
  75   if (state_.IsPending(TCPSocketState::BIND))
  76     return PP_ERROR_INPROGRESS;
  77   if (!state_.IsValidTransition(TCPSocketState::BIND))
  78     return PP_ERROR_FAILED;
  79
  80   bind_callback_ = callback;
  81   state_.SetPendingTransition(TCPSocketState::BIND);
  82
  83   Call<PpapiPluginMsg_TCPSocket_BindReply>(
  84       BROWSER,
  85       PpapiHostMsg_TCPSocket_Bind(*addr),
  86       base::Bind(&TCPSocketResourceBase::OnPluginMsgBindReply,
  87                  base::Unretained(this)),
  88       callback);
  89   return PP_OK_COMPLETIONPENDING;
  90 }
  91
  92 int32_t TCPSocketResourceBase::ConnectImpl(
  93     const char* host,
  94     uint16_t port,
  95     scoped_refptr<TrackedCallback> callback) {
  96   if (!host)
  97     return PP_ERROR_BADARGUMENT;
  98   if (state_.IsPending(TCPSocketState::CONNECT))
  99     return PP_ERROR_INPROGRESS;
 100   if (!state_.IsValidTransition(TCPSocketState::CONNECT))
 101     return PP_ERROR_FAILED;
 102
 103   connect_callback_ = callback;
 104   state_.SetPendingTransition(TCPSocketState::CONNECT);
 105
 106   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
 107       BROWSER,
 108       PpapiHostMsg_TCPSocket_Connect(host, port),
 109       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
 110                  base::Unretained(this)),
 111       callback);
 112   return PP_OK_COMPLETIONPENDING;
 113 }
 114
 115 int32_t TCPSocketResourceBase::ConnectWithNetAddressImpl(
 116     const PP_NetAddress_Private* addr,
 117     scoped_refptr<TrackedCallback> callback) {
 118   if (!addr)
 119     return PP_ERROR_BADARGUMENT;
 120   if (state_.IsPending(TCPSocketState::CONNECT))
 121     return PP_ERROR_INPROGRESS;
 122   if (!state_.IsValidTransition(TCPSocketState::CONNECT))
 123     return PP_ERROR_FAILED;
 124
 125   connect_callback_ = callback;
 126   state_.SetPendingTransition(TCPSocketState::CONNECT);
 127
 128   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
 129       BROWSER,
 130       PpapiHostMsg_TCPSocket_ConnectWithNetAddress(*addr),
 131       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
 132                  base::Unretained(this)),
 133       callback);
 134   return PP_OK_COMPLETIONPENDING;
 135 }
 136
 137 PP_Bool TCPSocketResourceBase::GetLocalAddressImpl(
 138     PP_NetAddress_Private* local_addr) {
 139   if (!state_.IsBound() || !local_addr)
 140     return PP_FALSE;
 141   *local_addr = local_addr_;
 142   return PP_TRUE;
 143 }
 144
 145 PP_Bool TCPSocketResourceBase::GetRemoteAddressImpl(
 146     PP_NetAddress_Private* remote_addr) {
 147   if (!state_.IsConnected() || !remote_addr)
 148     return PP_FALSE;
 149   *remote_addr = remote_addr_;
 150   return PP_TRUE;
 151 }
 152
 153 int32_t TCPSocketResourceBase::SSLHandshakeImpl(
 154     const char* server_name,
 155     uint16_t server_port,
 156     scoped_refptr<TrackedCallback> callback) {
 157   if (!server_name)
 158     return PP_ERROR_BADARGUMENT;
 159
 160   if (state_.IsPending(TCPSocketState::SSL_CONNECT) ||
 161       TrackedCallback::IsPending(read_callback_) ||
 162       TrackedCallback::IsPending(write_callback_)) {
 163     return PP_ERROR_INPROGRESS;
 164   }
 165   if (!state_.IsValidTransition(TCPSocketState::SSL_CONNECT))
 166     return PP_ERROR_FAILED;
 167
 168   ssl_handshake_callback_ = callback;
 169   state_.SetPendingTransition(TCPSocketState::SSL_CONNECT);
 170
 171   Call<PpapiPluginMsg_TCPSocket_SSLHandshakeReply>(
 172       BROWSER,
 173       PpapiHostMsg_TCPSocket_SSLHandshake(server_name,
 174                                           server_port,
 175                                           trusted_certificates_,
 176                                           untrusted_certificates_),
 177       base::Bind(&TCPSocketResourceBase::OnPluginMsgSSLHandshakeReply,
 178                  base::Unretained(this)),
 179       callback);
 180   return PP_OK_COMPLETIONPENDING;
 181 }
 182
 183 PP_Resource TCPSocketResourceBase::GetServerCertificateImpl() {
 184   if (!server_certificate_.get())
 185     return 0;
 186   return server_certificate_->GetReference();
 187 }
 188
 189 PP_Bool TCPSocketResourceBase::AddChainBuildingCertificateImpl(
 190     PP_Resource certificate,
 191     PP_Bool trusted) {
 192   // TODO(raymes): This is exposed in the private PPB_TCPSocket_Private
 193   // interface for Flash but isn't currently implemented due to security
 194   // implications. It is exposed so that it can be hooked up on the Flash side
 195   // and if we decide to implement it we can do so without modifying the Flash
 196   // codebase.
 197   NOTIMPLEMENTED();
 198   return PP_FALSE;
 199 }
 200
 201 int32_t TCPSocketResourceBase::ReadImpl(
 202     char* buffer,
 203     int32_t bytes_to_read,
 204     scoped_refptr<TrackedCallback> callback) {
 205   if (!buffer || bytes_to_read <= 0)
 206     return PP_ERROR_BADARGUMENT;
 207
 208   if (!state_.IsConnected())
 209     return PP_ERROR_FAILED;
 210   if (TrackedCallback::IsPending(read_callback_) ||
 211       state_.IsPending(TCPSocketState::SSL_CONNECT))
 212     return PP_ERROR_INPROGRESS;
 213   read_buffer_ = buffer;
 214   bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);
 215   read_callback_ = callback;
 216
 217   Call<PpapiPluginMsg_TCPSocket_ReadReply>(
 218       BROWSER,
 219       PpapiHostMsg_TCPSocket_Read(bytes_to_read_),
 220       base::Bind(&TCPSocketResourceBase::OnPluginMsgReadReply,
 221                  base::Unretained(this)),
 222       callback);
 223   return PP_OK_COMPLETIONPENDING;
 224 }
 225
 226 int32_t TCPSocketResourceBase::WriteImpl(
 227     const char* buffer,
 228     int32_t bytes_to_write,
 229     scoped_refptr<TrackedCallback> callback) {
 230   if (!buffer || bytes_to_write <= 0)
 231     return PP_ERROR_BADARGUMENT;
 232
 233   if (!state_.IsConnected())
 234     return PP_ERROR_FAILED;
 235   if (TrackedCallback::IsPending(write_callback_) ||
 236       state_.IsPending(TCPSocketState::SSL_CONNECT))
 237     return PP_ERROR_INPROGRESS;
 238
 239   if (bytes_to_write > kMaxWriteSize)
 240     bytes_to_write = kMaxWriteSize;
 241
 242   write_callback_ = callback;
 243
 244   Call<PpapiPluginMsg_TCPSocket_WriteReply>(
 245       BROWSER,
 246       PpapiHostMsg_TCPSocket_Write(std::string(buffer, bytes_to_write)),
 247       base::Bind(&TCPSocketResourceBase::OnPluginMsgWriteReply,
 248                  base::Unretained(this)),
 249       callback);
 250   return PP_OK_COMPLETIONPENDING;
 251 }
 252
 253 int32_t TCPSocketResourceBase::ListenImpl(
 254     int32_t backlog,
 255     scoped_refptr<TrackedCallback> callback) {
 256   if (backlog <= 0)
 257     return PP_ERROR_BADARGUMENT;
 258   if (state_.IsPending(TCPSocketState::LISTEN))
 259     return PP_ERROR_INPROGRESS;
 260   if (!state_.IsValidTransition(TCPSocketState::LISTEN))
 261     return PP_ERROR_FAILED;
 262
 263   listen_callback_ = callback;
 264   state_.SetPendingTransition(TCPSocketState::LISTEN);
 265
 266   Call<PpapiPluginMsg_TCPSocket_ListenReply>(
 267       BROWSER,
 268       PpapiHostMsg_TCPSocket_Listen(backlog),
 269       base::Bind(&TCPSocketResourceBase::OnPluginMsgListenReply,
 270                  base::Unretained(this)),
 271       callback);
 272   return PP_OK_COMPLETIONPENDING;
 273 }
 274
 275 int32_t TCPSocketResourceBase::AcceptImpl(
 276     PP_Resource* accepted_tcp_socket,
 277     scoped_refptr<TrackedCallback> callback) {
 278   if (!accepted_tcp_socket)
 279     return PP_ERROR_BADARGUMENT;
 280   if (TrackedCallback::IsPending(accept_callback_))
 281     return PP_ERROR_INPROGRESS;
 282   if (state_.state() != TCPSocketState::LISTENING)
 283     return PP_ERROR_FAILED;
 284
 285   accept_callback_ = callback;
 286   accepted_tcp_socket_ = accepted_tcp_socket;
 287
 288   Call<PpapiPluginMsg_TCPSocket_AcceptReply>(
 289       BROWSER,
 290       PpapiHostMsg_TCPSocket_Accept(),
 291       base::Bind(&TCPSocketResourceBase::OnPluginMsgAcceptReply,
 292                  base::Unretained(this)),
 293       callback);
 294   return PP_OK_COMPLETIONPENDING;
 295 }
 296
 297 void TCPSocketResourceBase::CloseImpl() {
 298   if (state_.state() == TCPSocketState::CLOSED)
 299     return;
 300
 301   state_.DoTransition(TCPSocketState::CLOSE, true);
 302
 303   Post(BROWSER, PpapiHostMsg_TCPSocket_Close());
 304
 305   PostAbortIfNecessary(&bind_callback_);
 306   PostAbortIfNecessary(&connect_callback_);
 307   PostAbortIfNecessary(&ssl_handshake_callback_);
 308   PostAbortIfNecessary(&read_callback_);
 309   PostAbortIfNecessary(&write_callback_);
 310   PostAbortIfNecessary(&listen_callback_);
 311   PostAbortIfNecessary(&accept_callback_);
 312   read_buffer_ = NULL;
 313   bytes_to_read_ = -1;
 314   server_certificate_ = NULL;
 315   accepted_tcp_socket_ = NULL;
 316 }
 317
 318 int32_t TCPSocketResourceBase::SetOptionImpl(
 319     PP_TCPSocket_Option name,
 320     const PP_Var& value,
 321     scoped_refptr<TrackedCallback> callback) {
 322   SocketOptionData option_data;
 323   switch (name) {
 324     case PP_TCPSOCKET_OPTION_NO_DELAY: {
 325       if (!state_.IsConnected())
 326         return PP_ERROR_FAILED;
 327
 328       if (value.type != PP_VARTYPE_BOOL)
 329         return PP_ERROR_BADARGUMENT;
 330       option_data.SetBool(PP_ToBool(value.value.as_bool));
 331       break;
 332     }
 333     case PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE:
 334     case PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE: {
 335       if (!state_.IsConnected())
 336         return PP_ERROR_FAILED;
 337
 338       if (value.type != PP_VARTYPE_INT32)
 339         return PP_ERROR_BADARGUMENT;
 340       option_data.SetInt32(value.value.as_int);
 341       break;
 342     }
 343     default: {
 344       NOTREACHED();
 345       return PP_ERROR_BADARGUMENT;
 346     }
 347   }
 348
 349   set_option_callbacks_.push(callback);
 350
 351   Call<PpapiPluginMsg_TCPSocket_SetOptionReply>(
 352       BROWSER,
 353       PpapiHostMsg_TCPSocket_SetOption(name, option_data),
 354       base::Bind(&TCPSocketResourceBase::OnPluginMsgSetOptionReply,
 355                  base::Unretained(this)),
 356       callback);
 357   return PP_OK_COMPLETIONPENDING;
 358 }
 359
 360 void TCPSocketResourceBase::PostAbortIfNecessary(
 361     scoped_refptr<TrackedCallback>* callback) {
 362   if (TrackedCallback::IsPending(*callback))
 363     (*callback)->PostAbort();
 364 }
 365
 366 void TCPSocketResourceBase::OnPluginMsgBindReply(
 367     const ResourceMessageReplyParams& params,
 368     const PP_NetAddress_Private& local_addr) {
 369   // It is possible that CloseImpl() has been called. We don't want to update
 370   // class members in this case.
 371   if (!state_.IsPending(TCPSocketState::BIND))
 372     return;
 373
 374   DCHECK(TrackedCallback::IsPending(bind_callback_));
 375   if (params.result() == PP_OK) {
 376     local_addr_ = local_addr;
 377     state_.CompletePendingTransition(true);
 378   } else {
 379     state_.CompletePendingTransition(false);
 380   }
 381   RunCallback(bind_callback_, params.result());
 382 }
 383
 384 void TCPSocketResourceBase::OnPluginMsgConnectReply(
 385     const ResourceMessageReplyParams& params,
 386     const PP_NetAddress_Private& local_addr,
 387     const PP_NetAddress_Private& remote_addr) {
 388   // It is possible that CloseImpl() has been called. We don't want to update
 389   // class members in this case.
 390   if (!state_.IsPending(TCPSocketState::CONNECT))
 391     return;
 392
 393   DCHECK(TrackedCallback::IsPending(connect_callback_));
 394   if (params.result() == PP_OK) {
 395     local_addr_ = local_addr;
 396     remote_addr_ = remote_addr;
 397     state_.CompletePendingTransition(true);
 398   } else {
 399     if (version_ == TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
 400       state_.CompletePendingTransition(false);
 401     } else {
 402       // In order to maintain backward compatibility, allow to connect the
 403       // socket again.
 404       state_ = TCPSocketState(TCPSocketState::INITIAL);
 405     }
 406   }
 407   RunCallback(connect_callback_, params.result());
 408 }
 409
 410 void TCPSocketResourceBase::OnPluginMsgSSLHandshakeReply(
 411       const ResourceMessageReplyParams& params,
 412       const PPB_X509Certificate_Fields& certificate_fields) {
 413   // It is possible that CloseImpl() has been called. We don't want to
 414   // update class members in this case.
 415   if (!state_.IsPending(TCPSocketState::SSL_CONNECT))
 416     return;
 417
 418   DCHECK(TrackedCallback::IsPending(ssl_handshake_callback_));
 419   if (params.result() == PP_OK) {
 420     state_.CompletePendingTransition(true);
 421     server_certificate_ = new PPB_X509Certificate_Private_Shared(
 422         OBJECT_IS_PROXY,
 423         pp_instance(),
 424         certificate_fields);
 425   } else {
 426     state_.CompletePendingTransition(false);
 427   }
 428   RunCallback(ssl_handshake_callback_, params.result());
 429 }
 430
 431 void TCPSocketResourceBase::OnPluginMsgReadReply(
 432     const ResourceMessageReplyParams& params,
 433     const std::string& data) {
 434   // It is possible that CloseImpl() has been called. We shouldn't access the
 435   // buffer in that case. The user may have released it.
 436   if (!state_.IsConnected() || !TrackedCallback::IsPending(read_callback_) ||
 437       !read_buffer_) {
 438     return;
 439   }
 440
 441   const bool succeeded = params.result() == PP_OK;
 442   if (succeeded) {
 443     CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
 444     if (!data.empty())
 445       memmove(read_buffer_, data.c_str(), data.size());
 446   }
 447   read_buffer_ = NULL;
 448   bytes_to_read_ = -1;
 449
 450   RunCallback(read_callback_,
 451               succeeded ? static_cast<int32_t>(data.size()) : params.result());
 452 }
 453
 454 void TCPSocketResourceBase::OnPluginMsgWriteReply(
 455     const ResourceMessageReplyParams& params) {
 456   if (!state_.IsConnected() || !TrackedCallback::IsPending(write_callback_))
 457     return;
 458   RunCallback(write_callback_, params.result());
 459 }
 460
 461 void TCPSocketResourceBase::OnPluginMsgListenReply(
 462     const ResourceMessageReplyParams& params) {
 463   if (!state_.IsPending(TCPSocketState::LISTEN))
 464     return;
 465
 466   DCHECK(TrackedCallback::IsPending(listen_callback_));
 467   state_.CompletePendingTransition(params.result() == PP_OK);
 468
 469   RunCallback(listen_callback_, params.result());
 470 }
 471
 472 void TCPSocketResourceBase::OnPluginMsgAcceptReply(
 473     const ResourceMessageReplyParams& params,
 474     int pending_host_id,
 475     const PP_NetAddress_Private& local_addr,
 476     const PP_NetAddress_Private& remote_addr) {
 477   // It is possible that CloseImpl() has been called. We shouldn't access the
 478   // output parameter in that case. The user may have released it.
 479   if (state_.state() != TCPSocketState::LISTENING ||
 480       !TrackedCallback::IsPending(accept_callback_) || !accepted_tcp_socket_) {
 481     return;
 482   }
 483
 484   if (params.result() == PP_OK) {
 485     *accepted_tcp_socket_ = CreateAcceptedSocket(pending_host_id, local_addr,
 486                                                  remote_addr);
 487   }
 488   accepted_tcp_socket_ = NULL;
 489   RunCallback(accept_callback_, params.result());
 490 }
 491
 492 void TCPSocketResourceBase::OnPluginMsgSetOptionReply(
 493     const ResourceMessageReplyParams& params) {
 494   if (set_option_callbacks_.empty()) {
 495     NOTREACHED();
 496     return;
 497   }
 498   scoped_refptr<TrackedCallback> callback = set_option_callbacks_.front();
 499   set_option_callbacks_.pop();
 500   if (TrackedCallback::IsPending(callback))
 501     RunCallback(callback, params.result());
 502 }
 503
 504 void TCPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
 505                                         int32_t pp_result) {
 506   callback->Run(ConvertNetworkAPIErrorForCompatibility(
 507       pp_result, version_ == TCP_SOCKET_VERSION_PRIVATE));
 508 }
 509
 510 }  // namespace ppapi
 511 }  // namespace proxy