net/socket/tcp_server_socket_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 "net/socket/tcp_server_socket.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "net/base/address_list.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/base/test_completion_callback.h"
  18 #include "net/socket/tcp_client_socket.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "testing/platform_test.h"
  21
  22 namespace net {
  23
  24 namespace {
  25 const int kListenBacklog = 5;
  26
  27 class TCPServerSocketTest : public PlatformTest {
  28  protected:
  29   TCPServerSocketTest()
  30       : socket_(NULL, NetLog::Source()) {
  31   }
  32
  33   void SetUpIPv4() {
  34     IPEndPoint address;
  35     ParseAddress("127.0.0.1", 0, &address);
  36     ASSERT_EQ(OK, socket_.Listen(address, kListenBacklog));
  37     ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
  38   }
  39
  40   void SetUpIPv6(bool* success) {
  41     *success = false;
  42     IPEndPoint address;
  43     ParseAddress("::1", 0, &address);
  44     if (socket_.Listen(address, kListenBacklog) != 0) {
  45       LOG(ERROR) << "Failed to listen on ::1 - probably because IPv6 is "
  46           "disabled. Skipping the test";
  47       return;
  48     }
  49     ASSERT_EQ(OK, socket_.GetLocalAddress(&local_address_));
  50     *success = true;
  51   }
  52
  53   void ParseAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
  54     IPAddressNumber ip_number;
  55     bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
  56     if (!rv)
  57       return;
  58     *address = IPEndPoint(ip_number, port);
  59   }
  60
  61   static IPEndPoint GetPeerAddress(StreamSocket* socket) {
  62     IPEndPoint address;
  63     EXPECT_EQ(OK, socket->GetPeerAddress(&address));
  64     return address;
  65   }
  66
  67   AddressList local_address_list() const {
  68     return AddressList(local_address_);
  69   }
  70
  71   TCPServerSocket socket_;
  72   IPEndPoint local_address_;
  73 };
  74
  75 TEST_F(TCPServerSocketTest, Accept) {
  76   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
  77
  78   TestCompletionCallback connect_callback;
  79   TCPClientSocket connecting_socket(local_address_list(),
  80                                     NULL, NetLog::Source());
  81   connecting_socket.Connect(connect_callback.callback());
  82
  83   TestCompletionCallback accept_callback;
  84   scoped_ptr<StreamSocket> accepted_socket;
  85   int result = socket_.Accept(&accepted_socket, accept_callback.callback());
  86   if (result == ERR_IO_PENDING)
  87     result = accept_callback.WaitForResult();
  88   ASSERT_EQ(OK, result);
  89
  90   ASSERT_TRUE(accepted_socket.get() != NULL);
  91
  92   // Both sockets should be on the loopback network interface.
  93   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
  94             local_address_.address());
  95
  96   EXPECT_EQ(OK, connect_callback.WaitForResult());
  97 }
  98
  99 // Test Accept() callback.
 100 TEST_F(TCPServerSocketTest, AcceptAsync) {
 101   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
 102
 103   TestCompletionCallback accept_callback;
 104   scoped_ptr<StreamSocket> accepted_socket;
 105
 106   ASSERT_EQ(ERR_IO_PENDING,
 107             socket_.Accept(&accepted_socket, accept_callback.callback()));
 108
 109   TestCompletionCallback connect_callback;
 110   TCPClientSocket connecting_socket(local_address_list(),
 111                                     NULL, NetLog::Source());
 112   connecting_socket.Connect(connect_callback.callback());
 113
 114   EXPECT_EQ(OK, connect_callback.WaitForResult());
 115   EXPECT_EQ(OK, accept_callback.WaitForResult());
 116
 117   EXPECT_TRUE(accepted_socket != NULL);
 118
 119   // Both sockets should be on the loopback network interface.
 120   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
 121             local_address_.address());
 122 }
 123
 124 // Accept two connections simultaneously.
 125 TEST_F(TCPServerSocketTest, Accept2Connections) {
 126   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
 127
 128   TestCompletionCallback accept_callback;
 129   scoped_ptr<StreamSocket> accepted_socket;
 130
 131   ASSERT_EQ(ERR_IO_PENDING,
 132             socket_.Accept(&accepted_socket, accept_callback.callback()));
 133
 134   TestCompletionCallback connect_callback;
 135   TCPClientSocket connecting_socket(local_address_list(),
 136                                     NULL, NetLog::Source());
 137   connecting_socket.Connect(connect_callback.callback());
 138
 139   TestCompletionCallback connect_callback2;
 140   TCPClientSocket connecting_socket2(local_address_list(),
 141                                      NULL, NetLog::Source());
 142   connecting_socket2.Connect(connect_callback2.callback());
 143
 144   EXPECT_EQ(OK, accept_callback.WaitForResult());
 145
 146   TestCompletionCallback accept_callback2;
 147   scoped_ptr<StreamSocket> accepted_socket2;
 148   int result = socket_.Accept(&accepted_socket2, accept_callback2.callback());
 149   if (result == ERR_IO_PENDING)
 150     result = accept_callback2.WaitForResult();
 151   ASSERT_EQ(OK, result);
 152
 153   EXPECT_EQ(OK, connect_callback.WaitForResult());
 154
 155   EXPECT_TRUE(accepted_socket != NULL);
 156   EXPECT_TRUE(accepted_socket2 != NULL);
 157   EXPECT_NE(accepted_socket.get(), accepted_socket2.get());
 158
 159   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
 160             local_address_.address());
 161   EXPECT_EQ(GetPeerAddress(accepted_socket2.get()).address(),
 162             local_address_.address());
 163 }
 164
 165 TEST_F(TCPServerSocketTest, AcceptIPv6) {
 166   bool initialized = false;
 167   ASSERT_NO_FATAL_FAILURE(SetUpIPv6(&initialized));
 168   if (!initialized)
 169     return;
 170
 171   TestCompletionCallback connect_callback;
 172   TCPClientSocket connecting_socket(local_address_list(),
 173                                     NULL, NetLog::Source());
 174   connecting_socket.Connect(connect_callback.callback());
 175
 176   TestCompletionCallback accept_callback;
 177   scoped_ptr<StreamSocket> accepted_socket;
 178   int result = socket_.Accept(&accepted_socket, accept_callback.callback());
 179   if (result == ERR_IO_PENDING)
 180     result = accept_callback.WaitForResult();
 181   ASSERT_EQ(OK, result);
 182
 183   ASSERT_TRUE(accepted_socket.get() != NULL);
 184
 185   // Both sockets should be on the loopback network interface.
 186   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
 187             local_address_.address());
 188
 189   EXPECT_EQ(OK, connect_callback.WaitForResult());
 190 }
 191
 192 TEST_F(TCPServerSocketTest, AcceptIO) {
 193   ASSERT_NO_FATAL_FAILURE(SetUpIPv4());
 194
 195   TestCompletionCallback connect_callback;
 196   TCPClientSocket connecting_socket(local_address_list(),
 197                                     NULL, NetLog::Source());
 198   connecting_socket.Connect(connect_callback.callback());
 199
 200   TestCompletionCallback accept_callback;
 201   scoped_ptr<StreamSocket> accepted_socket;
 202   int result = socket_.Accept(&accepted_socket, accept_callback.callback());
 203   ASSERT_EQ(OK, accept_callback.GetResult(result));
 204
 205   ASSERT_TRUE(accepted_socket.get() != NULL);
 206
 207   // Both sockets should be on the loopback network interface.
 208   EXPECT_EQ(GetPeerAddress(accepted_socket.get()).address(),
 209             local_address_.address());
 210
 211   EXPECT_EQ(OK, connect_callback.WaitForResult());
 212
 213   const std::string message("test message");
 214   std::vector<char> buffer(message.size());
 215
 216   size_t bytes_written = 0;
 217   while (bytes_written < message.size()) {
 218     scoped_refptr<IOBufferWithSize> write_buffer(
 219         new IOBufferWithSize(message.size() - bytes_written));
 220     memmove(write_buffer->data(), message.data(), message.size());
 221
 222     TestCompletionCallback write_callback;
 223     int write_result = accepted_socket->Write(
 224         write_buffer.get(), write_buffer->size(), write_callback.callback());
 225     write_result = write_callback.GetResult(write_result);
 226     ASSERT_TRUE(write_result >= 0);
 227     ASSERT_TRUE(bytes_written + write_result <= message.size());
 228     bytes_written += write_result;
 229   }
 230
 231   size_t bytes_read = 0;
 232   while (bytes_read < message.size()) {
 233     scoped_refptr<IOBufferWithSize> read_buffer(
 234         new IOBufferWithSize(message.size() - bytes_read));
 235     TestCompletionCallback read_callback;
 236     int read_result = connecting_socket.Read(
 237         read_buffer.get(), read_buffer->size(), read_callback.callback());
 238     read_result = read_callback.GetResult(read_result);
 239     ASSERT_TRUE(read_result >= 0);
 240     ASSERT_TRUE(bytes_read + read_result <= message.size());
 241     memmove(&buffer[bytes_read], read_buffer->data(), read_result);
 242     bytes_read += read_result;
 243   }
 244
 245   std::string received_message(buffer.begin(), buffer.end());
 246   ASSERT_EQ(message, received_message);
 247 }
 248
 249 }  // namespace
 250
 251 }  // namespace net