OLD | NEW |
(Empty) | |
| 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 |
OLD | NEW |