udp_socket_resource_base.cc revision d57369da7c6519fef57db42085f7b42d4c8845c1
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 20namespace ppapi { 21namespace proxy { 22 23const int32_t UDPSocketResourceBase::kMaxReadSize = 1024 * 1024; 24const int32_t UDPSocketResourceBase::kMaxWriteSize = 1024 * 1024; 25const int32_t UDPSocketResourceBase::kMaxSendBufferSize = 26 1024 * UDPSocketResourceBase::kMaxWriteSize; 27const int32_t UDPSocketResourceBase::kMaxReceiveBufferSize = 28 1024 * UDPSocketResourceBase::kMaxReadSize; 29 30 31UDPSocketResourceBase::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 53UDPSocketResourceBase::~UDPSocketResourceBase() { 54} 55 56int32_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 99int32_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 121PP_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 130int32_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 156PP_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 164int32_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 191void 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 208void UDPSocketResourceBase::PostAbortIfNecessary( 209 scoped_refptr<TrackedCallback>* callback) { 210 if (TrackedCallback::IsPending(*callback)) 211 (*callback)->PostAbort(); 212} 213 214void UDPSocketResourceBase::OnPluginMsgSetOptionReply( 215 scoped_refptr<TrackedCallback> callback, 216 const ResourceMessageReplyParams& params) { 217 if (TrackedCallback::IsPending(callback)) 218 RunCallback(callback, params.result()); 219} 220 221void 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 237void 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 276void 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 288void 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 296