• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
PendingPacket(const void * buffer,int buffer_size,const net::IPEndPoint & address)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 
UdpPacketSocket()104 UdpPacketSocket::UdpPacketSocket()
105     : state_(STATE_CLOSED),
106       error_(0),
107       send_pending_(false),
108       send_queue_size_(0) {
109 }
110 
~UdpPacketSocket()111 UdpPacketSocket::~UdpPacketSocket() {
112   Close();
113 }
114 
Init(const rtc::SocketAddress & local_address,int min_port,int max_port)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 
GetLocalAddress() const151 rtc::SocketAddress UdpPacketSocket::GetLocalAddress() const {
152   DCHECK_EQ(state_, STATE_BOUND);
153   return local_address_;
154 }
155 
GetRemoteAddress() const156 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 
Send(const void * data,size_t data_size,const rtc::PacketOptions & options)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 
SendTo(const void * data,size_t data_size,const rtc::SocketAddress & address,const rtc::PacketOptions & options)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 
Close()197 int UdpPacketSocket::Close() {
198   state_ = STATE_CLOSED;
199   socket_.reset();
200   return 0;
201 }
202 
GetState() const203 rtc::AsyncPacketSocket::State UdpPacketSocket::GetState() const {
204   return state_;
205 }
206 
GetOption(rtc::Socket::Option option,int * value)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 
SetOption(rtc::Socket::Option option,int value)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 
GetError() const256 int UdpPacketSocket::GetError() const {
257   return error_;
258 }
259 
SetError(int error)260 void UdpPacketSocket::SetError(int error) {
261   error_ = error;
262 }
263 
DoSend()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 
OnSendCompleted(int result)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 
DoRead()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 
OnReadCompleted(int result)326 void UdpPacketSocket::OnReadCompleted(int result) {
327   HandleReadResult(result);
328   if (result >= 0) {
329     DoRead();
330   }
331 }
332 
HandleReadResult(int result)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 
ChromiumPacketSocketFactory()354 ChromiumPacketSocketFactory::ChromiumPacketSocketFactory() {
355 }
356 
~ChromiumPacketSocketFactory()357 ChromiumPacketSocketFactory::~ChromiumPacketSocketFactory() {
358 }
359 
CreateUdpSocket(const rtc::SocketAddress & local_address,int min_port,int max_port)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*
CreateServerTcpSocket(const rtc::SocketAddress & local_address,int min_port,int max_port,int opts)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*
CreateClientTcpSocket(const rtc::SocketAddress & local_address,const rtc::SocketAddress & remote_address,const rtc::ProxyInfo & proxy_info,const std::string & user_agent,int opts)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*
CreateAsyncResolver()392 ChromiumPacketSocketFactory::CreateAsyncResolver() {
393   return new rtc::AsyncResolver();
394 }
395 
396 }  // namespace protocol
397 }  // namespace remoting
398