1// Copyright (c) 2012 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 "content/browser/renderer_host/p2p/socket_host_udp.h"
6
7#include <deque>
8#include <vector>
9
10#include "base/logging.h"
11#include "base/sys_byteorder.h"
12#include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
13#include "content/browser/renderer_host/p2p/socket_host_throttler.h"
14#include "net/base/io_buffer.h"
15#include "net/base/ip_endpoint.h"
16#include "net/base/net_errors.h"
17#include "net/udp/datagram_server_socket.h"
18#include "testing/gmock/include/gmock/gmock.h"
19#include "testing/gtest/include/gtest/gtest.h"
20#include "third_party/webrtc/base/timing.h"
21
22using ::testing::_;
23using ::testing::DeleteArg;
24using ::testing::DoAll;
25using ::testing::Return;
26
27namespace {
28
29class FakeTiming : public rtc::Timing {
30 public:
31  FakeTiming() : now_(0.0) {}
32  virtual double TimerNow() OVERRIDE { return now_; }
33  void set_now(double now) { now_ = now; }
34
35 private:
36  double now_;
37};
38
39class FakeDatagramServerSocket : public net::DatagramServerSocket {
40 public:
41  typedef std::pair<net::IPEndPoint, std::vector<char> > UDPPacket;
42
43  // P2PSocketHostUdp destroyes a socket on errors so sent packets
44  // need to be stored outside of this object.
45  explicit FakeDatagramServerSocket(std::deque<UDPPacket>* sent_packets)
46      : sent_packets_(sent_packets) {
47  }
48
49  virtual void Close() OVERRIDE {
50  }
51
52  virtual int GetPeerAddress(net::IPEndPoint* address) const OVERRIDE {
53    NOTREACHED();
54    return net::ERR_SOCKET_NOT_CONNECTED;
55  }
56
57  virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE {
58    *address = address_;
59    return 0;
60  }
61
62  virtual int Listen(const net::IPEndPoint& address) OVERRIDE {
63    address_ = address;
64    return 0;
65  }
66
67  virtual int RecvFrom(net::IOBuffer* buf, int buf_len,
68                       net::IPEndPoint* address,
69                       const net::CompletionCallback& callback) OVERRIDE {
70    CHECK(recv_callback_.is_null());
71    if (incoming_packets_.size() > 0) {
72      scoped_refptr<net::IOBuffer> buffer(buf);
73      int size = std::min(
74          static_cast<int>(incoming_packets_.front().second.size()), buf_len);
75      memcpy(buffer->data(), &*incoming_packets_.front().second.begin(), size);
76      *address = incoming_packets_.front().first;
77      incoming_packets_.pop_front();
78      return size;
79    } else {
80      recv_callback_ = callback;
81      recv_buffer_ = buf;
82      recv_size_ = buf_len;
83      recv_address_ = address;
84      return net::ERR_IO_PENDING;
85    }
86  }
87
88  virtual int SendTo(net::IOBuffer* buf, int buf_len,
89                     const net::IPEndPoint& address,
90                     const net::CompletionCallback& callback) OVERRIDE {
91    scoped_refptr<net::IOBuffer> buffer(buf);
92    std::vector<char> data_vector(buffer->data(), buffer->data() + buf_len);
93    sent_packets_->push_back(UDPPacket(address, data_vector));
94    return buf_len;
95  }
96
97  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
98    return net::OK;
99  }
100
101  virtual int SetSendBufferSize(int32 size) OVERRIDE {
102    return net::OK;
103  }
104
105  void ReceivePacket(const net::IPEndPoint& address, std::vector<char> data) {
106    if (!recv_callback_.is_null()) {
107      int size = std::min(recv_size_, static_cast<int>(data.size()));
108      memcpy(recv_buffer_->data(), &*data.begin(), size);
109      *recv_address_ = address;
110      net::CompletionCallback cb = recv_callback_;
111      recv_callback_.Reset();
112      recv_buffer_ = NULL;
113      cb.Run(size);
114    } else {
115      incoming_packets_.push_back(UDPPacket(address, data));
116    }
117  }
118
119  virtual const net::BoundNetLog& NetLog() const OVERRIDE {
120    return net_log_;
121  }
122
123  virtual void AllowAddressReuse() OVERRIDE {
124    NOTIMPLEMENTED();
125  }
126
127  virtual void AllowBroadcast() OVERRIDE {
128    NOTIMPLEMENTED();
129  }
130
131  virtual int JoinGroup(
132      const net::IPAddressNumber& group_address) const OVERRIDE {
133    NOTIMPLEMENTED();
134    return net::ERR_NOT_IMPLEMENTED;
135  }
136
137  virtual int LeaveGroup(
138      const net::IPAddressNumber& group_address) const OVERRIDE {
139    NOTIMPLEMENTED();
140    return net::ERR_NOT_IMPLEMENTED;
141  }
142
143  virtual int SetMulticastInterface(uint32 interface_index) OVERRIDE {
144    NOTIMPLEMENTED();
145    return net::ERR_NOT_IMPLEMENTED;
146  }
147
148  virtual int SetMulticastTimeToLive(int time_to_live) OVERRIDE {
149    NOTIMPLEMENTED();
150    return net::ERR_NOT_IMPLEMENTED;
151  }
152
153  virtual int SetMulticastLoopbackMode(bool loopback) OVERRIDE {
154    NOTIMPLEMENTED();
155    return net::ERR_NOT_IMPLEMENTED;
156  }
157
158  virtual int SetDiffServCodePoint(net::DiffServCodePoint dscp) OVERRIDE {
159    NOTIMPLEMENTED();
160    return net::ERR_NOT_IMPLEMENTED;
161  }
162
163  virtual void DetachFromThread() OVERRIDE {
164    NOTIMPLEMENTED();
165  }
166
167 private:
168  net::IPEndPoint address_;
169  std::deque<UDPPacket>* sent_packets_;
170  std::deque<UDPPacket> incoming_packets_;
171  net::BoundNetLog net_log_;
172
173  scoped_refptr<net::IOBuffer> recv_buffer_;
174  net::IPEndPoint* recv_address_;
175  int recv_size_;
176  net::CompletionCallback recv_callback_;
177};
178
179}  // namespace
180
181namespace content {
182
183class P2PSocketHostUdpTest : public testing::Test {
184 protected:
185  virtual void SetUp() OVERRIDE {
186    EXPECT_CALL(sender_, Send(
187        MatchMessage(static_cast<uint32>(P2PMsg_OnSocketCreated::ID))))
188        .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
189
190    socket_host_.reset(new P2PSocketHostUdp(&sender_, 0, &throttler_));
191    socket_ = new FakeDatagramServerSocket(&sent_packets_);
192    socket_host_->socket_.reset(socket_);
193
194    local_address_ = ParseAddress(kTestLocalIpAddress, kTestPort1);
195    socket_host_->Init(local_address_, P2PHostAndIPEndPoint());
196
197    dest1_ = ParseAddress(kTestIpAddress1, kTestPort1);
198    dest2_ = ParseAddress(kTestIpAddress2, kTestPort2);
199
200    scoped_ptr<rtc::Timing> timing(new FakeTiming());
201    throttler_.SetTiming(timing.Pass());
202  }
203
204  P2PMessageThrottler throttler_;
205  std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets_;
206  FakeDatagramServerSocket* socket_; // Owned by |socket_host_|.
207  scoped_ptr<P2PSocketHostUdp> socket_host_;
208  MockIPCSender sender_;
209
210  net::IPEndPoint local_address_;
211
212  net::IPEndPoint dest1_;
213  net::IPEndPoint dest2_;
214};
215
216// Verify that we can send STUN messages before we receive anything
217// from the other side.
218TEST_F(P2PSocketHostUdpTest, SendStunNoAuth) {
219  EXPECT_CALL(sender_, Send(
220      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
221      .Times(3)
222      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
223
224  rtc::PacketOptions options;
225  std::vector<char> packet1;
226  CreateStunRequest(&packet1);
227  socket_host_->Send(dest1_, packet1, options, 0);
228
229  std::vector<char> packet2;
230  CreateStunResponse(&packet2);
231  socket_host_->Send(dest1_, packet2, options, 0);
232
233  std::vector<char> packet3;
234  CreateStunError(&packet3);
235  socket_host_->Send(dest1_, packet3, options, 0);
236
237  ASSERT_EQ(sent_packets_.size(), 3U);
238  ASSERT_EQ(sent_packets_[0].second, packet1);
239  ASSERT_EQ(sent_packets_[1].second, packet2);
240  ASSERT_EQ(sent_packets_[2].second, packet3);
241}
242
243// Verify that no data packets can be sent before STUN binding has
244// finished.
245TEST_F(P2PSocketHostUdpTest, SendDataNoAuth) {
246  EXPECT_CALL(sender_, Send(
247      MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
248      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
249
250  rtc::PacketOptions options;
251  std::vector<char> packet;
252  CreateRandomPacket(&packet);
253  socket_host_->Send(dest1_, packet, options, 0);
254
255  ASSERT_EQ(sent_packets_.size(), 0U);
256}
257
258// Verify that we can send data after we've received STUN request
259// from the other side.
260TEST_F(P2PSocketHostUdpTest, SendAfterStunRequest) {
261  // Receive packet from |dest1_|.
262  std::vector<char> request_packet;
263  CreateStunRequest(&request_packet);
264
265  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
266      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
267  socket_->ReceivePacket(dest1_, request_packet);
268
269  // Now we should be able to send any data to |dest1_|.
270  EXPECT_CALL(sender_, Send(
271      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
272      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
273
274  rtc::PacketOptions options;
275  std::vector<char> packet;
276  CreateRandomPacket(&packet);
277  socket_host_->Send(dest1_, packet, options, 0);
278
279  ASSERT_EQ(1U, sent_packets_.size());
280  ASSERT_EQ(dest1_, sent_packets_[0].first);
281}
282
283// Verify that we can send data after we've received STUN response
284// from the other side.
285TEST_F(P2PSocketHostUdpTest, SendAfterStunResponse) {
286  // Receive packet from |dest1_|.
287  std::vector<char> request_packet;
288  CreateStunRequest(&request_packet);
289
290  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
291      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
292  socket_->ReceivePacket(dest1_, request_packet);
293
294  // Now we should be able to send any data to |dest1_|.
295  EXPECT_CALL(sender_, Send(
296      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
297      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
298
299  rtc::PacketOptions options;
300  std::vector<char> packet;
301  CreateRandomPacket(&packet);
302  socket_host_->Send(dest1_, packet, options, 0);
303
304  ASSERT_EQ(1U, sent_packets_.size());
305  ASSERT_EQ(dest1_, sent_packets_[0].first);
306}
307
308// Verify messages still cannot be sent to an unathorized host after
309// successful binding with different host.
310TEST_F(P2PSocketHostUdpTest, SendAfterStunResponseDifferentHost) {
311  // Receive packet from |dest1_|.
312  std::vector<char> request_packet;
313  CreateStunRequest(&request_packet);
314
315  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
316      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
317  socket_->ReceivePacket(dest1_, request_packet);
318
319  // Should fail when trying to send the same packet to |dest2_|.
320  rtc::PacketOptions options;
321  std::vector<char> packet;
322  CreateRandomPacket(&packet);
323  EXPECT_CALL(sender_, Send(
324      MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
325      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
326  socket_host_->Send(dest2_, packet, options, 0);
327}
328
329// Verify throttler not allowing unlimited sending of ICE messages to
330// any destination.
331TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimit) {
332  EXPECT_CALL(sender_, Send(
333      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
334      .Times(2)
335      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
336
337  rtc::PacketOptions options;
338  std::vector<char> packet1;
339  CreateStunRequest(&packet1);
340  throttler_.SetSendIceBandwidth(packet1.size() * 2);
341  socket_host_->Send(dest1_, packet1, options, 0);
342  socket_host_->Send(dest2_, packet1, options, 0);
343
344  net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2222);
345  // This packet must be dropped by the throttler.
346  socket_host_->Send(dest3, packet1, options, 0);
347  ASSERT_EQ(sent_packets_.size(), 2U);
348}
349
350// Verify we can send packets to a known destination when ICE throttling is
351// active.
352TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimitAfterReceive) {
353  // Receive packet from |dest1_|.
354  std::vector<char> request_packet;
355  CreateStunRequest(&request_packet);
356
357  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
358      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
359  socket_->ReceivePacket(dest1_, request_packet);
360
361  EXPECT_CALL(sender_, Send(
362      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
363      .Times(4)
364      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
365
366  rtc::PacketOptions options;
367  std::vector<char> packet1;
368  CreateStunRequest(&packet1);
369  throttler_.SetSendIceBandwidth(packet1.size());
370  // |dest1_| is known address, throttling will not be applied.
371  socket_host_->Send(dest1_, packet1, options, 0);
372  // Trying to send the packet to dest1_ in the same window. It should go.
373  socket_host_->Send(dest1_, packet1, options, 0);
374
375  // Throttler should allow this packet to go through.
376  socket_host_->Send(dest2_, packet1, options, 0);
377
378  net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2223);
379  // This packet will be dropped, as limit only for a single packet.
380  socket_host_->Send(dest3, packet1, options, 0);
381  net::IPEndPoint dest4 = ParseAddress(kTestIpAddress1, 2224);
382  // This packet should also be dropped.
383  socket_host_->Send(dest4, packet1, options, 0);
384  // |dest1| is known, we can send as many packets to it.
385  socket_host_->Send(dest1_, packet1, options, 0);
386  ASSERT_EQ(sent_packets_.size(), 4U);
387}
388
389}  // namespace content
390