remoting/protocol/chromium_socket_factory.cc

   1 // Copyright 2014 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 "remoting/protocol/chromium_socket_factory.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "jingle/glue/utils.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/ip_endpoint.h"
  13 #include "net/base/net_errors.h"
  14 #include "net/udp/udp_server_socket.h"
  15 #include "remoting/protocol/socket_util.h"
  16 #include "third_party/webrtc/base/asyncpacketsocket.h"
  17 #include "third_party/webrtc/base/nethelpers.h"
  18
  19 namespace remoting {
  20 namespace protocol {
  21
  22 namespace {
  23
  24 // Size of the buffer to allocate for RecvFrom().
  25 const int kReceiveBufferSize = 65536;
  26
  27 // Maximum amount of data in the send buffers. This is necessary to
  28 // prevent out-of-memory crashes if the caller sends data faster than
  29 // Pepper's UDP API can handle it. This maximum should never be
  30 // reached under normal conditions.
  31 const int kMaxSendBufferSize = 256 * 1024;
  32
  33 class UdpPacketSocket : public rtc::AsyncPacketSocket {
  34  public:
  35   UdpPacketSocket();
  36   virtual ~UdpPacketSocket();
  37
  38   bool Init(const rtc::SocketAddress& local_address,
  39             int min_port, int max_port);
  40
  41   // rtc::AsyncPacketSocket interface.
  42   virtual rtc::SocketAddress GetLocalAddress() const OVERRIDE;
  43   virtual rtc::SocketAddress GetRemoteAddress() const OVERRIDE;
  44   virtual int Send(const void* data, size_t data_size,
  45                    const rtc::PacketOptions& options) OVERRIDE;
  46   virtual int SendTo(const void* data, size_t data_size,
  47                      const rtc::SocketAddress& address,
  48                      const rtc::PacketOptions& options) OVERRIDE;
  49   virtual int Close() OVERRIDE;
  50   virtual State GetState() const OVERRIDE;
  51   virtual int GetOption(rtc::Socket::Option option, int* value) OVERRIDE;
  52   virtual int SetOption(rtc::Socket::Option option, int value) OVERRIDE;
  53   virtual int GetError() const OVERRIDE;
  54   virtual void SetError(int error) OVERRIDE;
  55
  56  private:
  57   struct PendingPacket {
  58     PendingPacket(const void* buffer,
  59                   int buffer_size,
  60                   const net::IPEndPoint& address);
  61
  62     scoped_refptr<net::IOBufferWithSize> data;
  63     net::IPEndPoint address;
  64     bool retried;
  65   };
  66
  67   void OnBindCompleted(int error);
  68
  69   void DoSend();
  70   void OnSendCompleted(int result);
  71
  72   void DoRead();
  73   void OnReadCompleted(int result);
  74   void HandleReadResult(int result);
  75
  76   scoped_ptr<net::UDPServerSocket> socket_;
  77
  78   State state_;
  79   int error_;
  80
  81   rtc::SocketAddress local_address_;
  82
  83   // Receive buffer and address are populated by asynchronous reads.
  84   scoped_refptr<net::IOBuffer> receive_buffer_;
  85   net::IPEndPoint receive_address_;
  86
  87   bool send_pending_;
  88   std::list<PendingPacket> send_queue_;
  89   int send_queue_size_;
  90
  91   DISALLOW_COPY_AND_ASSIGN(UdpPacketSocket);
  92 };
  93
  94 UdpPacketSocket::PendingPacket::PendingPacket(
  95     const void* buffer,
  96     int buffer_size,
  97     const net::IPEndPoint& address)
  98     : data(new net::IOBufferWithSize(buffer_size)),
  99       address(address),
 100       retried(false) {
 101   memcpy(data->data(), buffer, buffer_size);
 102 }
 103
 104 UdpPacketSocket::UdpPacketSocket()
 105     : state_(STATE_CLOSED),
 106       error_(0),
 107       send_pending_(false),
 108       send_queue_size_(0) {
 109 }
 110
 111 UdpPacketSocket::~UdpPacketSocket() {
 112   Close();
 113 }
 114
 115 bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
 116                            int min_port, int max_port) {
 117   net::IPEndPoint local_endpoint;
 118   if (!jingle_glue::SocketAddressToIPEndPoint(
 119           local_address, &local_endpoint)) {
 120     return false;
 121   }
 122
 123   for (int port = min_port; port <= max_port; ++port) {
 124     socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
 125     int result = socket_->Listen(
 126         net::IPEndPoint(local_endpoint.address(), port));
 127     if (result == net::OK) {
 128       break;
 129     } else {
 130       socket_.reset();
 131     }
 132   }
 133
 134   if (!socket_.get()) {
 135     // Failed to bind the socket.
 136     return false;
 137   }
 138
 139   if (socket_->GetLocalAddress(&local_endpoint) != net::OK ||
 140       !jingle_glue::IPEndPointToSocketAddress(local_endpoint,
 141                                               &local_address_)) {
 142     return false;
 143   }
 144
 145   state_ = STATE_BOUND;
 146   DoRead();
 147
 148   return true;
 149 }
 150
 151 rtc::SocketAddress UdpPacketSocket::GetLocalAddress() const {
 152   DCHECK_EQ(state_, STATE_BOUND);
 153   return local_address_;
 154 }
 155
 156 rtc::SocketAddress UdpPacketSocket::GetRemoteAddress() const {
 157   // UDP sockets are not connected - this method should never be called.
 158   NOTREACHED();
 159   return rtc::SocketAddress();
 160 }
 161
 162 int UdpPacketSocket::Send(const void* data, size_t data_size,
 163                           const rtc::PacketOptions& options) {
 164   // UDP sockets are not connected - this method should never be called.
 165   NOTREACHED();
 166   return EWOULDBLOCK;
 167 }
 168
 169 int UdpPacketSocket::SendTo(const void* data, size_t data_size,
 170                             const rtc::SocketAddress& address,
 171                             const rtc::PacketOptions& options) {
 172   if (state_ != STATE_BOUND) {
 173     NOTREACHED();
 174     return EINVAL;
 175   }
 176
 177   if (error_ != 0) {
 178     return error_;
 179   }
 180
 181   net::IPEndPoint endpoint;
 182   if (!jingle_glue::SocketAddressToIPEndPoint(address, &endpoint)) {
 183     return EINVAL;
 184   }
 185
 186   if (send_queue_size_ >= kMaxSendBufferSize) {
 187     return EWOULDBLOCK;
 188   }
 189
 190   send_queue_.push_back(PendingPacket(data, data_size, endpoint));
 191   send_queue_size_ += data_size;
 192
 193   DoSend();
 194   return data_size;
 195 }
 196
 197 int UdpPacketSocket::Close() {
 198   state_ = STATE_CLOSED;
 199   socket_.reset();
 200   return 0;
 201 }
 202
 203 rtc::AsyncPacketSocket::State UdpPacketSocket::GetState() const {
 204   return state_;
 205 }
 206
 207 int UdpPacketSocket::GetOption(rtc::Socket::Option option, int* value) {
 208   // This method is never called by libjingle.
 209   NOTIMPLEMENTED();
 210   return -1;
 211 }
 212
 213 int UdpPacketSocket::SetOption(rtc::Socket::Option option, int value) {
 214   if (state_ != STATE_BOUND) {
 215     NOTREACHED();
 216     return EINVAL;
 217   }
 218
 219   switch (option) {
 220     case rtc::Socket::OPT_DONTFRAGMENT:
 221       NOTIMPLEMENTED();
 222       return -1;
 223
 224     case rtc::Socket::OPT_RCVBUF: {
 225       int net_error = socket_->SetReceiveBufferSize(value);
 226       return (net_error == net::OK) ? 0 : -1;
 227     }
 228
 229     case rtc::Socket::OPT_SNDBUF: {
 230       int net_error = socket_->SetSendBufferSize(value);
 231       return (net_error == net::OK) ? 0 : -1;
 232     }
 233
 234     case rtc::Socket::OPT_NODELAY:
 235       // OPT_NODELAY is only for TCP sockets.
 236       NOTREACHED();
 237       return -1;
 238
 239     case rtc::Socket::OPT_IPV6_V6ONLY:
 240       NOTIMPLEMENTED();
 241       return -1;
 242
 243     case rtc::Socket::OPT_DSCP:
 244       NOTIMPLEMENTED();
 245       return -1;
 246
 247     case rtc::Socket::OPT_RTP_SENDTIME_EXTN_ID:
 248       NOTIMPLEMENTED();
 249       return -1;
 250   }
 251
 252   NOTREACHED();
 253   return -1;
 254 }
 255
 256 int UdpPacketSocket::GetError() const {
 257   return error_;
 258 }
 259
 260 void UdpPacketSocket::SetError(int error) {
 261   error_ = error;
 262 }
 263
 264 void UdpPacketSocket::DoSend() {
 265   if (send_pending_ || send_queue_.empty())
 266     return;
 267
 268   PendingPacket& packet = send_queue_.front();
 269   int result = socket_->SendTo(
 270       packet.data.get(),
 271       packet.data->size(),
 272       packet.address,
 273       base::Bind(&UdpPacketSocket::OnSendCompleted, base::Unretained(this)));
 274   if (result == net::ERR_IO_PENDING) {
 275     send_pending_ = true;
 276   } else {
 277     OnSendCompleted(result);
 278   }
 279 }
 280
 281 void UdpPacketSocket::OnSendCompleted(int result) {
 282   send_pending_ = false;
 283
 284   if (result < 0) {
 285     SocketErrorAction action = GetSocketErrorAction(result);
 286     switch (action) {
 287       case SOCKET_ERROR_ACTION_FAIL:
 288         LOG(ERROR) << "Send failed on a UDP socket: " << result;
 289         error_ = EINVAL;
 290         return;
 291
 292       case SOCKET_ERROR_ACTION_RETRY:
 293         // Retry resending only once.
 294         if (!send_queue_.front().retried) {
 295           send_queue_.front().retried = true;
 296           DoSend();
 297           return;
 298         }
 299         break;
 300
 301       case SOCKET_ERROR_ACTION_IGNORE:
 302         break;
 303     }
 304   }
 305
 306   // Don't need to worry about partial sends because this is a datagram
 307   // socket.
 308   send_queue_size_ -= send_queue_.front().data->size();
 309   send_queue_.pop_front();
 310   DoSend();
 311 }
 312
 313 void UdpPacketSocket::DoRead() {
 314   int result = 0;
 315   while (result >= 0) {
 316     receive_buffer_ = new net::IOBuffer(kReceiveBufferSize);
 317     result = socket_->RecvFrom(
 318         receive_buffer_.get(),
 319         kReceiveBufferSize,
 320         &receive_address_,
 321         base::Bind(&UdpPacketSocket::OnReadCompleted, base::Unretained(this)));
 322     HandleReadResult(result);
 323   }
 324 }
 325
 326 void UdpPacketSocket::OnReadCompleted(int result) {
 327   HandleReadResult(result);
 328   if (result >= 0) {
 329     DoRead();
 330   }
 331 }
 332
 333 void UdpPacketSocket::HandleReadResult(int result) {
 334   if (result == net::ERR_IO_PENDING) {
 335     return;
 336   }
 337
 338   if (result > 0) {
 339     rtc::SocketAddress address;
 340     if (!jingle_glue::IPEndPointToSocketAddress(receive_address_, &address)) {
 341       NOTREACHED();
 342       LOG(ERROR) << "Failed to convert address received from RecvFrom().";
 343       return;
 344     }
 345     SignalReadPacket(this, receive_buffer_->data(), result, address,
 346                      rtc::CreatePacketTime(0));
 347   } else {
 348     LOG(ERROR) << "Received error when reading from UDP socket: " << result;
 349   }
 350 }
 351
 352 }  // namespace
 353
 354 ChromiumPacketSocketFactory::ChromiumPacketSocketFactory() {
 355 }
 356
 357 ChromiumPacketSocketFactory::~ChromiumPacketSocketFactory() {
 358 }
 359
 360 rtc::AsyncPacketSocket* ChromiumPacketSocketFactory::CreateUdpSocket(
 361       const rtc::SocketAddress& local_address,
 362       int min_port, int max_port) {
 363   scoped_ptr<UdpPacketSocket> result(new UdpPacketSocket());
 364   if (!result->Init(local_address, min_port, max_port))
 365     return NULL;
 366   return result.release();
 367 }
 368
 369 rtc::AsyncPacketSocket*
 370 ChromiumPacketSocketFactory::CreateServerTcpSocket(
 371     const rtc::SocketAddress& local_address,
 372     int min_port, int max_port,
 373     int opts) {
 374   // We don't use TCP sockets for remoting connections.
 375   NOTIMPLEMENTED();
 376   return NULL;
 377 }
 378
 379 rtc::AsyncPacketSocket*
 380 ChromiumPacketSocketFactory::CreateClientTcpSocket(
 381       const rtc::SocketAddress& local_address,
 382       const rtc::SocketAddress& remote_address,
 383       const rtc::ProxyInfo& proxy_info,
 384       const std::string& user_agent,
 385       int opts) {
 386   // We don't use TCP sockets for remoting connections.
 387   NOTREACHED();
 388   return NULL;
 389 }
 390
 391 rtc::AsyncResolverInterface*
 392 ChromiumPacketSocketFactory::CreateAsyncResolver() {
 393   return new rtc::AsyncResolver();
 394 }
 395
 396 }  // namespace protocol
 397 }  // namespace remoting