src/content/browser/renderer_host/p2p/socket_host_udp_unittest.cc

   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
  22 using ::testing::_;
  23 using ::testing::DeleteArg;
  24 using ::testing::DoAll;
  25 using ::testing::Return;
  26
  27 namespace {
  28
  29 class 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
  39 class 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
 181 namespace content {
 182
 183 class 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<talk_base::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.
 218 TEST_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   talk_base::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.
 245 TEST_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   talk_base::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.
 260 TEST_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   talk_base::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.
 285 TEST_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   talk_base::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.
 310 TEST_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   talk_base::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.
 331 TEST_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   talk_base::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.
 352 TEST_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   talk_base::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