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