src/net/socket/unix_domain_client_socket_posix_unittest.cc

   1 // Copyright 2014 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/unix_domain_client_socket_posix.h"
   6
   7 #include <unistd.h>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "net/base/io_buffer.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/base/test_completion_callback.h"
  16 #include "net/socket/unix_domain_server_socket_posix.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace net {
  20 namespace {
  21
  22 const char kSocketFilename[] = "socket_for_testing";
  23
  24 bool UserCanConnectCallback(
  25     bool allow_user, const UnixDomainServerSocket::Credentials& credentials) {
  26   // Here peers are running in same process.
  27 #if defined(OS_LINUX) || defined(OS_ANDROID)
  28   EXPECT_EQ(getpid(), credentials.process_id);
  29 #endif
  30   EXPECT_EQ(getuid(), credentials.user_id);
  31   EXPECT_EQ(getgid(), credentials.group_id);
  32   return allow_user;
  33 }
  34
  35 UnixDomainServerSocket::AuthCallback CreateAuthCallback(bool allow_user) {
  36   return base::Bind(&UserCanConnectCallback, allow_user);
  37 }
  38
  39 // Connects socket synchronously.
  40 int ConnectSynchronously(StreamSocket* socket) {
  41   TestCompletionCallback connect_callback;
  42   int rv = socket->Connect(connect_callback.callback());
  43   if (rv == ERR_IO_PENDING)
  44     rv = connect_callback.WaitForResult();
  45   return rv;
  46 }
  47
  48 // Reads data from |socket| until it fills |buf| at least up to |min_data_len|.
  49 // Returns length of data read, or a net error.
  50 int ReadSynchronously(StreamSocket* socket,
  51                       IOBuffer* buf,
  52                       int buf_len,
  53                       int min_data_len) {
  54   DCHECK_LE(min_data_len, buf_len);
  55   scoped_refptr<DrainableIOBuffer> read_buf(
  56       new DrainableIOBuffer(buf, buf_len));
  57   TestCompletionCallback read_callback;
  58   // Iterate reading several times (but not infinite) until it reads at least
  59   // |min_data_len| bytes into |buf|.
  60   for (int retry_count = 10;
  61        retry_count > 0 && (read_buf->BytesConsumed() < min_data_len ||
  62                            // Try at least once when min_data_len == 0.
  63                            min_data_len == 0);
  64        --retry_count) {
  65     int rv = socket->Read(read_buf, read_buf->BytesRemaining(),
  66                           read_callback.callback());
  67     EXPECT_GE(read_buf->BytesRemaining(), rv);
  68     if (rv == ERR_IO_PENDING) {
  69       // If |min_data_len| is 0, returns ERR_IO_PENDING to distinguish the case
  70       // when some data has been read.
  71       if (min_data_len == 0) {
  72         // No data has been read because of for-loop condition.
  73         DCHECK_EQ(0, read_buf->BytesConsumed());
  74         return ERR_IO_PENDING;
  75       }
  76       rv = read_callback.WaitForResult();
  77     }
  78     EXPECT_NE(ERR_IO_PENDING, rv);
  79     if (rv < 0)
  80       return rv;
  81     read_buf->DidConsume(rv);
  82   }
  83   EXPECT_LE(0, read_buf->BytesRemaining());
  84   return read_buf->BytesConsumed();
  85 }
  86
  87 // Writes data to |socket| until it completes writing |buf| up to |buf_len|.
  88 // Returns length of data written, or a net error.
  89 int WriteSynchronously(StreamSocket* socket,
  90                        IOBuffer* buf,
  91                        int buf_len) {
  92   scoped_refptr<DrainableIOBuffer> write_buf(
  93       new DrainableIOBuffer(buf, buf_len));
  94   TestCompletionCallback write_callback;
  95   // Iterate writing several times (but not infinite) until it writes buf fully.
  96   for (int retry_count = 10;
  97        retry_count > 0 && write_buf->BytesRemaining() > 0;
  98        --retry_count) {
  99     int rv = socket->Write(write_buf, write_buf->BytesRemaining(),
 100                            write_callback.callback());
 101     EXPECT_GE(write_buf->BytesRemaining(), rv);
 102     if (rv == ERR_IO_PENDING)
 103       rv = write_callback.WaitForResult();
 104     EXPECT_NE(ERR_IO_PENDING, rv);
 105     if (rv < 0)
 106       return rv;
 107     write_buf->DidConsume(rv);
 108   }
 109   EXPECT_LE(0, write_buf->BytesRemaining());
 110   return write_buf->BytesConsumed();
 111 }
 112
 113 class UnixDomainClientSocketTest : public testing::Test {
 114  protected:
 115   UnixDomainClientSocketTest() {
 116     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
 117     socket_path_ = temp_dir_.path().Append(kSocketFilename).value();
 118   }
 119
 120   base::ScopedTempDir temp_dir_;
 121   std::string socket_path_;
 122 };
 123
 124 TEST_F(UnixDomainClientSocketTest, Connect) {
 125   const bool kUseAbstractNamespace = false;
 126
 127   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
 128                                        kUseAbstractNamespace);
 129   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 130
 131   scoped_ptr<StreamSocket> accepted_socket;
 132   TestCompletionCallback accept_callback;
 133   EXPECT_EQ(ERR_IO_PENDING,
 134             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 135   EXPECT_FALSE(accepted_socket);
 136
 137   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
 138   EXPECT_FALSE(client_socket.IsConnected());
 139
 140   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 141   EXPECT_TRUE(client_socket.IsConnected());
 142   // Server has not yet been notified of the connection.
 143   EXPECT_FALSE(accepted_socket);
 144
 145   EXPECT_EQ(OK, accept_callback.WaitForResult());
 146   EXPECT_TRUE(accepted_socket);
 147   EXPECT_TRUE(accepted_socket->IsConnected());
 148 }
 149
 150 TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) {
 151   const bool kUseAbstractNamespace = true;
 152
 153   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
 154   EXPECT_FALSE(client_socket.IsConnected());
 155
 156 #if defined(OS_ANDROID) || defined(OS_LINUX)
 157   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
 158                                        kUseAbstractNamespace);
 159   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 160
 161   scoped_ptr<StreamSocket> accepted_socket;
 162   TestCompletionCallback accept_callback;
 163   EXPECT_EQ(ERR_IO_PENDING,
 164             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 165   EXPECT_FALSE(accepted_socket);
 166
 167   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 168   EXPECT_TRUE(client_socket.IsConnected());
 169   // Server has not yet beend notified of the connection.
 170   EXPECT_FALSE(accepted_socket);
 171
 172   EXPECT_EQ(OK, accept_callback.WaitForResult());
 173   EXPECT_TRUE(accepted_socket);
 174   EXPECT_TRUE(accepted_socket->IsConnected());
 175 #else
 176   EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket));
 177 #endif
 178 }
 179
 180 TEST_F(UnixDomainClientSocketTest, ConnectToNonExistentSocket) {
 181   const bool kUseAbstractNamespace = false;
 182
 183   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
 184   EXPECT_FALSE(client_socket.IsConnected());
 185   EXPECT_EQ(ERR_FILE_NOT_FOUND, ConnectSynchronously(&client_socket));
 186 }
 187
 188 TEST_F(UnixDomainClientSocketTest,
 189        ConnectToNonExistentSocketWithAbstractNamespace) {
 190   const bool kUseAbstractNamespace = true;
 191
 192   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
 193   EXPECT_FALSE(client_socket.IsConnected());
 194
 195   TestCompletionCallback connect_callback;
 196 #if defined(OS_ANDROID) || defined(OS_LINUX)
 197   EXPECT_EQ(ERR_CONNECTION_REFUSED, ConnectSynchronously(&client_socket));
 198 #else
 199   EXPECT_EQ(ERR_ADDRESS_INVALID, ConnectSynchronously(&client_socket));
 200 #endif
 201 }
 202
 203 TEST_F(UnixDomainClientSocketTest, DisconnectFromClient) {
 204   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
 205   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 206   scoped_ptr<StreamSocket> accepted_socket;
 207   TestCompletionCallback accept_callback;
 208   EXPECT_EQ(ERR_IO_PENDING,
 209             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 210   UnixDomainClientSocket client_socket(socket_path_, false);
 211   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 212
 213   EXPECT_EQ(OK, accept_callback.WaitForResult());
 214   EXPECT_TRUE(accepted_socket->IsConnected());
 215   EXPECT_TRUE(client_socket.IsConnected());
 216
 217   // Try to read data.
 218   const int kReadDataSize = 10;
 219   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
 220   TestCompletionCallback read_callback;
 221   EXPECT_EQ(ERR_IO_PENDING,
 222             accepted_socket->Read(read_buffer, kReadDataSize,
 223                                   read_callback.callback()));
 224
 225   // Disconnect from client side.
 226   client_socket.Disconnect();
 227   EXPECT_FALSE(client_socket.IsConnected());
 228   EXPECT_FALSE(accepted_socket->IsConnected());
 229
 230   // Connection closed by peer.
 231   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
 232   // Note that read callback won't be called when the connection is closed
 233   // locally before the peer closes it. SocketLibevent just clears callbacks.
 234 }
 235
 236 TEST_F(UnixDomainClientSocketTest, DisconnectFromServer) {
 237   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
 238   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 239   scoped_ptr<StreamSocket> accepted_socket;
 240   TestCompletionCallback accept_callback;
 241   EXPECT_EQ(ERR_IO_PENDING,
 242             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 243   UnixDomainClientSocket client_socket(socket_path_, false);
 244   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 245
 246   EXPECT_EQ(OK, accept_callback.WaitForResult());
 247   EXPECT_TRUE(accepted_socket->IsConnected());
 248   EXPECT_TRUE(client_socket.IsConnected());
 249
 250   // Try to read data.
 251   const int kReadDataSize = 10;
 252   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
 253   TestCompletionCallback read_callback;
 254   EXPECT_EQ(ERR_IO_PENDING,
 255             client_socket.Read(read_buffer, kReadDataSize,
 256                                read_callback.callback()));
 257
 258   // Disconnect from server side.
 259   accepted_socket->Disconnect();
 260   EXPECT_FALSE(accepted_socket->IsConnected());
 261   EXPECT_FALSE(client_socket.IsConnected());
 262
 263   // Connection closed by peer.
 264   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
 265   // Note that read callback won't be called when the connection is closed
 266   // locally before the peer closes it. SocketLibevent just clears callbacks.
 267 }
 268
 269 TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
 270   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
 271   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 272   scoped_ptr<StreamSocket> accepted_socket;
 273   TestCompletionCallback accept_callback;
 274   EXPECT_EQ(ERR_IO_PENDING,
 275             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 276   UnixDomainClientSocket client_socket(socket_path_, false);
 277   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 278
 279   EXPECT_EQ(OK, accept_callback.WaitForResult());
 280   EXPECT_TRUE(accepted_socket->IsConnected());
 281   EXPECT_TRUE(client_socket.IsConnected());
 282
 283   // Send data from client to server.
 284   const int kWriteDataSize = 10;
 285   scoped_refptr<IOBuffer> write_buffer(
 286       new StringIOBuffer(std::string(kWriteDataSize, 'd')));
 287   EXPECT_EQ(kWriteDataSize,
 288             WriteSynchronously(&client_socket,
 289                                write_buffer,
 290                                kWriteDataSize));
 291
 292   // The buffer is bigger than write data size.
 293   const int kReadBufferSize = kWriteDataSize * 2;
 294   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
 295   EXPECT_EQ(kWriteDataSize,
 296             ReadSynchronously(accepted_socket.get(),
 297                               read_buffer,
 298                               kReadBufferSize,
 299                               kWriteDataSize));
 300   EXPECT_EQ(std::string(write_buffer->data(), kWriteDataSize),
 301             std::string(read_buffer->data(), kWriteDataSize));
 302
 303   // Send data from server and client.
 304   EXPECT_EQ(kWriteDataSize,
 305             WriteSynchronously(accepted_socket.get(),
 306                                write_buffer,
 307                                kWriteDataSize));
 308
 309   // Read multiple times.
 310   const int kSmallReadBufferSize = kWriteDataSize / 3;
 311   EXPECT_EQ(kSmallReadBufferSize,
 312             ReadSynchronously(&client_socket,
 313                               read_buffer,
 314                               kSmallReadBufferSize,
 315                               kSmallReadBufferSize));
 316   EXPECT_EQ(std::string(write_buffer->data(), kSmallReadBufferSize),
 317             std::string(read_buffer->data(), kSmallReadBufferSize));
 318
 319   EXPECT_EQ(kWriteDataSize - kSmallReadBufferSize,
 320             ReadSynchronously(&client_socket,
 321                               read_buffer,
 322                               kReadBufferSize,
 323                               kWriteDataSize - kSmallReadBufferSize));
 324   EXPECT_EQ(std::string(write_buffer->data() + kSmallReadBufferSize,
 325                         kWriteDataSize - kSmallReadBufferSize),
 326             std::string(read_buffer->data(),
 327                         kWriteDataSize - kSmallReadBufferSize));
 328
 329   // No more data.
 330   EXPECT_EQ(ERR_IO_PENDING,
 331             ReadSynchronously(&client_socket,
 332                               read_buffer,
 333                               kReadBufferSize,
 334                               0));
 335
 336   // Disconnect from server side after read-write.
 337   accepted_socket->Disconnect();
 338   EXPECT_FALSE(accepted_socket->IsConnected());
 339   EXPECT_FALSE(client_socket.IsConnected());
 340 }
 341
 342 TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) {
 343   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
 344   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
 345   scoped_ptr<StreamSocket> accepted_socket;
 346   TestCompletionCallback accept_callback;
 347   EXPECT_EQ(ERR_IO_PENDING,
 348             server_socket.Accept(&accepted_socket, accept_callback.callback()));
 349   UnixDomainClientSocket client_socket(socket_path_, false);
 350   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 351
 352   EXPECT_EQ(OK, accept_callback.WaitForResult());
 353   EXPECT_TRUE(accepted_socket->IsConnected());
 354   EXPECT_TRUE(client_socket.IsConnected());
 355
 356   // Wait for data from client.
 357   const int kWriteDataSize = 10;
 358   const int kReadBufferSize = kWriteDataSize * 2;
 359   const int kSmallReadBufferSize = kWriteDataSize / 3;
 360   // Read smaller than write data size first.
 361   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
 362   TestCompletionCallback read_callback;
 363   EXPECT_EQ(ERR_IO_PENDING,
 364             accepted_socket->Read(read_buffer, kSmallReadBufferSize,
 365                                   read_callback.callback()));
 366
 367   scoped_refptr<IOBuffer> write_buffer(
 368       new StringIOBuffer(std::string(kWriteDataSize, 'd')));
 369   EXPECT_EQ(kWriteDataSize,
 370             WriteSynchronously(&client_socket,
 371                                write_buffer,
 372                                kWriteDataSize));
 373
 374   // First read completed.
 375   int rv = read_callback.WaitForResult();
 376   EXPECT_LT(0, rv);
 377   EXPECT_LE(rv, kSmallReadBufferSize);
 378
 379   // Read remaining data.
 380   const int kExpectedRemainingDataSize = kWriteDataSize - rv;
 381   EXPECT_LE(0, kExpectedRemainingDataSize);
 382   EXPECT_EQ(kExpectedRemainingDataSize,
 383             ReadSynchronously(accepted_socket.get(),
 384                               read_buffer,
 385                               kReadBufferSize,
 386                               kExpectedRemainingDataSize));
 387   // No more data.
 388   EXPECT_EQ(ERR_IO_PENDING,
 389             ReadSynchronously(accepted_socket.get(),
 390                               read_buffer,
 391                               kReadBufferSize,
 392                               0));
 393
 394   // Disconnect from server side after read-write.
 395   accepted_socket->Disconnect();
 396   EXPECT_FALSE(accepted_socket->IsConnected());
 397   EXPECT_FALSE(client_socket.IsConnected());
 398 }
 399
 400 }  // namespace
 401 }  // namespace net