Home | History | Annotate | Download | only in proxy 
      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): The plumbing for this functionality is implemented but the
    193   // certificates aren't yet used for the connection, so just return false for
    194   // now.
    195   return PP_FALSE;
    196 
    197   thunk::EnterResourceNoLock<thunk::PPB_X509Certificate_Private_API>
    198   enter_cert(certificate, true);
    199   if (enter_cert.failed())
    200     return PP_FALSE;
    201 
    202   PP_Var der_var = enter_cert.object()->GetField(
    203       PP_X509CERTIFICATE_PRIVATE_RAW);
    204   ArrayBufferVar* der_array_buffer = ArrayBufferVar::FromPPVar(der_var);
    205   PP_Bool success = PP_FALSE;
    206   if (der_array_buffer) {
    207     const char* der_bytes = static_cast<const char*>(der_array_buffer->Map());
    208     uint32_t der_length = der_array_buffer->ByteLength();
    209     std::vector<char> der(der_bytes, der_bytes + der_length);
    210     if (PP_ToBool(trusted))
    211       trusted_certificates_.push_back(der);
    212     else
    213       untrusted_certificates_.push_back(der);
    214     success = PP_TRUE;
    215   }
    216   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(der_var);
    217   return success;
    218 }
    219 
    220 int32_t TCPSocketResourceBase::ReadImpl(
    221     char* buffer,
    222     int32_t bytes_to_read,
    223     scoped_refptr<TrackedCallback> callback) {
    224   if (!buffer || bytes_to_read <= 0)
    225     return PP_ERROR_BADARGUMENT;
    226 
    227   if (!state_.IsConnected())
    228     return PP_ERROR_FAILED;
    229   if (TrackedCallback::IsPending(read_callback_) ||
    230       state_.IsPending(TCPSocketState::SSL_CONNECT))
    231     return PP_ERROR_INPROGRESS;
    232   read_buffer_ = buffer;
    233   bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);
    234   read_callback_ = callback;
    235 
    236   Call<PpapiPluginMsg_TCPSocket_ReadReply>(
    237       BROWSER,
    238       PpapiHostMsg_TCPSocket_Read(bytes_to_read_),
    239       base::Bind(&TCPSocketResourceBase::OnPluginMsgReadReply,
    240                  base::Unretained(this)),
    241       callback);
    242   return PP_OK_COMPLETIONPENDING;
    243 }
    244 
    245 int32_t TCPSocketResourceBase::WriteImpl(
    246     const char* buffer,
    247     int32_t bytes_to_write,
    248     scoped_refptr<TrackedCallback> callback) {
    249   if (!buffer || bytes_to_write <= 0)
    250     return PP_ERROR_BADARGUMENT;
    251 
    252   if (!state_.IsConnected())
    253     return PP_ERROR_FAILED;
    254   if (TrackedCallback::IsPending(write_callback_) ||
    255       state_.IsPending(TCPSocketState::SSL_CONNECT))
    256     return PP_ERROR_INPROGRESS;
    257 
    258   if (bytes_to_write > kMaxWriteSize)
    259     bytes_to_write = kMaxWriteSize;
    260 
    261   write_callback_ = callback;
    262 
    263   Call<PpapiPluginMsg_TCPSocket_WriteReply>(
    264       BROWSER,
    265       PpapiHostMsg_TCPSocket_Write(std::string(buffer, bytes_to_write)),
    266       base::Bind(&TCPSocketResourceBase::OnPluginMsgWriteReply,
    267                  base::Unretained(this)),
    268       callback);
    269   return PP_OK_COMPLETIONPENDING;
    270 }
    271 
    272 int32_t TCPSocketResourceBase::ListenImpl(
    273     int32_t backlog,
    274     scoped_refptr<TrackedCallback> callback) {
    275   if (backlog <= 0)
    276     return PP_ERROR_BADARGUMENT;
    277   if (state_.IsPending(TCPSocketState::LISTEN))
    278     return PP_ERROR_INPROGRESS;
    279   if (!state_.IsValidTransition(TCPSocketState::LISTEN))
    280     return PP_ERROR_FAILED;
    281 
    282   listen_callback_ = callback;
    283   state_.SetPendingTransition(TCPSocketState::LISTEN);
    284 
    285   Call<PpapiPluginMsg_TCPSocket_ListenReply>(
    286       BROWSER,
    287       PpapiHostMsg_TCPSocket_Listen(backlog),
    288       base::Bind(&TCPSocketResourceBase::OnPluginMsgListenReply,
    289                  base::Unretained(this)),
    290       callback);
    291   return PP_OK_COMPLETIONPENDING;
    292 }
    293 
    294 int32_t TCPSocketResourceBase::AcceptImpl(
    295     PP_Resource* accepted_tcp_socket,
    296     scoped_refptr<TrackedCallback> callback) {
    297   if (!accepted_tcp_socket)
    298     return PP_ERROR_BADARGUMENT;
    299   if (TrackedCallback::IsPending(accept_callback_))
    300     return PP_ERROR_INPROGRESS;
    301   if (state_.state() != TCPSocketState::LISTENING)
    302     return PP_ERROR_FAILED;
    303 
    304   accept_callback_ = callback;
    305   accepted_tcp_socket_ = accepted_tcp_socket;
    306 
    307   Call<PpapiPluginMsg_TCPSocket_AcceptReply>(
    308       BROWSER,
    309       PpapiHostMsg_TCPSocket_Accept(),
    310       base::Bind(&TCPSocketResourceBase::OnPluginMsgAcceptReply,
    311                  base::Unretained(this)),
    312       callback);
    313   return PP_OK_COMPLETIONPENDING;
    314 }
    315 
    316 void TCPSocketResourceBase::CloseImpl() {
    317   if (state_.state() == TCPSocketState::CLOSED)
    318     return;
    319 
    320   state_.DoTransition(TCPSocketState::CLOSE, true);
    321 
    322   Post(BROWSER, PpapiHostMsg_TCPSocket_Close());
    323 
    324   PostAbortIfNecessary(&bind_callback_);
    325   PostAbortIfNecessary(&connect_callback_);
    326   PostAbortIfNecessary(&ssl_handshake_callback_);
    327   PostAbortIfNecessary(&read_callback_);
    328   PostAbortIfNecessary(&write_callback_);
    329   PostAbortIfNecessary(&listen_callback_);
    330   PostAbortIfNecessary(&accept_callback_);
    331   read_buffer_ = NULL;
    332   bytes_to_read_ = -1;
    333   server_certificate_ = NULL;
    334   accepted_tcp_socket_ = NULL;
    335 }
    336 
    337 int32_t TCPSocketResourceBase::SetOptionImpl(
    338     PP_TCPSocket_Option name,
    339     const PP_Var& value,
    340     scoped_refptr<TrackedCallback> callback) {
    341   SocketOptionData option_data;
    342   switch (name) {
    343     case PP_TCPSOCKET_OPTION_NO_DELAY: {
    344       if (!state_.IsConnected())
    345         return PP_ERROR_FAILED;
    346 
    347       if (value.type != PP_VARTYPE_BOOL)
    348         return PP_ERROR_BADARGUMENT;
    349       option_data.SetBool(PP_ToBool(value.value.as_bool));
    350       break;
    351     }
    352     case PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE:
    353     case PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE: {
    354       if (!state_.IsConnected())
    355         return PP_ERROR_FAILED;
    356 
    357       if (value.type != PP_VARTYPE_INT32)
    358         return PP_ERROR_BADARGUMENT;
    359       option_data.SetInt32(value.value.as_int);
    360       break;
    361     }
    362     default: {
    363       NOTREACHED();
    364       return PP_ERROR_BADARGUMENT;
    365     }
    366   }
    367 
    368   set_option_callbacks_.push(callback);
    369 
    370   Call<PpapiPluginMsg_TCPSocket_SetOptionReply>(
    371       BROWSER,
    372       PpapiHostMsg_TCPSocket_SetOption(name, option_data),
    373       base::Bind(&TCPSocketResourceBase::OnPluginMsgSetOptionReply,
    374                  base::Unretained(this)),
    375       callback);
    376   return PP_OK_COMPLETIONPENDING;
    377 }
    378 
    379 void TCPSocketResourceBase::PostAbortIfNecessary(
    380     scoped_refptr<TrackedCallback>* callback) {
    381   if (TrackedCallback::IsPending(*callback))
    382     (*callback)->PostAbort();
    383 }
    384 
    385 void TCPSocketResourceBase::OnPluginMsgBindReply(
    386     const ResourceMessageReplyParams& params,
    387     const PP_NetAddress_Private& local_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::BIND))
    391     return;
    392 
    393   DCHECK(TrackedCallback::IsPending(bind_callback_));
    394   if (params.result() == PP_OK) {
    395     local_addr_ = local_addr;
    396     state_.CompletePendingTransition(true);
    397   } else {
    398     state_.CompletePendingTransition(false);
    399   }
    400   RunCallback(bind_callback_, params.result());
    401 }
    402 
    403 void TCPSocketResourceBase::OnPluginMsgConnectReply(
    404     const ResourceMessageReplyParams& params,
    405     const PP_NetAddress_Private& local_addr,
    406     const PP_NetAddress_Private& remote_addr) {
    407   // It is possible that CloseImpl() has been called. We don't want to update
    408   // class members in this case.
    409   if (!state_.IsPending(TCPSocketState::CONNECT))
    410     return;
    411 
    412   DCHECK(TrackedCallback::IsPending(connect_callback_));
    413   if (params.result() == PP_OK) {
    414     local_addr_ = local_addr;
    415     remote_addr_ = remote_addr;
    416     state_.CompletePendingTransition(true);
    417   } else {
    418     if (version_ == TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
    419       state_.CompletePendingTransition(false);
    420     } else {
    421       // In order to maintain backward compatibility, allow to connect the
    422       // socket again.
    423       state_ = TCPSocketState(TCPSocketState::INITIAL);
    424     }
    425   }
    426   RunCallback(connect_callback_, params.result());
    427 }
    428 
    429 void TCPSocketResourceBase::OnPluginMsgSSLHandshakeReply(
    430       const ResourceMessageReplyParams& params,
    431       const PPB_X509Certificate_Fields& certificate_fields) {
    432   // It is possible that CloseImpl() has been called. We don't want to
    433   // update class members in this case.
    434   if (!state_.IsPending(TCPSocketState::SSL_CONNECT))
    435     return;
    436 
    437   DCHECK(TrackedCallback::IsPending(ssl_handshake_callback_));
    438   if (params.result() == PP_OK) {
    439     state_.CompletePendingTransition(true);
    440     server_certificate_ = new PPB_X509Certificate_Private_Shared(
    441         OBJECT_IS_PROXY,
    442         pp_instance(),
    443         certificate_fields);
    444   } else {
    445     state_.CompletePendingTransition(false);
    446   }
    447   RunCallback(ssl_handshake_callback_, params.result());
    448 }
    449 
    450 void TCPSocketResourceBase::OnPluginMsgReadReply(
    451     const ResourceMessageReplyParams& params,
    452     const std::string& data) {
    453   // It is possible that CloseImpl() has been called. We shouldn't access the
    454   // buffer in that case. The user may have released it.
    455   if (!state_.IsConnected() || !TrackedCallback::IsPending(read_callback_) ||
    456       !read_buffer_) {
    457     return;
    458   }
    459 
    460   const bool succeeded = params.result() == PP_OK;
    461   if (succeeded) {
    462     CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
    463     if (!data.empty())
    464       memmove(read_buffer_, data.c_str(), data.size());
    465   }
    466   read_buffer_ = NULL;
    467   bytes_to_read_ = -1;
    468 
    469   RunCallback(read_callback_,
    470               succeeded ? static_cast<int32_t>(data.size()) : params.result());
    471 }
    472 
    473 void TCPSocketResourceBase::OnPluginMsgWriteReply(
    474     const ResourceMessageReplyParams& params) {
    475   if (!state_.IsConnected() || !TrackedCallback::IsPending(write_callback_))
    476     return;
    477   RunCallback(write_callback_, params.result());
    478 }
    479 
    480 void TCPSocketResourceBase::OnPluginMsgListenReply(
    481     const ResourceMessageReplyParams& params) {
    482   if (!state_.IsPending(TCPSocketState::LISTEN))
    483     return;
    484 
    485   DCHECK(TrackedCallback::IsPending(listen_callback_));
    486   state_.CompletePendingTransition(params.result() == PP_OK);
    487 
    488   RunCallback(listen_callback_, params.result());
    489 }
    490 
    491 void TCPSocketResourceBase::OnPluginMsgAcceptReply(
    492     const ResourceMessageReplyParams& params,
    493     int pending_host_id,
    494     const PP_NetAddress_Private& local_addr,
    495     const PP_NetAddress_Private& remote_addr) {
    496   // It is possible that CloseImpl() has been called. We shouldn't access the
    497   // output parameter in that case. The user may have released it.
    498   if (state_.state() != TCPSocketState::LISTENING ||
    499       !TrackedCallback::IsPending(accept_callback_) || !accepted_tcp_socket_) {
    500     return;
    501   }
    502 
    503   if (params.result() == PP_OK) {
    504     *accepted_tcp_socket_ = CreateAcceptedSocket(pending_host_id, local_addr,
    505                                                  remote_addr);
    506   }
    507   accepted_tcp_socket_ = NULL;
    508   RunCallback(accept_callback_, params.result());
    509 }
    510 
    511 void TCPSocketResourceBase::OnPluginMsgSetOptionReply(
    512     const ResourceMessageReplyParams& params) {
    513   if (set_option_callbacks_.empty()) {
    514     NOTREACHED();
    515     return;
    516   }
    517   scoped_refptr<TrackedCallback> callback = set_option_callbacks_.front();
    518   set_option_callbacks_.pop();
    519   if (TrackedCallback::IsPending(callback))
    520     RunCallback(callback, params.result());
    521 }
    522 
    523 void TCPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
    524                                         int32_t pp_result) {
    525   callback->Run(ConvertNetworkAPIErrorForCompatibility(
    526       pp_result, version_ == TCP_SOCKET_VERSION_PRIVATE));
    527 }
    528 
    529 }  // namespace ppapi
    530 }  // namespace proxy
    531