unix_domain_client_socket_posix_unittest.cc 18 KB

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