ppapi/proxy/udp_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/udp_socket_resource_base.h"
   6
   7 #include <algorithm>
   8 #include <cstring>
   9
  10 #include "base/logging.h"
  11 #include "ppapi/c/pp_bool.h"
  12 #include "ppapi/c/pp_completion_callback.h"
  13 #include "ppapi/c/pp_errors.h"
  14 #include "ppapi/proxy/error_conversion.h"
  15 #include "ppapi/proxy/ppapi_messages.h"
  16 #include "ppapi/shared_impl/socket_option_data.h"
  17 #include "ppapi/thunk/enter.h"
  18 #include "ppapi/thunk/resource_creation_api.h"
  19
  20 namespace ppapi {
  21 namespace proxy {
  22
  23 const int32_t UDPSocketResourceBase::kMaxReadSize = 1024 * 1024;
  24 const int32_t UDPSocketResourceBase::kMaxWriteSize = 1024 * 1024;
  25 const int32_t UDPSocketResourceBase::kMaxSendBufferSize =
  26     1024 * UDPSocketResourceBase::kMaxWriteSize;
  27 const int32_t UDPSocketResourceBase::kMaxReceiveBufferSize =
  28     1024 * UDPSocketResourceBase::kMaxReadSize;
  29
  30
  31 UDPSocketResourceBase::UDPSocketResourceBase(Connection connection,
  32                                              PP_Instance instance,
  33                                              bool private_api)
  34     : PluginResource(connection, instance),
  35       private_api_(private_api),
  36       bound_(false),
  37       closed_(false),
  38       read_buffer_(NULL),
  39       bytes_to_read_(-1) {
  40   recvfrom_addr_.size = 0;
  41   memset(recvfrom_addr_.data, 0,
  42          arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data));
  43   bound_addr_.size = 0;
  44   memset(bound_addr_.data, 0,
  45          arraysize(bound_addr_.data) * sizeof(*bound_addr_.data));
  46
  47   if (private_api)
  48     SendCreate(BROWSER, PpapiHostMsg_UDPSocket_CreatePrivate());
  49   else
  50     SendCreate(BROWSER, PpapiHostMsg_UDPSocket_Create());
  51 }
  52
  53 UDPSocketResourceBase::~UDPSocketResourceBase() {
  54 }
  55
  56 int32_t UDPSocketResourceBase::SetOptionImpl(
  57     PP_UDPSocket_Option name,
  58     const PP_Var& value,
  59     scoped_refptr<TrackedCallback> callback) {
  60   if (closed_)
  61     return PP_ERROR_FAILED;
  62
  63   SocketOptionData option_data;
  64   switch (name) {
  65     case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
  66     case PP_UDPSOCKET_OPTION_BROADCAST: {
  67       if (bound_)
  68         return PP_ERROR_FAILED;
  69       if (value.type != PP_VARTYPE_BOOL)
  70         return PP_ERROR_BADARGUMENT;
  71       option_data.SetBool(PP_ToBool(value.value.as_bool));
  72       break;
  73     }
  74     case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
  75     case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
  76       if (!bound_)
  77         return PP_ERROR_FAILED;
  78       if (value.type != PP_VARTYPE_INT32)
  79         return PP_ERROR_BADARGUMENT;
  80       option_data.SetInt32(value.value.as_int);
  81       break;
  82     }
  83     default: {
  84       NOTREACHED();
  85       return PP_ERROR_BADARGUMENT;
  86     }
  87   }
  88
  89   Call<PpapiPluginMsg_UDPSocket_SetOptionReply>(
  90       BROWSER,
  91       PpapiHostMsg_UDPSocket_SetOption(name, option_data),
  92       base::Bind(&UDPSocketResourceBase::OnPluginMsgSetOptionReply,
  93                  base::Unretained(this),
  94                  callback),
  95       callback);
  96   return PP_OK_COMPLETIONPENDING;
  97 }
  98
  99 int32_t UDPSocketResourceBase::BindImpl(
 100     const PP_NetAddress_Private* addr,
 101     scoped_refptr<TrackedCallback> callback) {
 102   if (!addr)
 103     return PP_ERROR_BADARGUMENT;
 104   if (bound_ || closed_)
 105     return PP_ERROR_FAILED;
 106   if (TrackedCallback::IsPending(bind_callback_))
 107     return PP_ERROR_INPROGRESS;
 108
 109   bind_callback_ = callback;
 110
 111   // Send the request, the browser will call us back via BindReply.
 112   Call<PpapiPluginMsg_UDPSocket_BindReply>(
 113       BROWSER,
 114       PpapiHostMsg_UDPSocket_Bind(*addr),
 115       base::Bind(&UDPSocketResourceBase::OnPluginMsgBindReply,
 116                  base::Unretained(this)),
 117       callback);
 118   return PP_OK_COMPLETIONPENDING;
 119 }
 120
 121 PP_Bool UDPSocketResourceBase::GetBoundAddressImpl(
 122     PP_NetAddress_Private* addr) {
 123   if (!addr || !bound_ || closed_)
 124     return PP_FALSE;
 125
 126   *addr = bound_addr_;
 127   return PP_TRUE;
 128 }
 129
 130 int32_t UDPSocketResourceBase::RecvFromImpl(
 131     char* buffer,
 132     int32_t num_bytes,
 133     PP_Resource* addr,
 134     scoped_refptr<TrackedCallback> callback) {
 135   if (!buffer || num_bytes <= 0)
 136     return PP_ERROR_BADARGUMENT;
 137   if (!bound_)
 138     return PP_ERROR_FAILED;
 139   if (TrackedCallback::IsPending(recvfrom_callback_))
 140     return PP_ERROR_INPROGRESS;
 141
 142   read_buffer_ = buffer;
 143   bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
 144   recvfrom_callback_ = callback;
 145
 146   // Send the request, the browser will call us back via RecvFromReply.
 147   Call<PpapiPluginMsg_UDPSocket_RecvFromReply>(
 148       BROWSER,
 149       PpapiHostMsg_UDPSocket_RecvFrom(bytes_to_read_),
 150       base::Bind(&UDPSocketResourceBase::OnPluginMsgRecvFromReply,
 151                  base::Unretained(this), addr),
 152       callback);
 153   return PP_OK_COMPLETIONPENDING;
 154 }
 155
 156 PP_Bool UDPSocketResourceBase::GetRecvFromAddressImpl(
 157     PP_NetAddress_Private* addr) {
 158   if (!addr)
 159     return PP_FALSE;
 160   *addr = recvfrom_addr_;
 161   return PP_TRUE;
 162 }
 163
 164 int32_t UDPSocketResourceBase::SendToImpl(
 165     const char* buffer,
 166     int32_t num_bytes,
 167     const PP_NetAddress_Private* addr,
 168     scoped_refptr<TrackedCallback> callback) {
 169   if (!buffer || num_bytes <= 0 || !addr)
 170     return PP_ERROR_BADARGUMENT;
 171   if (!bound_)
 172     return PP_ERROR_FAILED;
 173   if (TrackedCallback::IsPending(sendto_callback_))
 174     return PP_ERROR_INPROGRESS;
 175
 176   if (num_bytes > kMaxWriteSize)
 177     num_bytes = kMaxWriteSize;
 178
 179   sendto_callback_ = callback;
 180
 181   // Send the request, the browser will call us back via SendToReply.
 182   Call<PpapiPluginMsg_UDPSocket_SendToReply>(
 183       BROWSER,
 184       PpapiHostMsg_UDPSocket_SendTo(std::string(buffer, num_bytes), *addr),
 185       base::Bind(&UDPSocketResourceBase::OnPluginMsgSendToReply,
 186                  base::Unretained(this)),
 187       callback);
 188   return PP_OK_COMPLETIONPENDING;
 189 }
 190
 191 void UDPSocketResourceBase::CloseImpl() {
 192   if(closed_)
 193     return;
 194
 195   bound_ = false;
 196   closed_ = true;
 197
 198   Post(BROWSER, PpapiHostMsg_UDPSocket_Close());
 199
 200   PostAbortIfNecessary(&bind_callback_);
 201   PostAbortIfNecessary(&recvfrom_callback_);
 202   PostAbortIfNecessary(&sendto_callback_);
 203
 204   read_buffer_ = NULL;
 205   bytes_to_read_ = -1;
 206 }
 207
 208 void UDPSocketResourceBase::PostAbortIfNecessary(
 209     scoped_refptr<TrackedCallback>* callback) {
 210   if (TrackedCallback::IsPending(*callback))
 211     (*callback)->PostAbort();
 212 }
 213
 214 void UDPSocketResourceBase::OnPluginMsgSetOptionReply(
 215     scoped_refptr<TrackedCallback> callback,
 216     const ResourceMessageReplyParams& params) {
 217   if (TrackedCallback::IsPending(callback))
 218     RunCallback(callback, params.result());
 219 }
 220
 221 void UDPSocketResourceBase::OnPluginMsgBindReply(
 222     const ResourceMessageReplyParams& params,
 223     const PP_NetAddress_Private& bound_addr) {
 224   // It is possible that |bind_callback_| is pending while |closed_| is true:
 225   // CloseImpl() has been called, but a BindReply came earlier than the task to
 226   // abort |bind_callback_|. We don't want to update |bound_| or |bound_addr_|
 227   // in that case.
 228   if (!TrackedCallback::IsPending(bind_callback_) || closed_)
 229     return;
 230
 231   if (params.result() == PP_OK)
 232     bound_ = true;
 233   bound_addr_ = bound_addr;
 234   RunCallback(bind_callback_, params.result());
 235 }
 236
 237 void UDPSocketResourceBase::OnPluginMsgRecvFromReply(
 238     PP_Resource* output_addr,
 239     const ResourceMessageReplyParams& params,
 240     const std::string& data,
 241     const PP_NetAddress_Private& addr) {
 242   // It is possible that |recvfrom_callback_| is pending while |read_buffer_| is
 243   // NULL: CloseImpl() has been called, but a RecvFromReply came earlier than
 244   // the task to abort |recvfrom_callback_|. We shouldn't access the buffer in
 245   // that case. The user may have released it.
 246   if (!TrackedCallback::IsPending(recvfrom_callback_) || !read_buffer_)
 247     return;
 248
 249   int32_t result = params.result();
 250   if (result == PP_OK && output_addr) {
 251     thunk::EnterResourceCreationNoLock enter(pp_instance());
 252     if (enter.succeeded()) {
 253       *output_addr = enter.functions()->CreateNetAddressFromNetAddressPrivate(
 254           pp_instance(), addr);
 255     } else {
 256       result = PP_ERROR_FAILED;
 257     }
 258   }
 259
 260   if (result == PP_OK) {
 261     CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
 262     if (!data.empty())
 263       memcpy(read_buffer_, data.c_str(), data.size());
 264   }
 265
 266   read_buffer_ = NULL;
 267   bytes_to_read_ = -1;
 268   recvfrom_addr_ = addr;
 269
 270   if (result == PP_OK)
 271     RunCallback(recvfrom_callback_, static_cast<int32_t>(data.size()));
 272   else
 273     RunCallback(recvfrom_callback_, result);
 274 }
 275
 276 void UDPSocketResourceBase::OnPluginMsgSendToReply(
 277     const ResourceMessageReplyParams& params,
 278     int32_t bytes_written) {
 279   if (!TrackedCallback::IsPending(sendto_callback_))
 280     return;
 281
 282   if (params.result() == PP_OK)
 283     RunCallback(sendto_callback_, bytes_written);
 284   else
 285     RunCallback(sendto_callback_, params.result());
 286 }
 287
 288 void UDPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
 289                                         int32_t pp_result) {
 290   callback->Run(ConvertNetworkAPIErrorForCompatibility(pp_result,
 291                                                        private_api_));
 292 }
 293
 294 }  // namespace proxy
 295 }  // namespace ppapi