content/browser/renderer_host/p2p/socket_host_tcp_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_tcp.h"
   6
   7 #include <deque>
   8
   9 #include "base/sys_byteorder.h"
  10 #include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
  11 #include "net/socket/stream_socket.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using ::testing::_;
  16 using ::testing::DeleteArg;
  17 using ::testing::DoAll;
  18 using ::testing::Return;
  19
  20 namespace content {
  21
  22 class P2PSocketHostTcpTestBase : public testing::Test {
  23  protected:
  24   explicit P2PSocketHostTcpTestBase(P2PSocketType type)
  25       : socket_type_(type) {
  26   }
  27
  28   virtual void SetUp() OVERRIDE {
  29     EXPECT_CALL(sender_, Send(
  30         MatchMessage(static_cast<uint32>(P2PMsg_OnSocketCreated::ID))))
  31         .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
  32
  33     if (socket_type_ == P2P_SOCKET_TCP_CLIENT) {
  34       socket_host_.reset(new P2PSocketHostTcp(
  35                             &sender_, 0,  P2P_SOCKET_TCP_CLIENT, NULL));
  36     } else {
  37       socket_host_.reset(new P2PSocketHostStunTcp(
  38                             &sender_, 0,  P2P_SOCKET_STUN_TCP_CLIENT, NULL));
  39     }
  40
  41     socket_ = new FakeSocket(&sent_data_);
  42     socket_->SetLocalAddress(ParseAddress(kTestLocalIpAddress, kTestPort1));
  43     socket_host_->socket_.reset(socket_);
  44
  45     dest_ = ParseAddress(kTestIpAddress1, kTestPort1);
  46
  47     local_address_ = ParseAddress(kTestLocalIpAddress, kTestPort1);
  48
  49     socket_host_->remote_address_ = dest_;
  50     socket_host_->state_ = P2PSocketHost::STATE_CONNECTING;
  51     socket_host_->OnConnected(net::OK);
  52   }
  53
  54   std::string IntToSize(int size) {
  55     std::string result;
  56     uint16 size16 = base::HostToNet16(size);
  57     result.resize(sizeof(size16));
  58     memcpy(&result[0], &size16, sizeof(size16));
  59     return result;
  60   }
  61
  62   std::string sent_data_;
  63   FakeSocket* socket_;  // Owned by |socket_host_|.
  64   scoped_ptr<P2PSocketHostTcpBase> socket_host_;
  65   MockIPCSender sender_;
  66
  67   net::IPEndPoint local_address_;
  68
  69   net::IPEndPoint dest_;
  70   net::IPEndPoint dest2_;
  71
  72   P2PSocketType socket_type_;
  73 };
  74
  75 class P2PSocketHostTcpTest : public P2PSocketHostTcpTestBase {
  76  protected:
  77   P2PSocketHostTcpTest() : P2PSocketHostTcpTestBase(P2P_SOCKET_TCP_CLIENT) { }
  78 };
  79
  80 class P2PSocketHostStunTcpTest : public P2PSocketHostTcpTestBase {
  81  protected:
  82   P2PSocketHostStunTcpTest()
  83       : P2PSocketHostTcpTestBase(P2P_SOCKET_STUN_TCP_CLIENT) {
  84   }
  85 };
  86
  87 // Verify that we can send STUN message and that they are formatted
  88 // properly.
  89 TEST_F(P2PSocketHostTcpTest, SendStunNoAuth) {
  90   EXPECT_CALL(sender_, Send(
  91       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
  92       .Times(3)
  93       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
  94
  95   std::vector<char> packet1;
  96   CreateStunRequest(&packet1);
  97   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE, 0);
  98
  99   std::vector<char> packet2;
 100   CreateStunResponse(&packet2);
 101   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 102
 103   std::vector<char> packet3;
 104   CreateStunError(&packet3);
 105   socket_host_->Send(dest_, packet3, net::DSCP_NO_CHANGE, 0);
 106
 107   std::string expected_data;
 108   expected_data.append(IntToSize(packet1.size()));
 109   expected_data.append(packet1.begin(), packet1.end());
 110   expected_data.append(IntToSize(packet2.size()));
 111   expected_data.append(packet2.begin(), packet2.end());
 112   expected_data.append(IntToSize(packet3.size()));
 113   expected_data.append(packet3.begin(), packet3.end());
 114
 115   EXPECT_EQ(expected_data, sent_data_);
 116 }
 117
 118 // Verify that we can receive STUN messages from the socket, and that
 119 // the messages are parsed properly.
 120 TEST_F(P2PSocketHostTcpTest, ReceiveStun) {
 121   EXPECT_CALL(sender_, Send(
 122       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
 123       .Times(3)
 124       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 125
 126   std::vector<char> packet1;
 127   CreateStunRequest(&packet1);
 128   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE, 0);
 129
 130   std::vector<char> packet2;
 131   CreateStunResponse(&packet2);
 132   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 133
 134   std::vector<char> packet3;
 135   CreateStunError(&packet3);
 136   socket_host_->Send(dest_, packet3, net::DSCP_NO_CHANGE, 0);
 137
 138   std::string received_data;
 139   received_data.append(IntToSize(packet1.size()));
 140   received_data.append(packet1.begin(), packet1.end());
 141   received_data.append(IntToSize(packet2.size()));
 142   received_data.append(packet2.begin(), packet2.end());
 143   received_data.append(IntToSize(packet3.size()));
 144   received_data.append(packet3.begin(), packet3.end());
 145
 146   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet1)))
 147       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 148   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet2)))
 149       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 150   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet3)))
 151       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 152
 153   size_t pos = 0;
 154   size_t step_sizes[] = {3, 2, 1};
 155   size_t step = 0;
 156   while (pos < received_data.size()) {
 157     size_t step_size = std::min(step_sizes[step], received_data.size() - pos);
 158     socket_->AppendInputData(&received_data[pos], step_size);
 159     pos += step_size;
 160     if (++step >= arraysize(step_sizes))
 161       step = 0;
 162   }
 163 }
 164
 165 // Verify that we can't send data before we've received STUN response
 166 // from the other side.
 167 TEST_F(P2PSocketHostTcpTest, SendDataNoAuth) {
 168   EXPECT_CALL(sender_, Send(
 169       MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
 170       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 171
 172   std::vector<char> packet;
 173   CreateRandomPacket(&packet);
 174   socket_host_->Send(dest_, packet, net::DSCP_NO_CHANGE, 0);
 175
 176   EXPECT_EQ(0U, sent_data_.size());
 177 }
 178
 179 // Verify that we can send data after we've received STUN response
 180 // from the other side.
 181 TEST_F(P2PSocketHostTcpTest, SendAfterStunRequest) {
 182   // Receive packet from |dest_|.
 183   std::vector<char> request_packet;
 184   CreateStunRequest(&request_packet);
 185
 186   std::string received_data;
 187   received_data.append(IntToSize(request_packet.size()));
 188   received_data.append(request_packet.begin(), request_packet.end());
 189
 190   EXPECT_CALL(sender_, Send(
 191       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
 192       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 193   EXPECT_CALL(sender_, Send(MatchPacketMessage(request_packet)))
 194       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 195   socket_->AppendInputData(&received_data[0], received_data.size());
 196
 197   // Now we should be able to send any data to |dest_|.
 198   std::vector<char> packet;
 199   CreateRandomPacket(&packet);
 200   socket_host_->Send(dest_, packet, net::DSCP_NO_CHANGE, 0);
 201
 202   std::string expected_data;
 203   expected_data.append(IntToSize(packet.size()));
 204   expected_data.append(packet.begin(), packet.end());
 205
 206   EXPECT_EQ(expected_data, sent_data_);
 207 }
 208
 209 // Verify that asynchronous writes are handled correctly.
 210 TEST_F(P2PSocketHostTcpTest, AsyncWrites) {
 211   base::MessageLoop message_loop;
 212
 213   socket_->set_async_write(true);
 214
 215   EXPECT_CALL(sender_, Send(
 216       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
 217       .Times(2)
 218       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 219
 220   std::vector<char> packet1;
 221   CreateStunRequest(&packet1);
 222
 223   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE, 0);
 224
 225   std::vector<char> packet2;
 226   CreateStunResponse(&packet2);
 227   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 228
 229   message_loop.RunUntilIdle();
 230
 231   std::string expected_data;
 232   expected_data.append(IntToSize(packet1.size()));
 233   expected_data.append(packet1.begin(), packet1.end());
 234   expected_data.append(IntToSize(packet2.size()));
 235   expected_data.append(packet2.begin(), packet2.end());
 236
 237   EXPECT_EQ(expected_data, sent_data_);
 238 }
 239
 240 // Verify that we can send STUN message and that they are formatted
 241 // properly.
 242 TEST_F(P2PSocketHostStunTcpTest, SendStunNoAuth) {
 243   EXPECT_CALL(sender_, Send(
 244       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
 245       .Times(3)
 246       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 247
 248   std::vector<char> packet1;
 249   CreateStunRequest(&packet1);
 250   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE, 0);
 251
 252   std::vector<char> packet2;
 253   CreateStunResponse(&packet2);
 254   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 255
 256   std::vector<char> packet3;
 257   CreateStunError(&packet3);
 258   socket_host_->Send(dest_, packet3, net::DSCP_NO_CHANGE, 0);
 259
 260   std::string expected_data;
 261   expected_data.append(packet1.begin(), packet1.end());
 262   expected_data.append(packet2.begin(), packet2.end());
 263   expected_data.append(packet3.begin(), packet3.end());
 264
 265   EXPECT_EQ(expected_data, sent_data_);
 266 }
 267
 268 // Verify that we can receive STUN messages from the socket, and that
 269 // the messages are parsed properly.
 270 TEST_F(P2PSocketHostStunTcpTest, ReceiveStun) {
 271   EXPECT_CALL(sender_, Send(
 272       MatchMessage(static_cast<uint32>(P2PMsg_OnSendComplete::ID))))
 273       .Times(3)
 274       .WillRepeatedly(DoAll(DeleteArg<0>(), Return(true)));
 275
 276   std::vector<char> packet1;
 277   CreateStunRequest(&packet1);
 278   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE, 0);
 279
 280   std::vector<char> packet2;
 281   CreateStunResponse(&packet2);
 282   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 283
 284   std::vector<char> packet3;
 285   CreateStunError(&packet3);
 286   socket_host_->Send(dest_, packet3, net::DSCP_NO_CHANGE, 0);
 287
 288   std::string received_data;
 289   received_data.append(packet1.begin(), packet1.end());
 290   received_data.append(packet2.begin(), packet2.end());
 291   received_data.append(packet3.begin(), packet3.end());
 292
 293   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet1)))
 294       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 295   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet2)))
 296       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 297   EXPECT_CALL(sender_, Send(MatchPacketMessage(packet3)))
 298       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 299
 300   size_t pos = 0;
 301   size_t step_sizes[] = {3, 2, 1};
 302   size_t step = 0;
 303   while (pos < received_data.size()) {
 304     size_t step_size = std::min(step_sizes[step], received_data.size() - pos);
 305     socket_->AppendInputData(&received_data[pos], step_size);
 306     pos += step_size;
 307     if (++step >= arraysize(step_sizes))
 308       step = 0;
 309   }
 310 }
 311
 312 // Verify that we can't send data before we've received STUN response
 313 // from the other side.
 314 TEST_F(P2PSocketHostStunTcpTest, SendDataNoAuth) {
 315   EXPECT_CALL(sender_, Send(
 316       MatchMessage(static_cast<uint32>(P2PMsg_OnError::ID))))
 317       .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 318
 319   std::vector<char> packet;
 320   CreateRandomPacket(&packet);
 321   socket_host_->Send(dest_, packet, net::DSCP_NO_CHANGE, 0);
 322
 323   EXPECT_EQ(0U, sent_data_.size());
 324 }
 325
 326 // Verify that asynchronous writes are handled correctly.
 327 TEST_F(P2PSocketHostStunTcpTest, AsyncWrites) {
 328   base::MessageLoop message_loop;
 329
 330   socket_->set_async_write(true);
 331
 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   std::vector<char> packet1;
 338   CreateStunRequest(&packet1);
 339   socket_host_->Send(dest_, packet1, net::DSCP_NO_CHANGE,0);
 340
 341   std::vector<char> packet2;
 342   CreateStunResponse(&packet2);
 343   socket_host_->Send(dest_, packet2, net::DSCP_NO_CHANGE, 0);
 344
 345   message_loop.RunUntilIdle();
 346
 347   std::string expected_data;
 348   expected_data.append(packet1.begin(), packet1.end());
 349   expected_data.append(packet2.begin(), packet2.end());
 350
 351   EXPECT_EQ(expected_data, sent_data_);
 352 }
 353
 354 }  // namespace content