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/libjingle/source/talk/base/timing.h"
21
22using ::testing::_;
23using ::testing::DeleteArg;
24using ::testing::DoAll;
25using ::testing::Return;
26
27namespace {
28
29class FakeTiming : public talk_base::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 bool SetReceiveBufferSize(int32 size) OVERRIDE {
98    return true;
99  }
100
101  virtual bool SetSendBufferSize(int32 size) OVERRIDE {
102    return true;
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 private:
164  net::IPEndPoint address_;
165  std::deque<UDPPacket>* sent_packets_;
166  std::deque<UDPPacket> incoming_packets_;
167  net::BoundNetLog net_log_;
168
169  scoped_refptr<net::IOBuffer> recv_buffer_;
170  net::IPEndPoint* recv_address_;
171  int recv_size_;
172  net::CompletionCallback recv_callback_;
173};
174
175}  // namespace
176
177namespace content {
178
179class P2PSocketHostUdpTest : public testing::Test {
180 protected:
181  virtual void SetUp() OVERRIDE {
182    EXPECT_CALL(sender_, Send(
183        MatchMessage(static_cast<uint32>(P2PMsg_OnSocketCreated::ID))))
184        .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
185
186    socket_host_.reset(new P2PSocketHostUdp(&sender_, 0, &throttler_));
187    socket_ = new FakeDatagramServerSocket(&sent_packets_);
188    socket_host_->socket_.reset(socket_);
189
190    local_address_ = ParseAddress(kTestLocalIpAddress, kTestPort1);
191    socket_host_->Init(local_address_, net::IPEndPoint());
192
193    dest1_ = ParseAddress(kTestIpAddress1, kTestPort1);
194    dest2_ = ParseAddress(kTestIpAddress2, kTestPort2);
195
196    scoped_ptr<talk_base::Timing> timing(new FakeTiming());
197    throttler_.SetTiming(timing.Pass());
198  }
199
200  P2PMessageThrottler throttler_;
201  std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets_;
202  FakeDatagramServerSocket* socket_; // Owned by |socket_host_|.
203  scoped_ptr<P2PSocketHostUdp> socket_host_;
204  MockIPCSender sender_;
205
206  net::IPEndPoint local_address_;
207
208  net::IPEndPoint dest1_;
209  net::IPEndPoint dest2_;
210};
211
212// Verify that we can send STUN messages before we receive anything
213// from the other side.
214TEST_F(P2PSocketHostUdpTest, SendStunNoAuth) {
215  EXPECT_CALL(sender_, Send(
216      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
217      .Times(3)
218      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
219
220  std::vector<char> packet1;
221  CreateStunRequest(&packet1);
222  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
223
224  std::vector<char> packet2;
225  CreateStunResponse(&packet2);
226  socket_host_->Send(dest1_, packet2, net::DSCP_NO_CHANGE, 0);
227
228  std::vector<char> packet3;
229  CreateStunError(&packet3);
230  socket_host_->Send(dest1_, packet3, net::DSCP_NO_CHANGE, 0);
231
232  ASSERT_EQ(sent_packets_.size(), 3U);
233  ASSERT_EQ(sent_packets_[0].second, packet1);
234  ASSERT_EQ(sent_packets_[1].second, packet2);
235  ASSERT_EQ(sent_packets_[2].second, packet3);
236}
237
238// Verify that no data packets can be sent before STUN binding has
239// finished.
240TEST_F(P2PSocketHostUdpTest, SendDataNoAuth) {
241  EXPECT_CALL(sender_, Send(
242      MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
243      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
244
245  std::vector<char> packet;
246  CreateRandomPacket(&packet);
247  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
248
249  ASSERT_EQ(sent_packets_.size(), 0U);
250}
251
252// Verify that we can send data after we've received STUN request
253// from the other side.
254TEST_F(P2PSocketHostUdpTest, SendAfterStunRequest) {
255  // Receive packet from |dest1_|.
256  std::vector<char> request_packet;
257  CreateStunRequest(&request_packet);
258
259  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
260      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
261  socket_->ReceivePacket(dest1_, request_packet);
262
263  // Now we should be able to send any data to |dest1_|.
264  EXPECT_CALL(sender_, Send(
265      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
266      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
267  std::vector<char> packet;
268  CreateRandomPacket(&packet);
269  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
270
271  ASSERT_EQ(1U, sent_packets_.size());
272  ASSERT_EQ(dest1_, sent_packets_[0].first);
273}
274
275// Verify that we can send data after we've received STUN response
276// from the other side.
277TEST_F(P2PSocketHostUdpTest, SendAfterStunResponse) {
278  // Receive packet from |dest1_|.
279  std::vector<char> request_packet;
280  CreateStunRequest(&request_packet);
281
282  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
283      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
284  socket_->ReceivePacket(dest1_, request_packet);
285
286  // Now we should be able to send any data to |dest1_|.
287  EXPECT_CALL(sender_, Send(
288      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
289      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
290  std::vector<char> packet;
291  CreateRandomPacket(&packet);
292  socket_host_->Send(dest1_, packet, net::DSCP_NO_CHANGE, 0);
293
294  ASSERT_EQ(1U, sent_packets_.size());
295  ASSERT_EQ(dest1_, sent_packets_[0].first);
296}
297
298// Verify messages still cannot be sent to an unathorized host after
299// successful binding with different host.
300TEST_F(P2PSocketHostUdpTest, SendAfterStunResponseDifferentHost) {
301  // Receive packet from |dest1_|.
302  std::vector<char> request_packet;
303  CreateStunRequest(&request_packet);
304
305  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
306      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
307  socket_->ReceivePacket(dest1_, request_packet);
308
309  // Should fail when trying to send the same packet to |dest2_|.
310  std::vector<char> packet;
311  CreateRandomPacket(&packet);
312  EXPECT_CALL(sender_, Send(
313      MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
314      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
315  socket_host_->Send(dest2_, packet, net::DSCP_NO_CHANGE, 0);
316}
317
318// Verify throttler not allowing unlimited sending of ICE messages to
319// any destination.
320TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimit) {
321  EXPECT_CALL(sender_, Send(
322      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
323      .Times(2)
324      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
325
326  std::vector<char> packet1;
327  CreateStunRequest(&packet1);
328  throttler_.SetSendIceBandwidth(packet1.size() * 2);
329  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
330  socket_host_->Send(dest2_, packet1, net::DSCP_NO_CHANGE, 0);
331
332  net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2222);
333  // This packet must be dropped by the throttler.
334  socket_host_->Send(dest3, packet1, net::DSCP_NO_CHANGE, 0);
335  ASSERT_EQ(sent_packets_.size(), 2U);
336}
337
338// Verify we can send packets to a known destination when ICE throttling is
339// active.
340TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimitAfterReceive) {
341  // Receive packet from |dest1_|.
342  std::vector<char> request_packet;
343  CreateStunRequest(&request_packet);
344
345  EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
346      .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
347  socket_->ReceivePacket(dest1_, request_packet);
348
349  EXPECT_CALL(sender_, Send(
350      MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
351      .Times(4)
352      .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
353
354  std::vector<char> packet1;
355  CreateStunRequest(&packet1);
356  throttler_.SetSendIceBandwidth(packet1.size());
357  // |dest1_| is known address, throttling will not be applied.
358  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
359  // Trying to send the packet to dest1_ in the same window. It should go.
360  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
361
362  // Throttler should allow this packet to go through.
363  socket_host_->Send(dest2_, packet1, net::DSCP_NO_CHANGE, 0);
364
365  net::IPEndPoint dest3 = ParseAddress(kTestIpAddress1, 2223);
366  // This packet will be dropped, as limit only for a single packet.
367  socket_host_->Send(dest3, packet1, net::DSCP_NO_CHANGE, 0);
368  net::IPEndPoint dest4 = ParseAddress(kTestIpAddress1, 2224);
369  // This packet should also be dropped.
370  socket_host_->Send(dest4, packet1, net::DSCP_NO_CHANGE, 0);
371  // |dest1| is known, we can send as many packets to it.
372  socket_host_->Send(dest1_, packet1, net::DSCP_NO_CHANGE, 0);
373  ASSERT_EQ(sent_packets_.size(), 4U);
374}
375
376}  // namespace content
377