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