tcp_socket_unittest.cc 65 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564
  1. // Copyright 2018 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 <stdint.h>
  5. #include <utility>
  6. #include <vector>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/check_op.h"
  10. #include "base/location.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/run_loop.h"
  13. #include "base/test/bind.h"
  14. #include "base/test/task_environment.h"
  15. #include "base/threading/thread.h"
  16. #include "build/build_config.h"
  17. #include "mojo/public/cpp/bindings/pending_receiver.h"
  18. #include "mojo/public/cpp/bindings/pending_remote.h"
  19. #include "mojo/public/cpp/bindings/remote.h"
  20. #include "mojo/public/cpp/bindings/unique_receiver_set.h"
  21. #include "mojo/public/cpp/system/data_pipe_utils.h"
  22. #include "mojo/public/cpp/system/simple_watcher.h"
  23. #include "net/base/completion_once_callback.h"
  24. #include "net/base/net_errors.h"
  25. #include "net/base/test_completion_callback.h"
  26. #include "net/socket/server_socket.h"
  27. #include "net/socket/socket_test_util.h"
  28. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  29. #include "net/url_request/url_request_context.h"
  30. #include "net/url_request/url_request_context_builder.h"
  31. #include "net/url_request/url_request_test_util.h"
  32. #include "services/network/mojo_socket_test_util.h"
  33. #include "services/network/public/mojom/network_service.mojom.h"
  34. #include "services/network/public/mojom/tcp_socket.mojom-forward.h"
  35. #include "services/network/public/mojom/tcp_socket.mojom.h"
  36. #include "services/network/public/mojom/tls_socket.mojom.h"
  37. #include "services/network/public/mojom/udp_socket.mojom.h"
  38. #include "services/network/socket_factory.h"
  39. #include "services/network/tcp_connected_socket.h"
  40. #include "services/network/tcp_server_socket.h"
  41. #include "testing/gtest/include/gtest/gtest.h"
  42. #if BUILDFLAG(IS_MAC)
  43. #include "base/mac/mac_util.h"
  44. #endif
  45. namespace network {
  46. namespace {
  47. // A mock ServerSocket that completes Accept() using a specified result.
  48. class MockServerSocket : public net::ServerSocket {
  49. public:
  50. explicit MockServerSocket(
  51. std::vector<std::unique_ptr<net::StaticSocketDataProvider>>
  52. data_providers)
  53. : data_providers_(std::move(data_providers)) {}
  54. ~MockServerSocket() override {}
  55. // net::ServerSocket implementation.
  56. int Listen(const net::IPEndPoint& address, int backlog) override {
  57. return net::OK;
  58. }
  59. int GetLocalAddress(net::IPEndPoint* address) const override {
  60. return net::OK;
  61. }
  62. int Accept(std::unique_ptr<net::StreamSocket>* socket,
  63. net::CompletionOnceCallback callback) override {
  64. DCHECK(accept_callback_.is_null());
  65. if (accept_result_ == net::OK && mode_ == net::SYNCHRONOUS)
  66. *socket = CreateMockAcceptSocket();
  67. if (mode_ == net::ASYNC || accept_result_ == net::ERR_IO_PENDING) {
  68. accept_socket_ = socket;
  69. accept_callback_ = std::move(callback);
  70. }
  71. run_loop_.Quit();
  72. if (mode_ == net::ASYNC) {
  73. base::ThreadTaskRunnerHandle::Get()->PostTask(
  74. FROM_HERE, base::BindOnce(&MockServerSocket::CompleteAccept,
  75. base::Unretained(this), accept_result_));
  76. return net::ERR_IO_PENDING;
  77. }
  78. return accept_result_;
  79. }
  80. void SetAcceptResult(net::IoMode mode, int result) {
  81. // It doesn't make sense to return net::ERR_IO_PENDING asynchronously.
  82. DCHECK(!(mode == net::ASYNC && result == net::ERR_IO_PENDING));
  83. mode_ = mode;
  84. accept_result_ = result;
  85. }
  86. void WaitForFirstAccept() { run_loop_.Run(); }
  87. void CompleteAccept(int result) {
  88. DCHECK(!accept_callback_.is_null());
  89. DCHECK_NE(net::ERR_IO_PENDING, result);
  90. *accept_socket_ = CreateMockAcceptSocket();
  91. accept_socket_ = nullptr;
  92. std::move(accept_callback_).Run(result);
  93. }
  94. private:
  95. std::unique_ptr<net::StreamSocket> CreateMockAcceptSocket() {
  96. DCHECK_GT(data_providers_.size(), next_data_provider_index_);
  97. auto mock_socket = std::make_unique<net::MockTCPClientSocket>(
  98. net::AddressList(), nullptr /*netlog*/,
  99. data_providers_[next_data_provider_index_++].get());
  100. mock_socket->set_enable_read_if_ready(true);
  101. EXPECT_EQ(net::OK, mock_socket->Connect(base::DoNothing()));
  102. return std::move(mock_socket);
  103. }
  104. net::IoMode mode_ = net::SYNCHRONOUS;
  105. int accept_result_ = net::OK;
  106. net::CompletionOnceCallback accept_callback_;
  107. raw_ptr<std::unique_ptr<net::StreamSocket>> accept_socket_;
  108. base::RunLoop run_loop_;
  109. std::vector<std::unique_ptr<net::StaticSocketDataProvider>> data_providers_;
  110. size_t next_data_provider_index_ = 0;
  111. };
  112. // A MockServerSocket that fails at GetLocalAddress().
  113. class FailingServerSocket : public MockServerSocket {
  114. public:
  115. FailingServerSocket()
  116. : MockServerSocket(
  117. std::vector<std::unique_ptr<net::StaticSocketDataProvider>>()) {}
  118. ~FailingServerSocket() override {}
  119. int GetLocalAddress(net::IPEndPoint* address) const override {
  120. return net::ERR_FAILED;
  121. }
  122. };
  123. // A server implemented using mojom::TCPServerSocket. It owns the server socket
  124. // pointer and as well as client connections. SendData() and StartReading()
  125. // operate on the newest client connection.
  126. class TestServer {
  127. public:
  128. TestServer()
  129. : TestServer(net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0)) {}
  130. explicit TestServer(const net::IPEndPoint& server_addr)
  131. : url_request_context_(
  132. net::CreateTestURLRequestContextBuilder()->Build()),
  133. factory_(nullptr, url_request_context_.get()),
  134. readable_handle_watcher_(FROM_HERE,
  135. mojo::SimpleWatcher::ArmingPolicy::AUTOMATIC),
  136. server_addr_(server_addr) {}
  137. ~TestServer() {}
  138. void Start(uint32_t backlog) {
  139. int net_error = net::ERR_FAILED;
  140. base::RunLoop run_loop;
  141. factory_.CreateTCPServerSocket(
  142. server_addr_, backlog, TRAFFIC_ANNOTATION_FOR_TESTS,
  143. server_socket_.BindNewPipeAndPassReceiver(),
  144. base::BindLambdaForTesting(
  145. [&](int result, const absl::optional<net::IPEndPoint>& local_addr) {
  146. net_error = result;
  147. if (local_addr)
  148. server_addr_ = local_addr.value();
  149. run_loop.Quit();
  150. }));
  151. run_loop.Run();
  152. EXPECT_EQ(net::OK, net_error);
  153. }
  154. // Accepts one connection. Upon successful completion, |callback| will be
  155. // invoked.
  156. void AcceptOneConnection(net::CompletionOnceCallback callback) {
  157. server_socket_->Accept(
  158. mojo::NullRemote(),
  159. base::BindOnce(&TestServer::OnAccept, base::Unretained(this),
  160. std::move(callback)));
  161. }
  162. // Sends data over the most recent connection that is established.
  163. void SendData(const std::string& msg) {
  164. EXPECT_TRUE(mojo::BlockingCopyFromString(msg, server_socket_send_handle_));
  165. }
  166. // Starts reading. Can be called multiple times. It cancels any previous
  167. // StartReading(). Once |expected_contents| is read, |callback| will be
  168. // invoked. If an error occurs or the pipe is broken before read can
  169. // complete, |callback| will be run, but ADD_FAILURE() will be called.
  170. void StartReading(const std::string& expected_contents,
  171. base::OnceClosure callback) {
  172. readable_handle_watcher_.Cancel();
  173. received_contents_.clear();
  174. expected_contents_ = expected_contents;
  175. read_callback_ = std::move(callback);
  176. readable_handle_watcher_.Watch(
  177. server_socket_receive_handle_.get(),
  178. MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED,
  179. base::BindRepeating(&TestServer::OnReadable, base::Unretained(this)));
  180. }
  181. void DestroyServerSocket() { server_socket_.reset(); }
  182. const net::IPEndPoint& server_addr() { return server_addr_; }
  183. mojom::TCPConnectedSocket* most_recent_connected_socket() {
  184. return connected_sockets_.back().get();
  185. }
  186. private:
  187. void OnAccept(net::CompletionOnceCallback callback,
  188. int result,
  189. const absl::optional<net::IPEndPoint>& remote_addr,
  190. mojo::PendingRemote<mojom::TCPConnectedSocket> connected_socket,
  191. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  192. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  193. connected_sockets_.push_back(
  194. mojo::Remote<mojom::TCPConnectedSocket>(std::move(connected_socket)));
  195. server_socket_receive_handle_ = std::move(receive_pipe_handle);
  196. server_socket_send_handle_ = std::move(send_pipe_handle);
  197. std::move(callback).Run(result);
  198. }
  199. void OnReadable(MojoResult result) {
  200. if (result != MOJO_RESULT_OK) {
  201. ADD_FAILURE() << "Unexpected broken pipe with error: " << result;
  202. EXPECT_EQ(expected_contents_, received_contents_);
  203. std::move(read_callback_).Run();
  204. return;
  205. }
  206. char buffer[16];
  207. uint32_t read_size = sizeof(buffer);
  208. result = server_socket_receive_handle_->ReadData(buffer, &read_size,
  209. MOJO_READ_DATA_FLAG_NONE);
  210. if (result == MOJO_RESULT_SHOULD_WAIT)
  211. return;
  212. if (result != MOJO_RESULT_OK) {
  213. ADD_FAILURE() << "Unexpected read error: " << result;
  214. EXPECT_EQ(expected_contents_, received_contents_);
  215. std::move(read_callback_).Run();
  216. return;
  217. }
  218. received_contents_.append(buffer, read_size);
  219. if (received_contents_.size() == expected_contents_.size()) {
  220. EXPECT_EQ(expected_contents_, received_contents_);
  221. std::move(read_callback_).Run();
  222. }
  223. }
  224. std::unique_ptr<net::URLRequestContext> url_request_context_;
  225. SocketFactory factory_;
  226. mojo::Remote<mojom::TCPServerSocket> server_socket_;
  227. std::vector<mojo::Remote<mojom::TCPConnectedSocket>> connected_sockets_;
  228. mojo::ScopedDataPipeConsumerHandle server_socket_receive_handle_;
  229. mojo::ScopedDataPipeProducerHandle server_socket_send_handle_;
  230. mojo::SimpleWatcher readable_handle_watcher_;
  231. net::IPEndPoint server_addr_;
  232. std::string expected_contents_;
  233. base::OnceClosure read_callback_;
  234. std::string received_contents_;
  235. };
  236. } // namespace
  237. class TCPSocketTest : public testing::Test {
  238. public:
  239. TCPSocketTest()
  240. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO) {}
  241. TCPSocketTest(const TCPSocketTest&) = delete;
  242. TCPSocketTest& operator=(const TCPSocketTest&) = delete;
  243. ~TCPSocketTest() override {}
  244. void Init(net::ClientSocketFactory* mock_client_socket_factory) {
  245. auto context_builder = net::CreateTestURLRequestContextBuilder();
  246. context_builder->set_client_socket_factory_for_testing(
  247. mock_client_socket_factory);
  248. url_request_context_ = context_builder->Build();
  249. factory_ = std::make_unique<SocketFactory>(nullptr /*net_log*/,
  250. url_request_context_.get());
  251. }
  252. void SetUp() override { Init(nullptr); }
  253. // Reads |num_bytes| from |handle| or reads until an error occurs. Returns the
  254. // bytes read as a string.
  255. std::string Read(mojo::ScopedDataPipeConsumerHandle* handle,
  256. size_t num_bytes) {
  257. std::string received_contents;
  258. while (received_contents.size() < num_bytes) {
  259. base::RunLoop().RunUntilIdle();
  260. std::vector<char> buffer(num_bytes);
  261. uint32_t read_size = static_cast<uint32_t>(num_bytes);
  262. MojoResult result = handle->get().ReadData(buffer.data(), &read_size,
  263. MOJO_READ_DATA_FLAG_NONE);
  264. if (result == MOJO_RESULT_SHOULD_WAIT)
  265. continue;
  266. if (result != MOJO_RESULT_OK)
  267. return received_contents;
  268. received_contents.append(buffer.data(), read_size);
  269. }
  270. return received_contents;
  271. }
  272. // Creates a TCPServerSocket with the mock server socket, |socket|.
  273. void CreateServerSocketWithMockSocket(
  274. uint32_t backlog,
  275. mojo::PendingReceiver<mojom::TCPServerSocket> receiver,
  276. std::unique_ptr<net::ServerSocket> socket) {
  277. auto server_socket_impl = std::make_unique<TCPServerSocket>(
  278. factory_.get(), nullptr /*netlog*/, TRAFFIC_ANNOTATION_FOR_TESTS);
  279. server_socket_impl->SetSocketForTest(std::move(socket));
  280. net::IPEndPoint local_addr;
  281. EXPECT_EQ(net::OK,
  282. server_socket_impl->Listen(local_addr, backlog, &local_addr));
  283. tcp_server_socket_receiver_.Add(std::move(server_socket_impl),
  284. std::move(receiver));
  285. }
  286. int CreateTCPConnectedSocketSync(
  287. mojo::PendingReceiver<mojom::TCPConnectedSocket> receiver,
  288. mojo::PendingRemote<mojom::SocketObserver> observer,
  289. const absl::optional<net::IPEndPoint>& local_addr,
  290. const net::IPEndPoint& remote_addr,
  291. mojo::ScopedDataPipeConsumerHandle* receive_pipe_handle_out,
  292. mojo::ScopedDataPipeProducerHandle* send_pipe_handle_out,
  293. mojom::TCPConnectedSocketOptionsPtr tcp_connected_socket_options =
  294. nullptr) {
  295. return CreateTCPConnectedSocketSync(
  296. std::move(receiver), std::move(observer), local_addr,
  297. net::AddressList(remote_addr), receive_pipe_handle_out,
  298. send_pipe_handle_out, std::move(tcp_connected_socket_options));
  299. }
  300. int CreateTCPConnectedSocketSync(
  301. mojo::PendingReceiver<mojom::TCPConnectedSocket> receiver,
  302. mojo::PendingRemote<mojom::SocketObserver> observer,
  303. const absl::optional<net::IPEndPoint>& local_addr,
  304. const net::AddressList& remote_addr_list,
  305. mojo::ScopedDataPipeConsumerHandle* receive_pipe_handle_out,
  306. mojo::ScopedDataPipeProducerHandle* send_pipe_handle_out,
  307. mojom::TCPConnectedSocketOptionsPtr tcp_connected_socket_options =
  308. nullptr) {
  309. base::RunLoop run_loop;
  310. int net_error = net::ERR_FAILED;
  311. factory_->CreateTCPConnectedSocket(
  312. local_addr, remote_addr_list, std::move(tcp_connected_socket_options),
  313. TRAFFIC_ANNOTATION_FOR_TESTS, std::move(receiver), std::move(observer),
  314. base::BindLambdaForTesting(
  315. [&](int result,
  316. const absl::optional<net::IPEndPoint>& actual_local_addr,
  317. const absl::optional<net::IPEndPoint>& peer_addr,
  318. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  319. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  320. net_error = result;
  321. if (result == net::OK) {
  322. EXPECT_NE(0, actual_local_addr.value().port());
  323. if (remote_addr_list.size() == 1) {
  324. EXPECT_EQ(remote_addr_list.front(), peer_addr.value());
  325. }
  326. }
  327. *receive_pipe_handle_out = std::move(receive_pipe_handle);
  328. *send_pipe_handle_out = std::move(send_pipe_handle);
  329. run_loop.Quit();
  330. }));
  331. run_loop.Run();
  332. return net_error;
  333. }
  334. TestSocketObserver* observer() { return &test_observer_; }
  335. SocketFactory* factory() { return factory_.get(); }
  336. private:
  337. base::test::TaskEnvironment task_environment_;
  338. std::unique_ptr<net::URLRequestContext> url_request_context_;
  339. std::unique_ptr<SocketFactory> factory_;
  340. TestSocketObserver test_observer_;
  341. mojo::UniqueReceiverSet<mojom::TCPServerSocket> tcp_server_socket_receiver_;
  342. };
  343. TEST_F(TCPSocketTest, ReadAndWrite) {
  344. const struct TestData {
  345. absl::optional<net::IPEndPoint> client_addr;
  346. net::IPEndPoint server_addr;
  347. } kTestCases[] = {
  348. {absl::nullopt, net::IPEndPoint(net::IPAddress::IPv4Localhost(), 0)},
  349. {absl::nullopt, net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0)},
  350. {net::IPEndPoint(net::IPAddress::IPv4Localhost(), 0),
  351. net::IPEndPoint(net::IPAddress::IPv4Localhost(), 0)},
  352. {net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0),
  353. net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0)},
  354. };
  355. for (auto test : kTestCases) {
  356. TestServer server(test.server_addr);
  357. server.Start(1 /*backlog*/);
  358. net::TestCompletionCallback accept_callback;
  359. server.AcceptOneConnection(accept_callback.callback());
  360. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  361. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  362. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  363. EXPECT_EQ(net::OK, CreateTCPConnectedSocketSync(
  364. client_socket.BindNewPipeAndPassReceiver(),
  365. mojo::NullRemote() /*observer*/, test.client_addr,
  366. server.server_addr(), &client_socket_receive_handle,
  367. &client_socket_send_handle));
  368. ASSERT_EQ(net::OK, accept_callback.WaitForResult());
  369. // Test sending data from server to client.
  370. const char kTestMsg[] = "hello";
  371. server.SendData(kTestMsg);
  372. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, strlen(kTestMsg)));
  373. // Test sending data from client to server.
  374. base::RunLoop read_run_loop;
  375. server.StartReading(kTestMsg, read_run_loop.QuitClosure());
  376. EXPECT_TRUE(
  377. mojo::BlockingCopyFromString(kTestMsg, client_socket_send_handle));
  378. read_run_loop.Run();
  379. }
  380. }
  381. TEST_F(TCPSocketTest, CannotConnectToWrongInterface) {
  382. const struct TestData {
  383. net::IPEndPoint client_addr;
  384. net::IPEndPoint server_addr;
  385. } kTestCases[] = {
  386. {net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0),
  387. net::IPEndPoint(net::IPAddress::IPv4Localhost(), 0)},
  388. {net::IPEndPoint(net::IPAddress::IPv4Localhost(), 0),
  389. net::IPEndPoint(net::IPAddress::IPv6Localhost(), 0)},
  390. };
  391. for (auto test : kTestCases) {
  392. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  393. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  394. TestServer server(test.server_addr);
  395. server.Start(1 /*backlog*/);
  396. net::TestCompletionCallback accept_callback;
  397. server.AcceptOneConnection(accept_callback.callback());
  398. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  399. int result = CreateTCPConnectedSocketSync(
  400. client_socket.BindNewPipeAndPassReceiver(),
  401. mojo::NullRemote() /*observer*/, test.client_addr, server.server_addr(),
  402. &client_socket_receive_handle, &client_socket_send_handle);
  403. // Both net::ERR_INVALID_ARGUMENT and net::ERR_ADDRESS_UNREACHABLE can be
  404. // returned. On Linux, for eample, the former is returned when talking ipv4
  405. // to a ipv6 remote, and the latter is returned when talking ipv6 to a ipv4
  406. // remote. net::ERR_CONNECTION_FAILED is returned on Windows.
  407. EXPECT_TRUE(result == net::ERR_CONNECTION_FAILED ||
  408. result == net::ERR_INVALID_ARGUMENT ||
  409. result == net::ERR_ADDRESS_UNREACHABLE)
  410. << "actual result: " << result;
  411. }
  412. }
  413. TEST_F(TCPSocketTest, ServerReceivesMultipleAccept) {
  414. uint32_t backlog = 10;
  415. TestServer server;
  416. server.Start(backlog);
  417. std::vector<std::unique_ptr<net::TestCompletionCallback>> accept_callbacks;
  418. // Issue |backlog| Accepts(), so the queue is filled up.
  419. for (size_t i = 0; i < backlog; ++i) {
  420. auto callback = std::make_unique<net::TestCompletionCallback>();
  421. server.AcceptOneConnection(callback->callback());
  422. accept_callbacks.push_back(std::move(callback));
  423. }
  424. // Accept() beyond the queue size should fail immediately.
  425. net::TestCompletionCallback callback;
  426. server.AcceptOneConnection(callback.callback());
  427. EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, callback.WaitForResult());
  428. // After handling incoming connections, all callbacks should now complete.
  429. std::vector<mojo::Remote<mojom::TCPConnectedSocket>> client_sockets;
  430. for (size_t i = 0; i < backlog; ++i) {
  431. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  432. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  433. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  434. EXPECT_EQ(net::OK,
  435. CreateTCPConnectedSocketSync(
  436. client_socket.BindNewPipeAndPassReceiver(),
  437. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  438. server.server_addr(), &client_socket_receive_handle,
  439. &client_socket_send_handle));
  440. client_sockets.push_back(std::move(client_socket));
  441. }
  442. for (const auto& accept_callback : accept_callbacks) {
  443. EXPECT_EQ(net::OK, accept_callback->WaitForResult());
  444. }
  445. }
  446. // Check that accepted sockets can't be upgraded to TLS, since UpgradeToTLS only
  447. // supports the client side of a TLS handshake.
  448. TEST_F(TCPSocketTest, AcceptedSocketCantUpgradeToTLS) {
  449. TestServer server;
  450. server.Start(1 /* backlog */);
  451. net::TestCompletionCallback callback;
  452. server.AcceptOneConnection(callback.callback());
  453. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  454. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  455. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  456. EXPECT_EQ(net::OK,
  457. CreateTCPConnectedSocketSync(
  458. client_socket.BindNewPipeAndPassReceiver(),
  459. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  460. server.server_addr(), &client_socket_receive_handle,
  461. &client_socket_send_handle));
  462. EXPECT_EQ(net::OK, callback.WaitForResult());
  463. // Consumers generally close these before attempting to upgrade the socket,
  464. // since TCPConnectedSocket waits for the pipes to close before upgrading the
  465. // connection.
  466. client_socket_receive_handle.reset();
  467. client_socket_send_handle.reset();
  468. base::RunLoop run_loop;
  469. mojo::Remote<mojom::TLSClientSocket> tls_client_socket;
  470. server.most_recent_connected_socket()->UpgradeToTLS(
  471. net::HostPortPair("foopy", 443), nullptr /* options */,
  472. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS),
  473. tls_client_socket.BindNewPipeAndPassReceiver(),
  474. mojo::NullRemote() /* observer */,
  475. base::BindLambdaForTesting(
  476. [&](int net_error,
  477. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  478. mojo::ScopedDataPipeProducerHandle send_pipe_handle,
  479. const absl::optional<net::SSLInfo>& ssl_info) {
  480. EXPECT_EQ(net::ERR_NOT_IMPLEMENTED, net_error);
  481. run_loop.Quit();
  482. }));
  483. }
  484. // Tests that if a socket is closed, the other side can observe that the pipes
  485. // are broken.
  486. TEST_F(TCPSocketTest, SocketClosed) {
  487. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  488. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  489. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  490. const char kTestMsg[] = "hello";
  491. auto server = std::make_unique<TestServer>();
  492. server->Start(1 /*backlog*/);
  493. net::TestCompletionCallback accept_callback;
  494. server->AcceptOneConnection(accept_callback.callback());
  495. EXPECT_EQ(net::OK,
  496. CreateTCPConnectedSocketSync(
  497. client_socket.BindNewPipeAndPassReceiver(),
  498. observer()->GetObserverRemote(), absl::nullopt /*local_addr*/,
  499. server->server_addr(), &client_socket_receive_handle,
  500. &client_socket_send_handle));
  501. ASSERT_EQ(net::OK, accept_callback.WaitForResult());
  502. // Send some data from server to client.
  503. server->SendData(kTestMsg);
  504. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, strlen(kTestMsg)));
  505. // Resetting the |server| destroys the TCPConnectedSocket ptr owned by the
  506. // server.
  507. server = nullptr;
  508. // Read should return EOF.
  509. EXPECT_EQ("", Read(&client_socket_receive_handle, 1));
  510. // Read from |client_socket_receive_handle| again should return that the pipe
  511. // is broken.
  512. char buffer[16];
  513. uint32_t read_size = sizeof(buffer);
  514. MojoResult mojo_result = client_socket_receive_handle->ReadData(
  515. buffer, &read_size, MOJO_READ_DATA_FLAG_NONE);
  516. ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, mojo_result);
  517. EXPECT_TRUE(client_socket_receive_handle->QuerySignalsState().peer_closed());
  518. // Send pipe should be closed.
  519. while (true) {
  520. base::RunLoop().RunUntilIdle();
  521. uint32_t size = strlen(kTestMsg);
  522. MojoResult r = client_socket_send_handle->WriteData(
  523. kTestMsg, &size, MOJO_WRITE_DATA_FLAG_ALL_OR_NONE);
  524. if (r == MOJO_RESULT_SHOULD_WAIT)
  525. continue;
  526. if (r == MOJO_RESULT_FAILED_PRECONDITION)
  527. break;
  528. }
  529. EXPECT_TRUE(client_socket_send_handle->QuerySignalsState().peer_closed());
  530. int result = observer()->WaitForWriteError();
  531. bool result_ok = result == net::ERR_CONNECTION_RESET ||
  532. result == net::ERR_CONNECTION_ABORTED;
  533. #if BUILDFLAG(IS_MAC)
  534. // On some macOS kernels, send() on a closing TCP socket can return
  535. // EPROTOTYPE, which is unknown to the net stack and gets mapped to
  536. // net::ERR_FAILED.
  537. // See https://crbug.com/1034991
  538. result_ok |= result == net::ERR_FAILED;
  539. #endif
  540. EXPECT_TRUE(result_ok) << "actual result: " << result;
  541. }
  542. TEST_F(TCPSocketTest, ReadPipeClosed) {
  543. const char kTestMsg[] = "hello";
  544. TestServer server;
  545. server.Start(1 /*backlog*/);
  546. net::TestCompletionCallback accept_callback;
  547. server.AcceptOneConnection(accept_callback.callback());
  548. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  549. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  550. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  551. EXPECT_EQ(net::OK,
  552. CreateTCPConnectedSocketSync(
  553. client_socket.BindNewPipeAndPassReceiver(),
  554. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  555. server.server_addr(), &client_socket_receive_handle,
  556. &client_socket_send_handle));
  557. ASSERT_EQ(net::OK, accept_callback.WaitForResult());
  558. // Close |client_socket_receive_handle|. The socket should remain open.
  559. client_socket_receive_handle.reset();
  560. // Send should proceed as normal.
  561. base::RunLoop read_run_loop;
  562. server.StartReading(kTestMsg, read_run_loop.QuitClosure());
  563. EXPECT_TRUE(
  564. mojo::BlockingCopyFromString(kTestMsg, client_socket_send_handle));
  565. read_run_loop.Run();
  566. }
  567. TEST_F(TCPSocketTest, WritePipeClosed) {
  568. const char kTestMsg[] = "hello";
  569. TestServer server;
  570. server.Start(1 /*backlog*/);
  571. net::TestCompletionCallback accept_callback;
  572. server.AcceptOneConnection(accept_callback.callback());
  573. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  574. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  575. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  576. EXPECT_EQ(net::OK,
  577. CreateTCPConnectedSocketSync(
  578. client_socket.BindNewPipeAndPassReceiver(),
  579. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  580. server.server_addr(), &client_socket_receive_handle,
  581. &client_socket_send_handle));
  582. ASSERT_EQ(net::OK, accept_callback.WaitForResult());
  583. // Close |client_socket_send_handle|. The socket should remain open.
  584. client_socket_send_handle.reset();
  585. // Receive should proceed as normal.
  586. server.SendData(kTestMsg);
  587. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, strlen(kTestMsg)));
  588. }
  589. // Tests that if the server socket is destroyed, any connected sockets that it
  590. // handed out remain alive.
  591. TEST_F(TCPSocketTest, ServerSocketClosedAcceptedSocketAlive) {
  592. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  593. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  594. const char kTestMsg[] = "hello";
  595. TestServer server;
  596. server.Start(1 /*backlog*/);
  597. net::TestCompletionCallback accept_callback;
  598. server.AcceptOneConnection(accept_callback.callback());
  599. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  600. EXPECT_EQ(net::OK,
  601. CreateTCPConnectedSocketSync(
  602. client_socket.BindNewPipeAndPassReceiver(),
  603. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  604. server.server_addr(), &client_socket_receive_handle,
  605. &client_socket_send_handle));
  606. ASSERT_EQ(net::OK, accept_callback.WaitForResult());
  607. // Now destroys the server socket.
  608. server.DestroyServerSocket();
  609. base::RunLoop().RunUntilIdle();
  610. // Sending and receiving should still work.
  611. server.SendData(kTestMsg);
  612. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, strlen(kTestMsg)));
  613. base::RunLoop read_run_loop;
  614. server.StartReading(kTestMsg, read_run_loop.QuitClosure());
  615. EXPECT_TRUE(
  616. mojo::BlockingCopyFromString(kTestMsg, client_socket_send_handle));
  617. read_run_loop.Run();
  618. }
  619. // Tests both async and sync cases.
  620. class TCPSocketWithMockSocketTest
  621. : public TCPSocketTest,
  622. public ::testing::WithParamInterface<net::IoMode> {
  623. public:
  624. void SetUp() override {
  625. mock_client_socket_factory_.set_enable_read_if_ready(true);
  626. Init(&mock_client_socket_factory_);
  627. }
  628. net::MockClientSocketFactory mock_client_socket_factory_;
  629. };
  630. INSTANTIATE_TEST_SUITE_P(All,
  631. TCPSocketWithMockSocketTest,
  632. testing::Values(net::SYNCHRONOUS, net::ASYNC));
  633. // Tests that a server socket handles Accept() correctly when the underlying
  634. // implementation completes Accept() in sync and async mode.
  635. TEST_P(TCPSocketWithMockSocketTest,
  636. ServerAcceptClientConnectionWithMockSocket) {
  637. net::IoMode accept_mode = GetParam();
  638. const uint32_t kBacklog = 10;
  639. const net::MockRead kReads[] = {
  640. net::MockRead(net::ASYNC, net::ERR_IO_PENDING)};
  641. std::vector<std::unique_ptr<net::StaticSocketDataProvider>> data_providers;
  642. for (size_t i = 0; i < kBacklog + 1; ++i) {
  643. auto provider = std::make_unique<net::StaticSocketDataProvider>(
  644. kReads, base::span<net::MockWrite>());
  645. provider->set_connect_data(net::MockConnect(net::SYNCHRONOUS, net::OK));
  646. data_providers.push_back(std::move(provider));
  647. }
  648. auto mock_server_socket =
  649. std::make_unique<MockServerSocket>(std::move(data_providers));
  650. MockServerSocket* mock_server_socket_raw = mock_server_socket.get();
  651. mojo::Remote<mojom::TCPServerSocket> server_socket;
  652. // Use a mock socket to control net::ServerSocket::Accept() behavior.
  653. CreateServerSocketWithMockSocket(kBacklog,
  654. server_socket.BindNewPipeAndPassReceiver(),
  655. std::move(mock_server_socket));
  656. // Complete first Accept() using manual completion via CompleteAccept().
  657. mock_server_socket_raw->SetAcceptResult(net::SYNCHRONOUS,
  658. net::ERR_IO_PENDING);
  659. std::vector<std::unique_ptr<net::TestCompletionCallback>> accept_callbacks;
  660. for (size_t i = 0; i < kBacklog; ++i) {
  661. auto callback = std::make_unique<net::TestCompletionCallback>();
  662. server_socket->Accept(
  663. mojo::NullRemote(),
  664. base::BindOnce(
  665. [](net::CompletionOnceCallback callback, int result,
  666. const absl::optional<net::IPEndPoint>& remote_addr,
  667. mojo::PendingRemote<mojom::TCPConnectedSocket> connected_socket,
  668. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  669. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  670. std::move(callback).Run(result);
  671. },
  672. callback->callback()));
  673. accept_callbacks.push_back(std::move(callback));
  674. }
  675. mock_server_socket_raw->WaitForFirstAccept();
  676. mock_server_socket_raw->SetAcceptResult(accept_mode, net::OK);
  677. mock_server_socket_raw->CompleteAccept(net::OK);
  678. // First net::ServerSocket::Accept() will complete asynchronously
  679. // internally. Other queued Accept() will complete
  680. // synchronously/asynchronously depending on |mode| internally.
  681. for (const auto& callback : accept_callbacks) {
  682. EXPECT_EQ(net::OK, callback->WaitForResult());
  683. }
  684. // New Accept() should complete synchronously internally. Make sure this is
  685. // okay.
  686. auto callback = std::make_unique<net::TestCompletionCallback>();
  687. server_socket->Accept(
  688. mojo::NullRemote(),
  689. base::BindOnce(
  690. [](net::CompletionOnceCallback callback, int result,
  691. const absl::optional<net::IPEndPoint>& remote_addr,
  692. mojo::PendingRemote<mojom::TCPConnectedSocket> connected_socket,
  693. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  694. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  695. std::move(callback).Run(result);
  696. },
  697. callback->callback()));
  698. EXPECT_EQ(net::OK, callback->WaitForResult());
  699. }
  700. // Tests that TCPServerSocket::Accept() is used with a non-null
  701. // SocketObserver and that the observer is invoked when a read error
  702. // occurs.
  703. TEST_P(TCPSocketWithMockSocketTest, ServerAcceptWithObserverReadError) {
  704. net::IoMode mode = GetParam();
  705. const net::MockRead kReadError[] = {net::MockRead(mode, net::ERR_TIMED_OUT)};
  706. std::vector<std::unique_ptr<net::StaticSocketDataProvider>> data_providers;
  707. auto provider = std::make_unique<net::StaticSocketDataProvider>(
  708. kReadError, base::span<net::MockWrite>());
  709. provider->set_connect_data(net::MockConnect(net::SYNCHRONOUS, net::OK));
  710. data_providers.push_back(std::move(provider));
  711. auto mock_server_socket =
  712. std::make_unique<MockServerSocket>(std::move(data_providers));
  713. mojo::Remote<mojom::TCPServerSocket> server_socket;
  714. CreateServerSocketWithMockSocket(1 /*backlog*/,
  715. server_socket.BindNewPipeAndPassReceiver(),
  716. std::move(mock_server_socket));
  717. auto callback = std::make_unique<net::TestCompletionCallback>();
  718. mojo::Remote<mojom::TCPConnectedSocket> connected_socket_result;
  719. mojo::ScopedDataPipeConsumerHandle receive_handle;
  720. mojo::ScopedDataPipeProducerHandle send_handle;
  721. server_socket->Accept(
  722. observer()->GetObserverRemote(),
  723. base::BindLambdaForTesting(
  724. [&](int result, const absl::optional<net::IPEndPoint>& remote_addr,
  725. mojo::PendingRemote<mojom::TCPConnectedSocket> connected_socket,
  726. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  727. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  728. callback->callback().Run(result);
  729. connected_socket_result.Bind(std::move(connected_socket));
  730. receive_handle = std::move(receive_pipe_handle);
  731. send_handle = std::move(send_pipe_handle);
  732. }));
  733. EXPECT_EQ(net::OK, callback->WaitForResult());
  734. base::RunLoop().RunUntilIdle();
  735. uint32_t read_size = 16;
  736. std::vector<char> buffer(read_size);
  737. MojoResult result = receive_handle->ReadData(buffer.data(), &read_size,
  738. MOJO_READ_DATA_FLAG_NONE);
  739. ASSERT_NE(MOJO_RESULT_OK, result);
  740. EXPECT_EQ(net::ERR_TIMED_OUT, observer()->WaitForReadError());
  741. }
  742. // Tests that TCPServerSocket::Accept() is used with a non-null SocketObserver
  743. // and that the observer is invoked when a write error occurs.
  744. TEST_P(TCPSocketWithMockSocketTest, ServerAcceptWithObserverWriteError) {
  745. net::IoMode mode = GetParam();
  746. const net::MockRead kReads[] = {net::MockRead(net::SYNCHRONOUS, net::OK)};
  747. const net::MockWrite kWriteError[] = {
  748. net::MockWrite(mode, net::ERR_TIMED_OUT)};
  749. std::vector<std::unique_ptr<net::StaticSocketDataProvider>> data_providers;
  750. std::unique_ptr<net::StaticSocketDataProvider> provider;
  751. provider =
  752. std::make_unique<net::StaticSocketDataProvider>(kReads, kWriteError);
  753. provider->set_connect_data(net::MockConnect(net::SYNCHRONOUS, net::OK));
  754. data_providers.push_back(std::move(provider));
  755. auto mock_server_socket =
  756. std::make_unique<MockServerSocket>(std::move(data_providers));
  757. mojo::Remote<mojom::TCPServerSocket> server_socket;
  758. CreateServerSocketWithMockSocket(1 /*backlog*/,
  759. server_socket.BindNewPipeAndPassReceiver(),
  760. std::move(mock_server_socket));
  761. auto callback = std::make_unique<net::TestCompletionCallback>();
  762. mojo::Remote<mojom::TCPConnectedSocket> connected_socket_result;
  763. mojo::ScopedDataPipeConsumerHandle receive_handle;
  764. mojo::ScopedDataPipeProducerHandle send_handle;
  765. server_socket->Accept(
  766. observer()->GetObserverRemote(),
  767. base::BindLambdaForTesting(
  768. [&](int result, const absl::optional<net::IPEndPoint>& remote_addr,
  769. mojo::PendingRemote<mojom::TCPConnectedSocket> connected_socket,
  770. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  771. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  772. callback->callback().Run(result);
  773. connected_socket_result.Bind(std::move(connected_socket));
  774. receive_handle = std::move(receive_pipe_handle);
  775. send_handle = std::move(send_pipe_handle);
  776. }));
  777. EXPECT_EQ(net::OK, callback->WaitForResult());
  778. const char kTestMsg[] = "abcdefghij";
  779. // Repeatedly write data to the |send_handle| until write fails.
  780. while (true) {
  781. base::RunLoop().RunUntilIdle();
  782. uint32_t num_bytes = strlen(kTestMsg);
  783. MojoResult result = send_handle->WriteData(&kTestMsg, &num_bytes,
  784. MOJO_WRITE_DATA_FLAG_NONE);
  785. if (result == MOJO_RESULT_SHOULD_WAIT)
  786. continue;
  787. if (result != MOJO_RESULT_OK)
  788. break;
  789. }
  790. EXPECT_EQ(net::ERR_TIMED_OUT, observer()->WaitForWriteError());
  791. }
  792. TEST_P(TCPSocketWithMockSocketTest, ReadAndWriteMultiple) {
  793. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  794. const char kTestMsg[] = "abcdefghij";
  795. const size_t kMsgSize = strlen(kTestMsg);
  796. const int kNumIterations = 3;
  797. std::vector<net::MockRead> reads;
  798. std::vector<net::MockWrite> writes;
  799. int sequence_number = 0;
  800. net::IoMode mode = GetParam();
  801. for (int j = 0; j < kNumIterations; ++j) {
  802. for (size_t i = 0; i < kMsgSize; ++i) {
  803. reads.push_back(net::MockRead(mode, &kTestMsg[i], 1, sequence_number++));
  804. }
  805. if (j == kNumIterations - 1) {
  806. reads.push_back(net::MockRead(mode, net::OK, sequence_number++));
  807. }
  808. for (size_t i = 0; i < kMsgSize; ++i) {
  809. writes.push_back(
  810. net::MockWrite(mode, &kTestMsg[i], 1, sequence_number++));
  811. }
  812. }
  813. net::StaticSocketDataProvider data_provider(reads, writes);
  814. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  815. data_provider.set_connect_data(
  816. net::MockConnect(net::SYNCHRONOUS, net::OK, server_addr));
  817. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  818. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  819. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  820. CreateTCPConnectedSocketSync(
  821. client_socket.BindNewPipeAndPassReceiver(),
  822. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  823. server_addr, &client_socket_receive_handle, &client_socket_send_handle);
  824. // Loop kNumIterations times to test that writes can follow reads, and reads
  825. // can follow writes.
  826. for (int j = 0; j < kNumIterations; ++j) {
  827. // Reading kMsgSize should coalesce the 1-byte mock reads.
  828. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, kMsgSize));
  829. // Write multiple times.
  830. for (size_t i = 0; i < kMsgSize; ++i) {
  831. uint32_t num_bytes = 1;
  832. EXPECT_EQ(MOJO_RESULT_OK,
  833. client_socket_send_handle->WriteData(
  834. &kTestMsg[i], &num_bytes, MOJO_WRITE_DATA_FLAG_NONE));
  835. // Flush the 1 byte write.
  836. base::RunLoop().RunUntilIdle();
  837. }
  838. }
  839. EXPECT_TRUE(data_provider.AllReadDataConsumed());
  840. EXPECT_TRUE(data_provider.AllWriteDataConsumed());
  841. }
  842. TEST_P(TCPSocketWithMockSocketTest, PartialStreamSocketWrite) {
  843. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  844. const char kTestMsg[] = "abcdefghij";
  845. const size_t kMsgSize = strlen(kTestMsg);
  846. const int kNumIterations = 3;
  847. std::vector<net::MockRead> reads;
  848. std::vector<net::MockWrite> writes;
  849. int sequence_number = 0;
  850. net::IoMode mode = GetParam();
  851. for (int j = 0; j < kNumIterations; ++j) {
  852. for (size_t i = 0; i < kMsgSize; ++i) {
  853. reads.push_back(net::MockRead(mode, &kTestMsg[i], 1, sequence_number++));
  854. }
  855. if (j == kNumIterations - 1) {
  856. reads.push_back(net::MockRead(mode, net::OK, sequence_number++));
  857. }
  858. for (size_t i = 0; i < kMsgSize; ++i) {
  859. writes.push_back(
  860. net::MockWrite(mode, &kTestMsg[i], 1, sequence_number++));
  861. }
  862. }
  863. net::StaticSocketDataProvider data_provider(reads, writes);
  864. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  865. data_provider.set_connect_data(
  866. net::MockConnect(net::SYNCHRONOUS, net::OK, server_addr));
  867. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  868. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  869. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  870. CreateTCPConnectedSocketSync(
  871. client_socket.BindNewPipeAndPassReceiver(),
  872. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  873. server_addr, &client_socket_receive_handle, &client_socket_send_handle);
  874. // Loop kNumIterations times to test that writes can follow reads, and reads
  875. // can follow writes.
  876. for (int j = 0; j < kNumIterations; ++j) {
  877. // Reading kMsgSize should coalesce the 1-byte mock reads.
  878. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, kMsgSize));
  879. // Write twice, each with kMsgSize/2 bytes which is bigger than the 1-byte
  880. // MockWrite(). This is to exercise that StreamSocket::Write() can do
  881. // partial write.
  882. uint32_t first_write_size = kMsgSize / 2;
  883. EXPECT_EQ(MOJO_RESULT_OK,
  884. client_socket_send_handle->WriteData(
  885. &kTestMsg[0], &first_write_size, MOJO_WRITE_DATA_FLAG_NONE));
  886. // Flush the kMsgSize/2 byte write.
  887. base::RunLoop().RunUntilIdle();
  888. uint32_t second_write_size = kMsgSize - first_write_size;
  889. EXPECT_EQ(MOJO_RESULT_OK,
  890. client_socket_send_handle->WriteData(&kTestMsg[first_write_size],
  891. &second_write_size,
  892. MOJO_WRITE_DATA_FLAG_NONE));
  893. // Flush the kMsgSize/2 byte write.
  894. base::RunLoop().RunUntilIdle();
  895. }
  896. EXPECT_TRUE(data_provider.AllReadDataConsumed());
  897. EXPECT_TRUE(data_provider.AllWriteDataConsumed());
  898. }
  899. TEST_P(TCPSocketWithMockSocketTest, ReadError) {
  900. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  901. net::IoMode mode = GetParam();
  902. net::MockRead reads[] = {net::MockRead(mode, net::ERR_FAILED)};
  903. const char kTestMsg[] = "hello!";
  904. net::MockWrite writes[] = {
  905. net::MockWrite(mode, kTestMsg, strlen(kTestMsg), 0)};
  906. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  907. net::StaticSocketDataProvider data_provider(reads, writes);
  908. data_provider.set_connect_data(
  909. net::MockConnect(net::SYNCHRONOUS, net::OK, server_addr));
  910. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  911. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  912. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  913. CreateTCPConnectedSocketSync(
  914. client_socket.BindNewPipeAndPassReceiver(),
  915. observer()->GetObserverRemote(), absl::nullopt /*local_addr*/,
  916. server_addr, &client_socket_receive_handle, &client_socket_send_handle);
  917. EXPECT_EQ("", Read(&client_socket_receive_handle, 1));
  918. EXPECT_EQ(net::ERR_FAILED, observer()->WaitForReadError());
  919. // Writes can proceed even though there is a read error.
  920. uint32_t num_bytes = strlen(kTestMsg);
  921. EXPECT_EQ(MOJO_RESULT_OK,
  922. client_socket_send_handle->WriteData(&kTestMsg, &num_bytes,
  923. MOJO_WRITE_DATA_FLAG_NONE));
  924. base::RunLoop().RunUntilIdle();
  925. EXPECT_TRUE(data_provider.AllReadDataConsumed());
  926. EXPECT_TRUE(data_provider.AllWriteDataConsumed());
  927. }
  928. TEST_P(TCPSocketWithMockSocketTest, WriteError) {
  929. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  930. net::IoMode mode = GetParam();
  931. const char kTestMsg[] = "hello!";
  932. // The first MockRead needs to complete asynchronously because otherwise it
  933. // can't be paused to happen after the MockWrite.
  934. net::MockRead reads[] = {
  935. net::MockRead(net::ASYNC, kTestMsg, strlen(kTestMsg), 1),
  936. net::MockRead(mode, net::OK, 2)};
  937. net::MockWrite writes[] = {net::MockWrite(mode, net::ERR_FAILED, 0)};
  938. net::SequencedSocketData data_provider(reads, writes);
  939. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  940. data_provider.set_connect_data(
  941. net::MockConnect(net::SYNCHRONOUS, net::OK, server_addr));
  942. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  943. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  944. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  945. CreateTCPConnectedSocketSync(
  946. client_socket.BindNewPipeAndPassReceiver(),
  947. observer()->GetObserverRemote(), absl::nullopt /*local_addr*/,
  948. server_addr, &client_socket_receive_handle, &client_socket_send_handle);
  949. uint32_t num_bytes = strlen(kTestMsg);
  950. EXPECT_EQ(MOJO_RESULT_OK,
  951. client_socket_send_handle->WriteData(&kTestMsg, &num_bytes,
  952. MOJO_WRITE_DATA_FLAG_NONE));
  953. EXPECT_EQ(net::ERR_FAILED, observer()->WaitForWriteError());
  954. // Reads can proceed even though there is a read error.
  955. EXPECT_EQ(kTestMsg, Read(&client_socket_receive_handle, strlen(kTestMsg)));
  956. base::RunLoop().RunUntilIdle();
  957. EXPECT_TRUE(data_provider.AllReadDataConsumed());
  958. EXPECT_TRUE(data_provider.AllWriteDataConsumed());
  959. }
  960. TEST_P(TCPSocketWithMockSocketTest, InitialTCPConnectedSocketOptions) {
  961. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  962. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  963. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  964. std::vector<mojom::TCPKeepAliveOptionsPtr> keep_alive_options_list;
  965. keep_alive_options_list.emplace_back(nullptr);
  966. keep_alive_options_list.emplace_back(absl::in_place, false, 0U);
  967. keep_alive_options_list.emplace_back(absl::in_place, true, 100U);
  968. for (int receive_buffer_size :
  969. {-1, 0, 1024, TCPConnectedSocket::kMaxBufferSize,
  970. TCPConnectedSocket::kMaxBufferSize + 1}) {
  971. for (int send_buffer_size :
  972. {-1, 0, 2048, TCPConnectedSocket::kMaxBufferSize,
  973. TCPConnectedSocket::kMaxBufferSize + 1}) {
  974. for (int no_delay : {false, true}) {
  975. for (const auto& keep_alive_options : keep_alive_options_list) {
  976. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  977. net::StaticSocketDataProvider data_provider;
  978. data_provider.set_connect_data(
  979. net::MockConnect(GetParam(), net::OK, server_addr));
  980. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  981. mojom::TCPConnectedSocketOptionsPtr tcp_connected_socket_options =
  982. mojom::TCPConnectedSocketOptions::New();
  983. tcp_connected_socket_options->receive_buffer_size =
  984. receive_buffer_size;
  985. tcp_connected_socket_options->send_buffer_size = send_buffer_size;
  986. tcp_connected_socket_options->no_delay = no_delay;
  987. if (keep_alive_options) {
  988. tcp_connected_socket_options->keep_alive_options =
  989. keep_alive_options.Clone();
  990. }
  991. EXPECT_EQ(net::OK, CreateTCPConnectedSocketSync(
  992. client_socket.BindNewPipeAndPassReceiver(),
  993. mojo::NullRemote() /*observer*/,
  994. absl::nullopt /*local_addr*/, server_addr,
  995. &client_socket_receive_handle,
  996. &client_socket_send_handle,
  997. std::move(tcp_connected_socket_options)));
  998. if (receive_buffer_size <= 0) {
  999. EXPECT_EQ(-1, data_provider.receive_buffer_size());
  1000. } else if (receive_buffer_size <=
  1001. TCPConnectedSocket::kMaxBufferSize) {
  1002. EXPECT_EQ(receive_buffer_size, data_provider.receive_buffer_size());
  1003. } else {
  1004. EXPECT_EQ(TCPConnectedSocket::kMaxBufferSize,
  1005. data_provider.receive_buffer_size());
  1006. }
  1007. if (send_buffer_size <= 0) {
  1008. EXPECT_EQ(-1, data_provider.send_buffer_size());
  1009. } else if (send_buffer_size <= TCPConnectedSocket::kMaxBufferSize) {
  1010. EXPECT_EQ(send_buffer_size, data_provider.send_buffer_size());
  1011. } else {
  1012. EXPECT_EQ(TCPConnectedSocket::kMaxBufferSize,
  1013. data_provider.send_buffer_size());
  1014. }
  1015. EXPECT_EQ(no_delay, data_provider.no_delay());
  1016. if (!keep_alive_options) {
  1017. EXPECT_EQ(data_provider.keep_alive_state(),
  1018. net::SocketDataProvider::KeepAliveState::kDefault);
  1019. } else {
  1020. EXPECT_EQ(data_provider.keep_alive_state(),
  1021. keep_alive_options->enable
  1022. ? net::SocketDataProvider::KeepAliveState::kEnabled
  1023. : net::SocketDataProvider::KeepAliveState::kDisabled);
  1024. if (keep_alive_options->enable) {
  1025. EXPECT_EQ(keep_alive_options->delay,
  1026. data_provider.keep_alive_delay());
  1027. }
  1028. }
  1029. }
  1030. }
  1031. }
  1032. }
  1033. }
  1034. TEST_P(TCPSocketWithMockSocketTest, InitialTCPConnectedSocketOptionsFails) {
  1035. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1036. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1037. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1038. enum class FailedCall {
  1039. SET_RECEIVE_BUFFER_SIZE,
  1040. SET_SEND_BUFFER_SIZE,
  1041. SET_NO_DELAY,
  1042. SET_KEEP_ALIVE
  1043. };
  1044. for (const auto& failed_call :
  1045. {FailedCall::SET_RECEIVE_BUFFER_SIZE, FailedCall::SET_SEND_BUFFER_SIZE,
  1046. FailedCall::SET_NO_DELAY, FailedCall::SET_KEEP_ALIVE}) {
  1047. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1048. net::StaticSocketDataProvider data_provider;
  1049. data_provider.set_connect_data(
  1050. net::MockConnect(GetParam(), net::OK, server_addr));
  1051. switch (failed_call) {
  1052. case FailedCall::SET_RECEIVE_BUFFER_SIZE:
  1053. data_provider.set_set_receive_buffer_size_result(net::ERR_FAILED);
  1054. break;
  1055. case FailedCall::SET_SEND_BUFFER_SIZE:
  1056. data_provider.set_set_send_buffer_size_result(net::ERR_FAILED);
  1057. break;
  1058. case FailedCall::SET_NO_DELAY:
  1059. data_provider.set_set_no_delay_result(false);
  1060. break;
  1061. case FailedCall::SET_KEEP_ALIVE:
  1062. data_provider.set_set_keep_alive_result(false);
  1063. break;
  1064. }
  1065. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1066. mojom::TCPConnectedSocketOptionsPtr tcp_connected_socket_options =
  1067. mojom::TCPConnectedSocketOptions::New();
  1068. tcp_connected_socket_options->receive_buffer_size = 1;
  1069. tcp_connected_socket_options->send_buffer_size = 2;
  1070. tcp_connected_socket_options->no_delay = false;
  1071. tcp_connected_socket_options->keep_alive_options =
  1072. mojom::TCPKeepAliveOptions::New(false, 0U);
  1073. EXPECT_EQ(net::ERR_FAILED,
  1074. CreateTCPConnectedSocketSync(
  1075. client_socket.BindNewPipeAndPassReceiver(),
  1076. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  1077. server_addr, &client_socket_receive_handle,
  1078. &client_socket_send_handle,
  1079. std::move(tcp_connected_socket_options)));
  1080. }
  1081. }
  1082. // Simulates the initial connection attempt failing, followed by another
  1083. // attempt. Used to simulate cases where the BeforeConnectionCallback is
  1084. // invoked multiple times.
  1085. TEST_P(TCPSocketWithMockSocketTest,
  1086. InitialTCPConnectedSocketSucceedsOnSecondAttempt) {
  1087. net::IPEndPoint server_addr_a(net::IPAddress::IPv4Localhost(), 1234);
  1088. net::IPEndPoint server_addr_b(net::IPAddress::IPv4Localhost(), 1235);
  1089. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1090. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1091. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1092. net::StaticSocketDataProvider data_provider;
  1093. data_provider.set_connect_data(net::MockConnect(
  1094. GetParam(), net::OK, server_addr_b, /*first_attempt_fails=*/true));
  1095. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1096. mojom::TCPConnectedSocketOptionsPtr tcp_connected_socket_options =
  1097. mojom::TCPConnectedSocketOptions::New();
  1098. tcp_connected_socket_options->receive_buffer_size = 1;
  1099. tcp_connected_socket_options->send_buffer_size = 2;
  1100. EXPECT_EQ(net::OK,
  1101. CreateTCPConnectedSocketSync(
  1102. client_socket.BindNewPipeAndPassReceiver(),
  1103. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  1104. net::AddressList({server_addr_a, server_addr_b}),
  1105. &client_socket_receive_handle, &client_socket_send_handle,
  1106. std::move(tcp_connected_socket_options)));
  1107. }
  1108. TEST_P(TCPSocketWithMockSocketTest, SetBufferSizes) {
  1109. typedef struct {
  1110. int passed_buffer_size;
  1111. int expected_buffer_size;
  1112. } BufferSizeTestData;
  1113. static const BufferSizeTestData kBufferSizeDataTestCases[] = {
  1114. // Setting a buffer size < 0 is replaced by setting a buffer size of 0.
  1115. {-1, 0},
  1116. {1024, 1024},
  1117. {TCPConnectedSocket::kMaxBufferSize + 1,
  1118. TCPConnectedSocket::kMaxBufferSize},
  1119. {0, 0}};
  1120. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1121. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1122. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1123. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1124. net::StaticSocketDataProvider data_provider;
  1125. data_provider.set_connect_data(
  1126. net::MockConnect(GetParam(), net::OK, server_addr));
  1127. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1128. EXPECT_EQ(net::OK,
  1129. CreateTCPConnectedSocketSync(
  1130. client_socket.BindNewPipeAndPassReceiver(),
  1131. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  1132. server_addr, &client_socket_receive_handle,
  1133. &client_socket_send_handle));
  1134. EXPECT_EQ(-1, data_provider.receive_buffer_size());
  1135. for (const BufferSizeTestData& test_case : kBufferSizeDataTestCases) {
  1136. net::TestCompletionCallback callback;
  1137. // Setting a buffer size < 0 is replaced by setting a buffer size of 0.
  1138. client_socket->SetReceiveBufferSize(test_case.passed_buffer_size,
  1139. callback.callback());
  1140. EXPECT_EQ(net::OK, callback.WaitForResult());
  1141. EXPECT_EQ(test_case.expected_buffer_size,
  1142. data_provider.receive_buffer_size());
  1143. }
  1144. EXPECT_EQ(-1, data_provider.send_buffer_size());
  1145. for (const BufferSizeTestData& test_case : kBufferSizeDataTestCases) {
  1146. net::TestCompletionCallback callback;
  1147. // Setting a buffer size < 0 is replaced by setting a buffer size of 0.
  1148. client_socket->SetSendBufferSize(test_case.passed_buffer_size,
  1149. callback.callback());
  1150. EXPECT_EQ(net::OK, callback.WaitForResult());
  1151. EXPECT_EQ(test_case.expected_buffer_size, data_provider.send_buffer_size());
  1152. }
  1153. }
  1154. TEST_P(TCPSocketWithMockSocketTest, SetBufferSizesFails) {
  1155. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1156. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1157. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1158. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1159. net::StaticSocketDataProvider data_provider;
  1160. data_provider.set_connect_data(
  1161. net::MockConnect(GetParam(), net::OK, server_addr));
  1162. data_provider.set_set_receive_buffer_size_result(net::ERR_FAILED);
  1163. data_provider.set_set_send_buffer_size_result(net::ERR_UNEXPECTED);
  1164. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1165. EXPECT_EQ(net::OK,
  1166. CreateTCPConnectedSocketSync(
  1167. client_socket.BindNewPipeAndPassReceiver(),
  1168. mojo::NullRemote() /*observer*/, absl::nullopt /*local_addr*/,
  1169. server_addr, &client_socket_receive_handle,
  1170. &client_socket_send_handle));
  1171. net::TestCompletionCallback receive_buffer_callback;
  1172. client_socket->SetReceiveBufferSize(1024, receive_buffer_callback.callback());
  1173. EXPECT_EQ(net::ERR_FAILED, receive_buffer_callback.WaitForResult());
  1174. net::TestCompletionCallback send_buffer_callback;
  1175. client_socket->SetSendBufferSize(1024, send_buffer_callback.callback());
  1176. EXPECT_EQ(net::ERR_UNEXPECTED, send_buffer_callback.WaitForResult());
  1177. }
  1178. TEST_F(TCPSocketWithMockSocketTest, SetNoDelayAndKeepAlive) {
  1179. net::StaticSocketDataProvider data_provider;
  1180. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1181. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1182. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1183. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1184. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1185. EXPECT_EQ(net::OK,
  1186. CreateTCPConnectedSocketSync(
  1187. client_socket.BindNewPipeAndPassReceiver(),
  1188. mojo::NullRemote() /*observer*/, absl::nullopt, server_addr,
  1189. &client_socket_receive_handle, &client_socket_send_handle));
  1190. EXPECT_TRUE(data_provider.no_delay());
  1191. {
  1192. base::RunLoop run_loop;
  1193. client_socket->SetNoDelay(false /* no_delay */,
  1194. base::BindLambdaForTesting([&](bool success) {
  1195. EXPECT_TRUE(success);
  1196. run_loop.Quit();
  1197. }));
  1198. run_loop.Run();
  1199. EXPECT_FALSE(data_provider.no_delay());
  1200. }
  1201. {
  1202. base::RunLoop run_loop;
  1203. client_socket->SetNoDelay(true /* no_delay */,
  1204. base::BindLambdaForTesting([&](bool success) {
  1205. EXPECT_TRUE(success);
  1206. run_loop.Quit();
  1207. }));
  1208. run_loop.Run();
  1209. EXPECT_TRUE(data_provider.no_delay());
  1210. }
  1211. {
  1212. const int kKeepAliveDelay = 123;
  1213. base::RunLoop run_loop;
  1214. client_socket->SetKeepAlive(true /* enable */, kKeepAliveDelay,
  1215. base::BindLambdaForTesting([&](bool success) {
  1216. EXPECT_TRUE(success);
  1217. run_loop.Quit();
  1218. }));
  1219. run_loop.Run();
  1220. EXPECT_EQ(data_provider.keep_alive_state(),
  1221. net::SocketDataProvider::KeepAliveState::kEnabled);
  1222. EXPECT_EQ(kKeepAliveDelay, data_provider.keep_alive_delay());
  1223. }
  1224. {
  1225. base::RunLoop run_loop;
  1226. client_socket->SetKeepAlive(false /* enable */, 0 /* delay */,
  1227. base::BindLambdaForTesting([&](bool success) {
  1228. EXPECT_TRUE(success);
  1229. run_loop.Quit();
  1230. }));
  1231. run_loop.Run();
  1232. EXPECT_EQ(data_provider.keep_alive_state(),
  1233. net::SocketDataProvider::KeepAliveState::kDisabled);
  1234. }
  1235. {
  1236. const int kKeepAliveDelay = 1234;
  1237. base::RunLoop run_loop;
  1238. client_socket->SetKeepAlive(true /* enable */, kKeepAliveDelay,
  1239. base::BindLambdaForTesting([&](bool success) {
  1240. EXPECT_TRUE(success);
  1241. run_loop.Quit();
  1242. }));
  1243. run_loop.Run();
  1244. EXPECT_EQ(data_provider.keep_alive_state(),
  1245. net::SocketDataProvider::KeepAliveState::kEnabled);
  1246. EXPECT_EQ(kKeepAliveDelay, data_provider.keep_alive_delay());
  1247. }
  1248. }
  1249. TEST_F(TCPSocketWithMockSocketTest, SetNoDelayFails) {
  1250. net::StaticSocketDataProvider data_provider;
  1251. data_provider.set_set_no_delay_result(false);
  1252. data_provider.set_set_keep_alive_result(false);
  1253. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1254. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1255. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1256. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1257. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1258. EXPECT_EQ(net::OK,
  1259. CreateTCPConnectedSocketSync(
  1260. client_socket.BindNewPipeAndPassReceiver(),
  1261. mojo::NullRemote() /*observer*/, absl::nullopt, server_addr,
  1262. &client_socket_receive_handle, &client_socket_send_handle));
  1263. {
  1264. base::RunLoop run_loop;
  1265. client_socket->SetNoDelay(false /* no_delay */,
  1266. base::BindLambdaForTesting([&](bool success) {
  1267. EXPECT_FALSE(success);
  1268. run_loop.Quit();
  1269. }));
  1270. run_loop.Run();
  1271. }
  1272. {
  1273. base::RunLoop run_loop;
  1274. client_socket->SetKeepAlive(true /* enable */, 123 /* delay */,
  1275. base::BindLambdaForTesting([&](bool success) {
  1276. EXPECT_FALSE(success);
  1277. run_loop.Quit();
  1278. }));
  1279. run_loop.Run();
  1280. }
  1281. }
  1282. TEST_F(TCPSocketWithMockSocketTest, SetOptionsAfterTLSUpgrade) {
  1283. // Populate with some mock reads, so UpgradeToTLS() won't error out because of
  1284. // a closed receive pipe.
  1285. const net::MockRead kReads[] = {
  1286. net::MockRead(net::ASYNC, "hello", 5 /* length */),
  1287. net::MockRead(net::ASYNC, net::OK)};
  1288. net::StaticSocketDataProvider data_provider(kReads,
  1289. base::span<net::MockWrite>());
  1290. net::SSLSocketDataProvider ssl_socket(net::ASYNC, net::ERR_FAILED);
  1291. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1292. mock_client_socket_factory_.AddSSLSocketDataProvider(&ssl_socket);
  1293. mojo::ScopedDataPipeConsumerHandle client_socket_receive_handle;
  1294. mojo::ScopedDataPipeProducerHandle client_socket_send_handle;
  1295. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1296. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1297. EXPECT_EQ(net::OK,
  1298. CreateTCPConnectedSocketSync(
  1299. client_socket.BindNewPipeAndPassReceiver(),
  1300. mojo::NullRemote() /*observer*/, absl::nullopt, server_addr,
  1301. &client_socket_receive_handle, &client_socket_send_handle));
  1302. // UpgradeToTLS will destroy network::TCPConnectedSocket::|socket_|. Calling
  1303. // SetNoDelay and SetKeepAlive should error out.
  1304. mojo::Remote<mojom::TLSClientSocket> tls_socket;
  1305. client_socket_receive_handle.reset();
  1306. client_socket_send_handle.reset();
  1307. {
  1308. base::RunLoop run_loop;
  1309. net::HostPortPair host_port_pair("example.org", 443);
  1310. client_socket->UpgradeToTLS(
  1311. host_port_pair, nullptr /* ssl_config_ptr */,
  1312. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS),
  1313. tls_socket.BindNewPipeAndPassReceiver(),
  1314. mojo::NullRemote() /*observer */,
  1315. base::BindLambdaForTesting(
  1316. [&](int result,
  1317. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  1318. mojo::ScopedDataPipeProducerHandle send_pipe_handle,
  1319. const absl::optional<net::SSLInfo>& ssl_info) {
  1320. EXPECT_EQ(net::ERR_FAILED, result);
  1321. run_loop.Quit();
  1322. }));
  1323. run_loop.Run();
  1324. }
  1325. net::TestCompletionCallback receive_buffer_callback;
  1326. client_socket->SetReceiveBufferSize(1024, receive_buffer_callback.callback());
  1327. EXPECT_EQ(net::ERR_UNEXPECTED, receive_buffer_callback.WaitForResult());
  1328. EXPECT_EQ(-1, data_provider.receive_buffer_size());
  1329. net::TestCompletionCallback send_buffer_callback;
  1330. client_socket->SetSendBufferSize(1024, send_buffer_callback.callback());
  1331. EXPECT_EQ(net::ERR_UNEXPECTED, send_buffer_callback.WaitForResult());
  1332. EXPECT_EQ(-1, data_provider.send_buffer_size());
  1333. {
  1334. base::RunLoop run_loop;
  1335. client_socket->SetNoDelay(false /* no_delay */,
  1336. base::BindLambdaForTesting([&](bool success) {
  1337. EXPECT_FALSE(success);
  1338. run_loop.Quit();
  1339. }));
  1340. run_loop.Run();
  1341. EXPECT_TRUE(data_provider.no_delay());
  1342. }
  1343. {
  1344. base::RunLoop run_loop;
  1345. client_socket->SetKeepAlive(true /* enable */, 123 /* delay */,
  1346. base::BindLambdaForTesting([&](bool success) {
  1347. EXPECT_FALSE(success);
  1348. run_loop.Quit();
  1349. }));
  1350. run_loop.Run();
  1351. }
  1352. }
  1353. TEST_F(TCPSocketWithMockSocketTest, SocketDestroyedBeforeConnectCompletes) {
  1354. std::vector<net::MockRead> reads;
  1355. std::vector<net::MockWrite> writes;
  1356. net::StaticSocketDataProvider data_provider(reads, writes);
  1357. data_provider.set_connect_data(
  1358. net::MockConnect(net::ASYNC, net::ERR_IO_PENDING));
  1359. mock_client_socket_factory_.AddSocketDataProvider(&data_provider);
  1360. mojo::Remote<mojom::TCPConnectedSocket> client_socket;
  1361. net::IPEndPoint server_addr(net::IPAddress::IPv4Localhost(), 1234);
  1362. net::AddressList remote_addr_list(server_addr);
  1363. int net_error = net::OK;
  1364. base::RunLoop run_loop;
  1365. factory()->CreateTCPConnectedSocket(
  1366. absl::nullopt, remote_addr_list,
  1367. nullptr /* tcp_connected_socket_options */, TRAFFIC_ANNOTATION_FOR_TESTS,
  1368. client_socket.BindNewPipeAndPassReceiver(), mojo::NullRemote(),
  1369. base::BindLambdaForTesting(
  1370. [&](int result,
  1371. const absl::optional<net::IPEndPoint>& actual_local_addr,
  1372. const absl::optional<net::IPEndPoint>& peer_addr,
  1373. mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
  1374. mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
  1375. net_error = result;
  1376. run_loop.Quit();
  1377. }));
  1378. client_socket.reset();
  1379. run_loop.Run();
  1380. EXPECT_EQ(net::ERR_ABORTED, net_error);
  1381. }
  1382. // Tests the case where net::ServerSocket::Listen() succeeds but
  1383. // net::ServerSocket::GetLocalAddress() fails. This should still be considered
  1384. // as a failure.
  1385. TEST(TCPServerSocketTest, GetLocalAddressFailedInListen) {
  1386. base::test::TaskEnvironment task_environment(
  1387. base::test::TaskEnvironment::MainThreadType::IO);
  1388. TCPServerSocket socket(nullptr /* delegate */, nullptr /* net_log */,
  1389. TRAFFIC_ANNOTATION_FOR_TESTS);
  1390. socket.SetSocketForTest(std::make_unique<FailingServerSocket>());
  1391. net::IPEndPoint local_addr;
  1392. EXPECT_EQ(net::ERR_FAILED, socket.Listen(local_addr, 1, &local_addr));
  1393. }
  1394. } // namespace network