1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "jingle/glue/network_service_async_socket.h"
6
7 #include <stddef.h>
8
9 #include <memory>
10 #include <string>
11 #include <utility>
12
13 #include "base/bind.h"
14 #include "base/check_op.h"
15 #include "base/containers/circular_deque.h"
16 #include "base/memory/ptr_util.h"
17 #include "base/message_loop/message_pump_default.h"
18 #include "base/notreached.h"
19 #include "base/run_loop.h"
20 #include "base/stl_util.h"
21 #include "base/strings/strcat.h"
22 #include "base/strings/string_number_conversions.h"
23 #include "base/test/task_environment.h"
24 #include "mojo/public/cpp/bindings/pending_receiver.h"
25 #include "mojo/public/cpp/bindings/pending_remote.h"
26 #include "mojo/public/cpp/bindings/remote.h"
27 #include "mojo/public/cpp/bindings/unique_receiver_set.h"
28 #include "mojo/public/cpp/system/data_pipe_utils.h"
29 #include "net/base/address_list.h"
30 #include "net/base/host_port_pair.h"
31 #include "net/base/ip_address.h"
32 #include "net/base/net_errors.h"
33 #include "net/base/network_isolation_key.h"
34 #include "net/cert/mock_cert_verifier.h"
35 #include "net/http/transport_security_state.h"
36 #include "net/log/net_log_source.h"
37 #include "net/socket/socket_test_util.h"
38 #include "net/socket/ssl_client_socket.h"
39 #include "net/ssl/ssl_config_service.h"
40 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
41 #include "net/url_request/url_request_test_util.h"
42 #include "services/network/proxy_resolving_socket_factory_mojo.h"
43 #include "services/network/public/mojom/proxy_resolving_socket.mojom.h"
44 #include "testing/gtest/include/gtest/gtest.h"
45 #include "third_party/webrtc/rtc_base/third_party/sigslot/sigslot.h"
46 #include "url/origin.h"
47
48 namespace jingle_glue {
49
50 namespace {
51
52 // Data provider that handles reads/writes for NetworkServiceAsyncSocket.
53 class AsyncSocketDataProvider : public net::SocketDataProvider {
54 public:
AsyncSocketDataProvider()55 AsyncSocketDataProvider() : has_pending_read_(false) {}
56
~AsyncSocketDataProvider()57 ~AsyncSocketDataProvider() override {
58 EXPECT_TRUE(writes_.empty());
59 EXPECT_TRUE(reads_.empty());
60 }
61
62 // If there's no read, sets the "has pending read" flag. Otherwise,
63 // pops the next read.
OnRead()64 net::MockRead OnRead() override {
65 if (reads_.empty()) {
66 DCHECK(!has_pending_read_);
67 has_pending_read_ = true;
68 const net::MockRead pending_read(net::SYNCHRONOUS, net::ERR_IO_PENDING);
69 return pending_read;
70 }
71 net::MockRead mock_read = reads_.front();
72 reads_.pop_front();
73 return mock_read;
74 }
75
CancelPendingRead()76 void CancelPendingRead() override {
77 DCHECK(has_pending_read_);
78 has_pending_read_ = false;
79 }
80
81 // Simply pops the next write and, if applicable, compares it to
82 // |data|.
OnWrite(const std::string & data)83 net::MockWriteResult OnWrite(const std::string& data) override {
84 DCHECK(!writes_.empty());
85 net::MockWrite mock_write = writes_.front();
86 writes_.pop_front();
87 if (mock_write.result != net::OK) {
88 return net::MockWriteResult(mock_write.mode, mock_write.result);
89 }
90 std::string expected_data(mock_write.data, mock_write.data_len);
91 EXPECT_EQ(expected_data, data);
92 if (expected_data != data) {
93 return net::MockWriteResult(net::SYNCHRONOUS, net::ERR_UNEXPECTED);
94 }
95 return net::MockWriteResult(mock_write.mode, data.size());
96 }
97
98 // We ignore resets so we can pre-load the socket data provider with
99 // read/write events.
Reset()100 void Reset() override {}
101
102 // If there is a pending read, completes it with the given read.
103 // Otherwise, queues up the given read.
AddRead(const net::MockRead & mock_read)104 void AddRead(const net::MockRead& mock_read) {
105 DCHECK_NE(mock_read.result, net::ERR_IO_PENDING);
106 if (has_pending_read_) {
107 has_pending_read_ = false;
108 socket()->OnReadComplete(mock_read);
109 return;
110 }
111 reads_.push_back(mock_read);
112 }
113
114 // Simply queues up the given write.
AddWrite(const net::MockWrite & mock_write)115 void AddWrite(const net::MockWrite& mock_write) {
116 writes_.push_back(mock_write);
117 }
118
AllReadDataConsumed() const119 bool AllReadDataConsumed() const override { return reads_.empty(); }
120
AllWriteDataConsumed() const121 bool AllWriteDataConsumed() const override { return writes_.empty(); }
122
123 private:
124 base::circular_deque<net::MockRead> reads_;
125 bool has_pending_read_;
126
127 base::circular_deque<net::MockWrite> writes_;
128
129 DISALLOW_COPY_AND_ASSIGN(AsyncSocketDataProvider);
130 };
131
132 class MockProxyResolvingSocket : public network::mojom::ProxyResolvingSocket {
133 public:
134 enum Event {
135 // These names are from the perspective of the client, not the socket.
136 kRead,
137 kWrite,
138 kCloseReadPipe,
139 kCloseWritePipe,
140 kReadError,
141 kReadErrorInvalid,
142 kWriteError,
143 kWriteErrorInvalid,
144 kReadEofError,
145 kCloseObserverPipe,
146 };
147
MockProxyResolvingSocket()148 MockProxyResolvingSocket() {}
~MockProxyResolvingSocket()149 ~MockProxyResolvingSocket() override {}
150
Connect(mojo::PendingRemote<network::mojom::SocketObserver> observer,network::mojom::ProxyResolvingSocketFactory::CreateProxyResolvingSocketCallback callback)151 void Connect(mojo::PendingRemote<network::mojom::SocketObserver> observer,
152 network::mojom::ProxyResolvingSocketFactory::
153 CreateProxyResolvingSocketCallback callback) {
154 mojo::DataPipe send_pipe;
155 mojo::DataPipe receive_pipe;
156
157 observer_.Bind(std::move(observer));
158 receive_pipe_handle_ = std::move(receive_pipe.producer_handle);
159 send_pipe_handle_ = std::move(send_pipe.consumer_handle);
160
161 std::move(callback).Run(net::OK, base::nullopt, base::nullopt,
162 std::move(receive_pipe.consumer_handle),
163 std::move(send_pipe.producer_handle));
164 }
165
166 void RunEvents(std::vector<Event>&& events);
167
168 // mojom::ProxyResolvingSocket implementation.
UpgradeToTLS(const net::HostPortPair & host_port_pair,const net::MutableNetworkTrafficAnnotationTag & traffic_annotation,mojo::PendingReceiver<network::mojom::TLSClientSocket> receiver,mojo::PendingRemote<network::mojom::SocketObserver> observer,network::mojom::ProxyResolvingSocket::UpgradeToTLSCallback callback)169 void UpgradeToTLS(
170 const net::HostPortPair& host_port_pair,
171 const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
172 mojo::PendingReceiver<network::mojom::TLSClientSocket> receiver,
173 mojo::PendingRemote<network::mojom::SocketObserver> observer,
174 network::mojom::ProxyResolvingSocket::UpgradeToTLSCallback callback)
175 override {
176 NOTREACHED();
177 }
178
179 private:
180 mojo::Remote<network::mojom::SocketObserver> observer_;
181 mojo::ScopedDataPipeProducerHandle receive_pipe_handle_;
182 mojo::ScopedDataPipeConsumerHandle send_pipe_handle_;
183
184 DISALLOW_COPY_AND_ASSIGN(MockProxyResolvingSocket);
185 };
186
187 class MockProxyResolvingSocketFactory
188 : public network::mojom::ProxyResolvingSocketFactory {
189 public:
MockProxyResolvingSocketFactory()190 explicit MockProxyResolvingSocketFactory() : socket_raw_(nullptr) {}
~MockProxyResolvingSocketFactory()191 ~MockProxyResolvingSocketFactory() override {}
192
193 // mojom::ProxyResolvingSocketFactory implementation.
CreateProxyResolvingSocket(const GURL & url,const net::NetworkIsolationKey & network_isolation_key,network::mojom::ProxyResolvingSocketOptionsPtr options,const net::MutableNetworkTrafficAnnotationTag & traffic_annotation,mojo::PendingReceiver<network::mojom::ProxyResolvingSocket> receiver,mojo::PendingRemote<network::mojom::SocketObserver> observer,CreateProxyResolvingSocketCallback callback)194 void CreateProxyResolvingSocket(
195 const GURL& url,
196 const net::NetworkIsolationKey& network_isolation_key,
197 network::mojom::ProxyResolvingSocketOptionsPtr options,
198 const net::MutableNetworkTrafficAnnotationTag& traffic_annotation,
199 mojo::PendingReceiver<network::mojom::ProxyResolvingSocket> receiver,
200 mojo::PendingRemote<network::mojom::SocketObserver> observer,
201 CreateProxyResolvingSocketCallback callback) override {
202 url::Origin origin = url::Origin::Create(url);
203 EXPECT_EQ(net::NetworkIsolationKey(origin /* top_frame_origin */,
204 origin /* frame_origin */),
205 network_isolation_key);
206 auto socket = std::make_unique<MockProxyResolvingSocket>();
207 socket_raw_ = socket.get();
208 proxy_resolving_socket_receivers_.Add(std::move(socket),
209 std::move(receiver));
210 socket_raw_->Connect(std::move(observer), std::move(callback));
211 }
212
socket()213 MockProxyResolvingSocket* socket() { return socket_raw_; }
214
215 private:
216 mojo::UniqueReceiverSet<network::mojom::ProxyResolvingSocket>
217 proxy_resolving_socket_receivers_;
218
219 // Owned by |proxy_resolving_socket_receivers_|.
220 MockProxyResolvingSocket* socket_raw_;
221
222 DISALLOW_COPY_AND_ASSIGN(MockProxyResolvingSocketFactory);
223 };
224
RunEvents(std::vector<Event> && events)225 void MockProxyResolvingSocket::RunEvents(std::vector<Event>&& events) {
226 for (Event ev : events) {
227 switch (ev) {
228 case kRead:
229 mojo::BlockingCopyFromString("data", receive_pipe_handle_);
230 break;
231 case kWrite: {
232 std::string written;
233 while (true) {
234 char read_buffer[1024];
235 uint32_t read_size = sizeof(read_buffer);
236 MojoResult result = send_pipe_handle_->ReadData(
237 read_buffer, &read_size, MOJO_READ_DATA_FLAG_NONE);
238 if (result != MOJO_RESULT_OK)
239 break;
240 written.append(read_buffer, read_size);
241 }
242
243 EXPECT_EQ("atad", written);
244 break;
245 }
246 case kCloseReadPipe:
247 receive_pipe_handle_.reset();
248 break;
249 case kCloseWritePipe:
250 send_pipe_handle_.reset();
251 break;
252 case kReadError:
253 observer_->OnReadError(net::ERR_OUT_OF_MEMORY);
254 observer_.FlushForTesting();
255 break;
256 case kReadErrorInvalid:
257 observer_->OnReadError(42);
258 observer_.FlushForTesting();
259 break;
260 case kWriteError:
261 observer_->OnWriteError(net::ERR_ACCESS_DENIED);
262 observer_.FlushForTesting();
263 break;
264 case kWriteErrorInvalid:
265 observer_->OnWriteError(net::ERR_IO_PENDING);
266 observer_.FlushForTesting();
267 break;
268 case kReadEofError:
269 observer_->OnReadError(0);
270 observer_.FlushForTesting();
271 break;
272 case kCloseObserverPipe:
273 observer_.reset();
274 break;
275 }
276 // Make sure the event is actually delivered.
277 base::RunLoop().RunUntilIdle();
278 }
279 }
280
281 class NetworkServiceAsyncSocketTest : public testing::Test,
282 public sigslot::has_slots<> {
283 protected:
NetworkServiceAsyncSocketTest(bool use_mojo_level_mock=false)284 explicit NetworkServiceAsyncSocketTest(bool use_mojo_level_mock = false)
285 : ssl_socket_data_provider_(net::ASYNC, net::OK),
286 use_mojo_level_mock_(use_mojo_level_mock),
287 mock_proxy_resolving_socket_factory_(nullptr),
288 addr_({"localhost", 35}) {
289 // GTest death tests by default execute in a fork()ed but not exec()ed
290 // process. On macOS, a CoreFoundation-backed MessageLoop will exit with a
291 // __THE_PROCESS_HAS_FORKED_AND_YOU_CANNOT_USE_THIS_COREFOUNDATION_FUNCTIONALITY___YOU_MUST_EXEC__
292 // when called. Use the threadsafe mode to avoid this problem.
293 testing::GTEST_FLAG(death_test_style) = "threadsafe";
294 }
295
~NetworkServiceAsyncSocketTest()296 ~NetworkServiceAsyncSocketTest() override {}
297
SetUp()298 void SetUp() override {
299 mock_client_socket_factory_ =
300 std::make_unique<net::MockClientSocketFactory>();
301 mock_client_socket_factory_->set_enable_read_if_ready(true);
302 mock_client_socket_factory_->AddSocketDataProvider(
303 &async_socket_data_provider_);
304 mock_client_socket_factory_->AddSSLSocketDataProvider(
305 &ssl_socket_data_provider_);
306
307 test_url_request_context_ =
308 std::make_unique<net::TestURLRequestContext>(true /* delay init */);
309 test_url_request_context_->set_client_socket_factory(
310 mock_client_socket_factory_.get());
311 test_url_request_context_->Init();
312
313 if (use_mojo_level_mock_) {
314 auto mock_proxy_resolving_socket_factory =
315 std::make_unique<MockProxyResolvingSocketFactory>();
316 mock_proxy_resolving_socket_factory_ =
317 mock_proxy_resolving_socket_factory.get();
318 proxy_resolving_socket_factory_ =
319 std::move(mock_proxy_resolving_socket_factory);
320 } else {
321 mock_proxy_resolving_socket_factory_ = nullptr;
322 proxy_resolving_socket_factory_ =
323 std::make_unique<network::ProxyResolvingSocketFactoryMojo>(
324 test_url_request_context_.get());
325 }
326
327 ns_async_socket_.reset(new NetworkServiceAsyncSocket(
328 base::BindRepeating(
329 &NetworkServiceAsyncSocketTest::BindToProxyResolvingSocketFactory,
330 base::Unretained(this)),
331 false, /* use_fake_tls_handshake */
332 14, 20, TRAFFIC_ANNOTATION_FOR_TESTS));
333
334 ns_async_socket_->SignalConnected.connect(
335 this, &NetworkServiceAsyncSocketTest::OnConnect);
336 ns_async_socket_->SignalSSLConnected.connect(
337 this, &NetworkServiceAsyncSocketTest::OnSSLConnect);
338 ns_async_socket_->SignalClosed.connect(
339 this, &NetworkServiceAsyncSocketTest::OnClose);
340 ns_async_socket_->SignalRead.connect(
341 this, &NetworkServiceAsyncSocketTest::OnRead);
342 ns_async_socket_->SignalError.connect(
343 this, &NetworkServiceAsyncSocketTest::OnError);
344 }
345
TearDown()346 void TearDown() override {
347 // Run any tasks that we forgot to pump.
348 base::RunLoop().RunUntilIdle();
349 ExpectClosed();
350 ExpectNoSignal();
351 ns_async_socket_.reset();
352 }
353
BindToProxyResolvingSocketFactory(mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory> receiver)354 void BindToProxyResolvingSocketFactory(
355 mojo::PendingReceiver<network::mojom::ProxyResolvingSocketFactory>
356 receiver) {
357 proxy_resolving_socket_factory_receiver_ = std::make_unique<
358 mojo::Receiver<network::mojom::ProxyResolvingSocketFactory>>(
359 proxy_resolving_socket_factory_.get());
360 proxy_resolving_socket_factory_receiver_->Bind(std::move(receiver));
361 }
362
363 enum Signal {
364 SIGNAL_CONNECT,
365 SIGNAL_SSL_CONNECT,
366 SIGNAL_CLOSE,
367 SIGNAL_READ,
368 SIGNAL_ERROR,
369 };
370
371 // Helper struct that records the state at the time of a signal.
372
373 struct SignalSocketState {
SignalSocketStatejingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState374 SignalSocketState()
375 : signal(SIGNAL_ERROR),
376 state(NetworkServiceAsyncSocket::STATE_CLOSED),
377 error(NetworkServiceAsyncSocket::ERROR_NONE),
378 net_error(net::OK) {}
379
SignalSocketStatejingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState380 SignalSocketState(Signal signal,
381 NetworkServiceAsyncSocket::State state,
382 NetworkServiceAsyncSocket::Error error,
383 net::Error net_error)
384 : signal(signal), state(state), error(error), net_error(net_error) {}
385
IsEqualjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState386 bool IsEqual(const SignalSocketState& other) const {
387 return (signal == other.signal) && (state == other.state) &&
388 (error == other.error) && (net_error == other.net_error);
389 }
390
FromAsyncSocketjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState391 static SignalSocketState FromAsyncSocket(Signal signal,
392 jingle_xmpp::AsyncSocket* async_socket) {
393 return SignalSocketState(
394 signal, async_socket->state(), async_socket->error(),
395 static_cast<net::Error>(async_socket->GetError()));
396 }
397
NoErrorjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState398 static SignalSocketState NoError(Signal signal,
399 jingle_xmpp::AsyncSocket::State state) {
400 return SignalSocketState(signal, state, jingle_xmpp::AsyncSocket::ERROR_NONE,
401 net::OK);
402 }
403
ToStringjingle_glue::__anon811b799b0111::NetworkServiceAsyncSocketTest::SignalSocketState404 std::string ToString() const {
405 return base::StrCat({"(", base::NumberToString(signal), ",",
406 base::NumberToString(state), ",",
407 base::NumberToString(error), ",",
408 base::NumberToString(net_error), ")"});
409 }
410
411 Signal signal;
412 NetworkServiceAsyncSocket::State state;
413 NetworkServiceAsyncSocket::Error error;
414 net::Error net_error;
415 };
416
CaptureSocketState(Signal signal)417 void CaptureSocketState(Signal signal) {
418 signal_socket_states_.push_back(
419 SignalSocketState::FromAsyncSocket(signal, ns_async_socket_.get()));
420 }
421
OnConnect()422 void OnConnect() { CaptureSocketState(SIGNAL_CONNECT); }
423
OnSSLConnect()424 void OnSSLConnect() { CaptureSocketState(SIGNAL_SSL_CONNECT); }
425
OnClose()426 void OnClose() { CaptureSocketState(SIGNAL_CLOSE); }
427
OnRead()428 void OnRead() { CaptureSocketState(SIGNAL_READ); }
429
OnError()430 void OnError() { ADD_FAILURE(); }
431
432 // State expect functions.
433
ExpectState(NetworkServiceAsyncSocket::State state,NetworkServiceAsyncSocket::Error error,net::Error net_error)434 void ExpectState(NetworkServiceAsyncSocket::State state,
435 NetworkServiceAsyncSocket::Error error,
436 net::Error net_error) {
437 EXPECT_EQ(state, ns_async_socket_->state());
438 EXPECT_EQ(error, ns_async_socket_->error());
439 EXPECT_EQ(net_error, ns_async_socket_->GetError());
440 }
441
ExpectNonErrorState(NetworkServiceAsyncSocket::State state)442 void ExpectNonErrorState(NetworkServiceAsyncSocket::State state) {
443 ExpectState(state, NetworkServiceAsyncSocket::ERROR_NONE, net::OK);
444 }
445
ExpectErrorState(NetworkServiceAsyncSocket::State state,NetworkServiceAsyncSocket::Error error)446 void ExpectErrorState(NetworkServiceAsyncSocket::State state,
447 NetworkServiceAsyncSocket::Error error) {
448 ExpectState(state, error, net::OK);
449 }
450
ExpectClosed()451 void ExpectClosed() {
452 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
453 }
454
455 // Signal expect functions.
456
ExpectNoSignal()457 void ExpectNoSignal() {
458 if (!signal_socket_states_.empty()) {
459 ADD_FAILURE() << signal_socket_states_.front().signal;
460 }
461 }
462
ExpectSignalSocketState(SignalSocketState expected_signal_socket_state)463 void ExpectSignalSocketState(SignalSocketState expected_signal_socket_state) {
464 if (signal_socket_states_.empty()) {
465 ADD_FAILURE() << expected_signal_socket_state.signal;
466 return;
467 }
468 EXPECT_TRUE(
469 expected_signal_socket_state.IsEqual(signal_socket_states_.front()))
470 << "Expected signal:" << expected_signal_socket_state.ToString()
471 << " actual signal: " << signal_socket_states_.front().ToString();
472 signal_socket_states_.pop_front();
473 }
474
ExpectReadSignal()475 void ExpectReadSignal() {
476 ExpectSignalSocketState(SignalSocketState::NoError(
477 SIGNAL_READ, NetworkServiceAsyncSocket::STATE_OPEN));
478 }
479
ExpectSSLConnectSignal()480 void ExpectSSLConnectSignal() {
481 ExpectSignalSocketState(SignalSocketState::NoError(
482 SIGNAL_SSL_CONNECT, NetworkServiceAsyncSocket::STATE_TLS_OPEN));
483 }
484
ExpectSSLReadSignal()485 void ExpectSSLReadSignal() {
486 ExpectSignalSocketState(SignalSocketState::NoError(
487 SIGNAL_READ, NetworkServiceAsyncSocket::STATE_TLS_OPEN));
488 }
489
490 // Open/close utility functions.
491
DoOpenClosed()492 void DoOpenClosed() {
493 ExpectClosed();
494 async_socket_data_provider_.set_connect_data(
495 net::MockConnect(net::SYNCHRONOUS, net::OK));
496 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
497 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
498
499 base::RunLoop().RunUntilIdle();
500 // We may not necessarily be open; may have been other events
501 // queued up.
502 ExpectSignalSocketState(SignalSocketState::NoError(
503 SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
504 }
505
DoCloseOpened(SignalSocketState expected_signal_socket_state)506 void DoCloseOpened(SignalSocketState expected_signal_socket_state) {
507 // We may be in an error state, so just compare state().
508 EXPECT_EQ(NetworkServiceAsyncSocket::STATE_OPEN, ns_async_socket_->state());
509 EXPECT_TRUE(ns_async_socket_->Close());
510 ExpectSignalSocketState(expected_signal_socket_state);
511 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
512 }
513
DoCloseOpenedNoError()514 void DoCloseOpenedNoError() {
515 DoCloseOpened(SignalSocketState::NoError(
516 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
517 }
518
DoSSLOpenClosed()519 void DoSSLOpenClosed() {
520 const char kDummyData[] = "dummy_data";
521 async_socket_data_provider_.AddRead(net::MockRead(kDummyData));
522 DoOpenClosed();
523 ExpectReadSignal();
524 EXPECT_EQ(kDummyData, DrainRead(1));
525
526 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
527 base::RunLoop().RunUntilIdle();
528 ExpectSSLConnectSignal();
529 ExpectNoSignal();
530 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
531 }
532
DoSSLCloseOpened(SignalSocketState expected_signal_socket_state)533 void DoSSLCloseOpened(SignalSocketState expected_signal_socket_state) {
534 // We may be in an error state, so just compare state().
535 EXPECT_EQ(NetworkServiceAsyncSocket::STATE_TLS_OPEN,
536 ns_async_socket_->state());
537 EXPECT_TRUE(ns_async_socket_->Close());
538 ExpectSignalSocketState(expected_signal_socket_state);
539 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
540 }
541
DoSSLCloseOpenedNoError()542 void DoSSLCloseOpenedNoError() {
543 DoSSLCloseOpened(SignalSocketState::NoError(
544 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
545 }
546
547 // Read utility functions.
548
DrainRead(size_t buf_size)549 std::string DrainRead(size_t buf_size) {
550 std::string read;
551 std::unique_ptr<char[]> buf(new char[buf_size]);
552 size_t len_read;
553 while (true) {
554 bool success = ns_async_socket_->Read(buf.get(), buf_size, &len_read);
555 if (!success) {
556 ADD_FAILURE();
557 break;
558 }
559 if (len_read == 0U) {
560 break;
561 }
562 read.append(buf.get(), len_read);
563 }
564 return read;
565 }
566
567 // Need a message loop for both the socket and Mojo.
568 base::test::SingleThreadTaskEnvironment task_environment_;
569
570 AsyncSocketDataProvider async_socket_data_provider_;
571 net::SSLSocketDataProvider ssl_socket_data_provider_;
572
573 bool use_mojo_level_mock_;
574
575 std::unique_ptr<net::MockClientSocketFactory> mock_client_socket_factory_;
576 std::unique_ptr<net::TestURLRequestContext> test_url_request_context_;
577 // Either null or owned by proxy_resolving_socket_factory_.
578 MockProxyResolvingSocketFactory* mock_proxy_resolving_socket_factory_;
579 std::unique_ptr<network::mojom::ProxyResolvingSocketFactory>
580 proxy_resolving_socket_factory_;
581 std::unique_ptr<mojo::Receiver<network::mojom::ProxyResolvingSocketFactory>>
582 proxy_resolving_socket_factory_receiver_;
583
584 std::unique_ptr<NetworkServiceAsyncSocket> ns_async_socket_;
585 base::circular_deque<SignalSocketState> signal_socket_states_;
586 const net::HostPortPair addr_;
587
588 private:
589 DISALLOW_COPY_AND_ASSIGN(NetworkServiceAsyncSocketTest);
590 };
591
TEST_F(NetworkServiceAsyncSocketTest,InitialState)592 TEST_F(NetworkServiceAsyncSocketTest, InitialState) {
593 ExpectClosed();
594 ExpectNoSignal();
595 }
596
TEST_F(NetworkServiceAsyncSocketTest,EmptyClose)597 TEST_F(NetworkServiceAsyncSocketTest, EmptyClose) {
598 ExpectClosed();
599 EXPECT_TRUE(ns_async_socket_->Close());
600 ExpectClosed();
601 }
602
TEST_F(NetworkServiceAsyncSocketTest,ImmediateConnectAndClose)603 TEST_F(NetworkServiceAsyncSocketTest, ImmediateConnectAndClose) {
604 DoOpenClosed();
605
606 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_OPEN);
607
608 DoCloseOpenedNoError();
609 }
610
611 // After this, no need to test immediate successful connect and
612 // Close() so thoroughly.
613
TEST_F(NetworkServiceAsyncSocketTest,DoubleClose)614 TEST_F(NetworkServiceAsyncSocketTest, DoubleClose) {
615 DoOpenClosed();
616
617 EXPECT_TRUE(ns_async_socket_->Close());
618 ExpectClosed();
619 ExpectSignalSocketState(SignalSocketState::NoError(
620 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
621
622 EXPECT_TRUE(ns_async_socket_->Close());
623 ExpectClosed();
624 }
625
TEST_F(NetworkServiceAsyncSocketTest,ZeroPortConnect)626 TEST_F(NetworkServiceAsyncSocketTest, ZeroPortConnect) {
627 const net::HostPortPair zero_port_addr({addr_.host(), 0});
628 EXPECT_FALSE(ns_async_socket_->Connect(zero_port_addr));
629 ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
630 NetworkServiceAsyncSocket::ERROR_DNS);
631
632 EXPECT_TRUE(ns_async_socket_->Close());
633 ExpectClosed();
634 }
635
TEST_F(NetworkServiceAsyncSocketTest,DoubleConnect)636 TEST_F(NetworkServiceAsyncSocketTest, DoubleConnect) {
637 EXPECT_DEBUG_DEATH(
638 {
639 DoOpenClosed();
640
641 EXPECT_FALSE(ns_async_socket_->Connect(addr_));
642 ExpectErrorState(NetworkServiceAsyncSocket::STATE_OPEN,
643 NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
644
645 DoCloseOpened(SignalSocketState(
646 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
647 NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
648 },
649 "non-closed socket");
650 }
651
TEST_F(NetworkServiceAsyncSocketTest,ImmediateConnectCloseBeforeRead)652 TEST_F(NetworkServiceAsyncSocketTest, ImmediateConnectCloseBeforeRead) {
653 DoOpenClosed();
654
655 EXPECT_TRUE(ns_async_socket_->Close());
656 ExpectClosed();
657 ExpectSignalSocketState(SignalSocketState::NoError(
658 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
659
660 base::RunLoop().RunUntilIdle();
661 }
662
TEST_F(NetworkServiceAsyncSocketTest,HangingConnect)663 TEST_F(NetworkServiceAsyncSocketTest, HangingConnect) {
664 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
665 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
666 ExpectNoSignal();
667
668 EXPECT_TRUE(ns_async_socket_->Close());
669 ExpectClosed();
670 ExpectSignalSocketState(SignalSocketState::NoError(
671 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
672 }
673
TEST_F(NetworkServiceAsyncSocketTest,PendingConnect)674 TEST_F(NetworkServiceAsyncSocketTest, PendingConnect) {
675 async_socket_data_provider_.set_connect_data(
676 net::MockConnect(net::ASYNC, net::OK));
677 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
678 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
679 ExpectNoSignal();
680
681 base::RunLoop().RunUntilIdle();
682 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_OPEN);
683 ExpectSignalSocketState(SignalSocketState::NoError(
684 SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
685 ExpectNoSignal();
686
687 base::RunLoop().RunUntilIdle();
688
689 DoCloseOpenedNoError();
690 }
691
692 // After this no need to test successful pending connect so
693 // thoroughly.
694
TEST_F(NetworkServiceAsyncSocketTest,PendingConnectCloseBeforeRead)695 TEST_F(NetworkServiceAsyncSocketTest, PendingConnectCloseBeforeRead) {
696 async_socket_data_provider_.set_connect_data(
697 net::MockConnect(net::ASYNC, net::OK));
698 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
699
700 base::RunLoop().RunUntilIdle();
701 ExpectSignalSocketState(SignalSocketState::NoError(
702 SIGNAL_CONNECT, NetworkServiceAsyncSocket::STATE_OPEN));
703
704 DoCloseOpenedNoError();
705
706 base::RunLoop().RunUntilIdle();
707 }
708
TEST_F(NetworkServiceAsyncSocketTest,PendingConnectError)709 TEST_F(NetworkServiceAsyncSocketTest, PendingConnectError) {
710 async_socket_data_provider_.set_connect_data(
711 net::MockConnect(net::ASYNC, net::ERR_TIMED_OUT));
712 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
713
714 base::RunLoop().RunUntilIdle();
715
716 ExpectSignalSocketState(SignalSocketState(
717 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
718 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
719 }
720
721 // After this we can assume Connect() and Close() work as expected.
722
TEST_F(NetworkServiceAsyncSocketTest,EmptyRead)723 TEST_F(NetworkServiceAsyncSocketTest, EmptyRead) {
724 DoOpenClosed();
725
726 char buf[4096];
727 size_t len_read = 10000U;
728 EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
729 EXPECT_EQ(0U, len_read);
730
731 DoCloseOpenedNoError();
732 }
733
TEST_F(NetworkServiceAsyncSocketTest,WrongRead)734 TEST_F(NetworkServiceAsyncSocketTest, WrongRead) {
735 EXPECT_DEBUG_DEATH(
736 {
737 async_socket_data_provider_.set_connect_data(
738 net::MockConnect(net::ASYNC, net::OK));
739 EXPECT_TRUE(ns_async_socket_->Connect(addr_));
740 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING);
741 ExpectNoSignal();
742
743 char buf[4096];
744 size_t len_read;
745 EXPECT_FALSE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
746 ExpectErrorState(NetworkServiceAsyncSocket::STATE_CONNECTING,
747 NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
748 EXPECT_TRUE(ns_async_socket_->Close());
749 ExpectSignalSocketState(SignalSocketState(
750 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
751 NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
752 },
753 "non-open");
754 }
755
TEST_F(NetworkServiceAsyncSocketTest,WrongReadClosed)756 TEST_F(NetworkServiceAsyncSocketTest, WrongReadClosed) {
757 char buf[4096];
758 size_t len_read;
759 EXPECT_FALSE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
760 ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
761 NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
762 EXPECT_TRUE(ns_async_socket_->Close());
763 }
764
765 const char kReadData[] = "mydatatoread";
766
TEST_F(NetworkServiceAsyncSocketTest,Read)767 TEST_F(NetworkServiceAsyncSocketTest, Read) {
768 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
769 DoOpenClosed();
770
771 ExpectReadSignal();
772 ExpectNoSignal();
773
774 EXPECT_EQ(kReadData, DrainRead(1));
775
776 base::RunLoop().RunUntilIdle();
777
778 DoCloseOpenedNoError();
779 }
780
TEST_F(NetworkServiceAsyncSocketTest,ReadTwice)781 TEST_F(NetworkServiceAsyncSocketTest, ReadTwice) {
782 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
783 DoOpenClosed();
784
785 ExpectReadSignal();
786 ExpectNoSignal();
787
788 EXPECT_EQ(kReadData, DrainRead(1));
789
790 base::RunLoop().RunUntilIdle();
791
792 const char kReadData2[] = "mydatatoread2";
793 async_socket_data_provider_.AddRead(net::MockRead(kReadData2));
794 base::RunLoop().RunUntilIdle();
795
796 ExpectReadSignal();
797 ExpectNoSignal();
798
799 EXPECT_EQ(kReadData2, DrainRead(1));
800
801 DoCloseOpenedNoError();
802 }
803
TEST_F(NetworkServiceAsyncSocketTest,ReadError)804 TEST_F(NetworkServiceAsyncSocketTest, ReadError) {
805 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
806 DoOpenClosed();
807
808 ExpectReadSignal();
809 ExpectNoSignal();
810
811 EXPECT_EQ(kReadData, DrainRead(1));
812
813 base::RunLoop().RunUntilIdle();
814
815 async_socket_data_provider_.AddRead(
816 net::MockRead(net::SYNCHRONOUS, net::ERR_TIMED_OUT));
817 base::RunLoop().RunUntilIdle();
818
819 ExpectSignalSocketState(SignalSocketState(
820 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
821 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
822 }
823
TEST_F(NetworkServiceAsyncSocketTest,ReadEOF)824 TEST_F(NetworkServiceAsyncSocketTest, ReadEOF) {
825 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
826 DoOpenClosed();
827
828 ExpectReadSignal();
829 ExpectNoSignal();
830
831 EXPECT_EQ(kReadData, DrainRead(1));
832
833 base::RunLoop().RunUntilIdle();
834
835 async_socket_data_provider_.AddRead(net::MockRead(net::SYNCHRONOUS, net::OK));
836 base::RunLoop().RunUntilIdle();
837 ExpectSignalSocketState(SignalSocketState::NoError(
838 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
839 }
840
TEST_F(NetworkServiceAsyncSocketTest,ReadEmpty)841 TEST_F(NetworkServiceAsyncSocketTest, ReadEmpty) {
842 async_socket_data_provider_.AddRead(net::MockRead(""));
843 DoOpenClosed();
844
845 ExpectSignalSocketState(SignalSocketState::NoError(
846 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
847 }
848
TEST_F(NetworkServiceAsyncSocketTest,PendingRead)849 TEST_F(NetworkServiceAsyncSocketTest, PendingRead) {
850 DoOpenClosed();
851
852 ExpectNoSignal();
853
854 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
855 base::RunLoop().RunUntilIdle();
856
857 ExpectSignalSocketState(SignalSocketState::NoError(
858 SIGNAL_READ, NetworkServiceAsyncSocket::STATE_OPEN));
859 ExpectNoSignal();
860
861 EXPECT_EQ(kReadData, DrainRead(1));
862
863 base::RunLoop().RunUntilIdle();
864
865 DoCloseOpenedNoError();
866 }
867
TEST_F(NetworkServiceAsyncSocketTest,PendingEmptyRead)868 TEST_F(NetworkServiceAsyncSocketTest, PendingEmptyRead) {
869 DoOpenClosed();
870
871 ExpectNoSignal();
872
873 async_socket_data_provider_.AddRead(net::MockRead(""));
874 base::RunLoop().RunUntilIdle();
875
876 ExpectSignalSocketState(SignalSocketState::NoError(
877 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
878 }
879
TEST_F(NetworkServiceAsyncSocketTest,PendingReadError)880 TEST_F(NetworkServiceAsyncSocketTest, PendingReadError) {
881 DoOpenClosed();
882
883 ExpectNoSignal();
884
885 async_socket_data_provider_.AddRead(
886 net::MockRead(net::ASYNC, net::ERR_TIMED_OUT));
887 base::RunLoop().RunUntilIdle();
888
889 ExpectSignalSocketState(SignalSocketState(
890 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
891 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
892 }
893
894 // After this we can assume non-SSL Read() works as expected.
895
TEST_F(NetworkServiceAsyncSocketTest,WrongWrite)896 TEST_F(NetworkServiceAsyncSocketTest, WrongWrite) {
897 EXPECT_DEBUG_DEATH(
898 {
899 std::string data("foo");
900 EXPECT_FALSE(ns_async_socket_->Write(data.data(), data.size()));
901 ExpectErrorState(NetworkServiceAsyncSocket::STATE_CLOSED,
902 NetworkServiceAsyncSocket::ERROR_WRONGSTATE);
903 EXPECT_TRUE(ns_async_socket_->Close());
904 },
905 "non-open");
906 }
907
908 const char kWriteData[] = "mydatatowrite";
909
TEST_F(NetworkServiceAsyncSocketTest,SyncWrite)910 TEST_F(NetworkServiceAsyncSocketTest, SyncWrite) {
911 async_socket_data_provider_.AddWrite(
912 net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
913 async_socket_data_provider_.AddWrite(
914 net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
915 async_socket_data_provider_.AddWrite(net::MockWrite(
916 net::SYNCHRONOUS, kWriteData + 8, base::size(kWriteData) - 8));
917 DoOpenClosed();
918
919 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
920 base::RunLoop().RunUntilIdle();
921 EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
922 base::RunLoop().RunUntilIdle();
923 EXPECT_TRUE(
924 ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
925 base::RunLoop().RunUntilIdle();
926
927 ExpectNoSignal();
928
929 DoCloseOpenedNoError();
930 }
931
TEST_F(NetworkServiceAsyncSocketTest,AsyncWrite)932 TEST_F(NetworkServiceAsyncSocketTest, AsyncWrite) {
933 DoOpenClosed();
934
935 async_socket_data_provider_.AddWrite(
936 net::MockWrite(net::ASYNC, kWriteData, 3));
937 async_socket_data_provider_.AddWrite(
938 net::MockWrite(net::ASYNC, kWriteData + 3, 5));
939 async_socket_data_provider_.AddWrite(
940 net::MockWrite(net::ASYNC, kWriteData + 8, base::size(kWriteData) - 8));
941
942 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
943 base::RunLoop().RunUntilIdle();
944 EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
945 base::RunLoop().RunUntilIdle();
946 EXPECT_TRUE(
947 ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
948 base::RunLoop().RunUntilIdle();
949
950 ExpectNoSignal();
951
952 DoCloseOpenedNoError();
953 }
954
TEST_F(NetworkServiceAsyncSocketTest,AsyncWriteError)955 TEST_F(NetworkServiceAsyncSocketTest, AsyncWriteError) {
956 DoOpenClosed();
957
958 async_socket_data_provider_.AddWrite(
959 net::MockWrite(net::ASYNC, kWriteData, 3));
960 async_socket_data_provider_.AddWrite(
961 net::MockWrite(net::ASYNC, kWriteData + 3, 5));
962 async_socket_data_provider_.AddWrite(
963 net::MockWrite(net::ASYNC, net::ERR_TIMED_OUT));
964
965 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
966 base::RunLoop().RunUntilIdle();
967 EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
968 base::RunLoop().RunUntilIdle();
969 EXPECT_TRUE(
970 ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
971 base::RunLoop().RunUntilIdle();
972
973 ExpectSignalSocketState(SignalSocketState(
974 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
975 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_TIMED_OUT));
976 }
977
TEST_F(NetworkServiceAsyncSocketTest,LargeWrite)978 TEST_F(NetworkServiceAsyncSocketTest, LargeWrite) {
979 EXPECT_DEBUG_DEATH(
980 {
981 DoOpenClosed();
982
983 std::string large_data(100, 'x');
984 EXPECT_FALSE(
985 ns_async_socket_->Write(large_data.data(), large_data.size()));
986 ExpectState(NetworkServiceAsyncSocket::STATE_OPEN,
987 NetworkServiceAsyncSocket::ERROR_WINSOCK,
988 net::ERR_INSUFFICIENT_RESOURCES);
989 DoCloseOpened(SignalSocketState(
990 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
991 NetworkServiceAsyncSocket::ERROR_WINSOCK,
992 net::ERR_INSUFFICIENT_RESOURCES));
993 },
994 "exceed the max write buffer");
995 }
996
TEST_F(NetworkServiceAsyncSocketTest,LargeAccumulatedWrite)997 TEST_F(NetworkServiceAsyncSocketTest, LargeAccumulatedWrite) {
998 EXPECT_DEBUG_DEATH(
999 {
1000 DoOpenClosed();
1001
1002 std::string data(15, 'x');
1003 EXPECT_TRUE(ns_async_socket_->Write(data.data(), data.size()));
1004 EXPECT_FALSE(ns_async_socket_->Write(data.data(), data.size()));
1005 ExpectState(NetworkServiceAsyncSocket::STATE_OPEN,
1006 NetworkServiceAsyncSocket::ERROR_WINSOCK,
1007 net::ERR_INSUFFICIENT_RESOURCES);
1008 DoCloseOpened(SignalSocketState(
1009 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1010 NetworkServiceAsyncSocket::ERROR_WINSOCK,
1011 net::ERR_INSUFFICIENT_RESOURCES));
1012 },
1013 "exceed the max write buffer");
1014 }
1015
1016 // After this we can assume non-SSL I/O works as expected.
1017
TEST_F(NetworkServiceAsyncSocketTest,HangingSSLConnect)1018 TEST_F(NetworkServiceAsyncSocketTest, HangingSSLConnect) {
1019 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1020 DoOpenClosed();
1021 ExpectReadSignal();
1022
1023 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1024 ExpectNoSignal();
1025
1026 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_CONNECTING);
1027 EXPECT_TRUE(ns_async_socket_->Close());
1028 ExpectSignalSocketState(SignalSocketState::NoError(
1029 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1030 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_CLOSED);
1031 }
1032
TEST_F(NetworkServiceAsyncSocketTest,ImmediateSSLConnect)1033 TEST_F(NetworkServiceAsyncSocketTest, ImmediateSSLConnect) {
1034 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1035 DoOpenClosed();
1036 ExpectReadSignal();
1037
1038 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1039 base::RunLoop().RunUntilIdle();
1040 ExpectSSLConnectSignal();
1041 ExpectNoSignal();
1042 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1043
1044 DoSSLCloseOpenedNoError();
1045 }
1046
TEST_F(NetworkServiceAsyncSocketTest,DoubleSSLConnect)1047 TEST_F(NetworkServiceAsyncSocketTest, DoubleSSLConnect) {
1048 EXPECT_DEBUG_DEATH(
1049 {
1050 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1051 DoOpenClosed();
1052 ExpectReadSignal();
1053
1054 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1055 base::RunLoop().RunUntilIdle();
1056 ExpectSSLConnectSignal();
1057 ExpectNoSignal();
1058 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1059
1060 EXPECT_FALSE(ns_async_socket_->StartTls("fakedomain.com"));
1061
1062 DoSSLCloseOpened(SignalSocketState(
1063 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1064 NetworkServiceAsyncSocket::ERROR_WRONGSTATE, net::OK));
1065 },
1066 "wrong state");
1067 }
1068
TEST_F(NetworkServiceAsyncSocketTest,FailedSSLConnect)1069 TEST_F(NetworkServiceAsyncSocketTest, FailedSSLConnect) {
1070 ssl_socket_data_provider_.connect =
1071 net::MockConnect(net::ASYNC, net::ERR_CERT_COMMON_NAME_INVALID),
1072
1073 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1074 DoOpenClosed();
1075 ExpectReadSignal();
1076
1077 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1078 base::RunLoop().RunUntilIdle();
1079 ExpectSignalSocketState(
1080 SignalSocketState(SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1081 NetworkServiceAsyncSocket::ERROR_WINSOCK,
1082 net::ERR_CERT_COMMON_NAME_INVALID));
1083
1084 EXPECT_TRUE(ns_async_socket_->Close());
1085 ExpectClosed();
1086 }
1087
TEST_F(NetworkServiceAsyncSocketTest,ReadDuringSSLConnecting)1088 TEST_F(NetworkServiceAsyncSocketTest, ReadDuringSSLConnecting) {
1089 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1090 DoOpenClosed();
1091 ExpectReadSignal();
1092 EXPECT_EQ(kReadData, DrainRead(1));
1093
1094 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1095 ExpectNoSignal();
1096
1097 // Shouldn't do anything.
1098 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1099
1100 char buf[4096];
1101 size_t len_read = 10000U;
1102 EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
1103 EXPECT_EQ(0U, len_read);
1104
1105 base::RunLoop().RunUntilIdle();
1106 ExpectSSLConnectSignal();
1107 ExpectSSLReadSignal();
1108 ExpectNoSignal();
1109 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_OPEN);
1110
1111 len_read = 10000U;
1112 EXPECT_TRUE(ns_async_socket_->Read(buf, sizeof(buf), &len_read));
1113 EXPECT_EQ(kReadData, std::string(buf, len_read));
1114
1115 DoSSLCloseOpenedNoError();
1116 }
1117
TEST_F(NetworkServiceAsyncSocketTest,WriteDuringSSLConnecting)1118 TEST_F(NetworkServiceAsyncSocketTest, WriteDuringSSLConnecting) {
1119 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1120 DoOpenClosed();
1121 ExpectReadSignal();
1122
1123 EXPECT_TRUE(ns_async_socket_->StartTls("fakedomain.com"));
1124 ExpectNoSignal();
1125 ExpectNonErrorState(NetworkServiceAsyncSocket::STATE_TLS_CONNECTING);
1126
1127 async_socket_data_provider_.AddWrite(
1128 net::MockWrite(net::ASYNC, kWriteData, 3));
1129
1130 // Shouldn't do anything.
1131 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1132
1133 // TODO(akalin): Figure out how to test that the write happens
1134 // *after* the SSL connect.
1135
1136 base::RunLoop().RunUntilIdle();
1137 ExpectSSLConnectSignal();
1138 ExpectNoSignal();
1139
1140 base::RunLoop().RunUntilIdle();
1141
1142 DoSSLCloseOpenedNoError();
1143 }
1144
1145 // After this we can assume SSL connect works as expected.
1146
TEST_F(NetworkServiceAsyncSocketTest,SSLRead)1147 TEST_F(NetworkServiceAsyncSocketTest, SSLRead) {
1148 DoSSLOpenClosed();
1149 async_socket_data_provider_.AddRead(net::MockRead(kReadData));
1150 base::RunLoop().RunUntilIdle();
1151
1152 ExpectSSLReadSignal();
1153 ExpectNoSignal();
1154
1155 EXPECT_EQ(kReadData, DrainRead(1));
1156
1157 base::RunLoop().RunUntilIdle();
1158
1159 DoSSLCloseOpenedNoError();
1160 }
1161
TEST_F(NetworkServiceAsyncSocketTest,SSLSyncWrite)1162 TEST_F(NetworkServiceAsyncSocketTest, SSLSyncWrite) {
1163 async_socket_data_provider_.AddWrite(
1164 net::MockWrite(net::SYNCHRONOUS, kWriteData, 3));
1165 async_socket_data_provider_.AddWrite(
1166 net::MockWrite(net::SYNCHRONOUS, kWriteData + 3, 5));
1167 async_socket_data_provider_.AddWrite(net::MockWrite(
1168 net::SYNCHRONOUS, kWriteData + 8, base::size(kWriteData) - 8));
1169 DoSSLOpenClosed();
1170
1171 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1172 base::RunLoop().RunUntilIdle();
1173 EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
1174 base::RunLoop().RunUntilIdle();
1175 EXPECT_TRUE(
1176 ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
1177 base::RunLoop().RunUntilIdle();
1178
1179 ExpectNoSignal();
1180
1181 DoSSLCloseOpenedNoError();
1182 }
1183
TEST_F(NetworkServiceAsyncSocketTest,SSLAsyncWrite)1184 TEST_F(NetworkServiceAsyncSocketTest, SSLAsyncWrite) {
1185 DoSSLOpenClosed();
1186
1187 async_socket_data_provider_.AddWrite(
1188 net::MockWrite(net::ASYNC, kWriteData, 3));
1189 async_socket_data_provider_.AddWrite(
1190 net::MockWrite(net::ASYNC, kWriteData + 3, 5));
1191 async_socket_data_provider_.AddWrite(
1192 net::MockWrite(net::ASYNC, kWriteData + 8, base::size(kWriteData) - 8));
1193
1194 EXPECT_TRUE(ns_async_socket_->Write(kWriteData, 3));
1195 base::RunLoop().RunUntilIdle();
1196 EXPECT_TRUE(ns_async_socket_->Write(kWriteData + 3, 5));
1197 base::RunLoop().RunUntilIdle();
1198 EXPECT_TRUE(
1199 ns_async_socket_->Write(kWriteData + 8, base::size(kWriteData) - 8));
1200 base::RunLoop().RunUntilIdle();
1201
1202 ExpectNoSignal();
1203
1204 DoSSLCloseOpenedNoError();
1205 }
1206
1207 class NetworkServiceAsyncSocketMojoTest : public NetworkServiceAsyncSocketTest {
1208 protected:
NetworkServiceAsyncSocketMojoTest()1209 NetworkServiceAsyncSocketMojoTest()
1210 : NetworkServiceAsyncSocketTest(true /* use_mojo_level_mock */) {}
~NetworkServiceAsyncSocketMojoTest()1211 ~NetworkServiceAsyncSocketMojoTest() override {}
1212 };
1213
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadEOF1)1214 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadEOF1) {
1215 DoOpenClosed();
1216 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1217 {MockProxyResolvingSocket::kRead,
1218 MockProxyResolvingSocket::kCloseReadPipe,
1219 MockProxyResolvingSocket::kReadEofError,
1220 MockProxyResolvingSocket::kCloseObserverPipe});
1221
1222 ExpectReadSignal();
1223 ExpectNoSignal();
1224 EXPECT_EQ("data", DrainRead(1));
1225
1226 base::RunLoop().RunUntilIdle();
1227 ExpectSignalSocketState(SignalSocketState::NoError(
1228 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1229 ExpectClosed();
1230 }
1231
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadEOF2)1232 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadEOF2) {
1233 DoOpenClosed();
1234 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1235 {MockProxyResolvingSocket::kReadEofError,
1236 MockProxyResolvingSocket::kCloseObserverPipe,
1237 MockProxyResolvingSocket::kRead,
1238 MockProxyResolvingSocket::kCloseReadPipe});
1239
1240 ExpectReadSignal();
1241 ExpectNoSignal();
1242 EXPECT_EQ("data", DrainRead(1));
1243
1244 base::RunLoop().RunUntilIdle();
1245 ExpectSignalSocketState(SignalSocketState::NoError(
1246 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED));
1247 ExpectClosed();
1248 }
1249
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadError1)1250 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadError1) {
1251 DoOpenClosed();
1252 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1253 {MockProxyResolvingSocket::kRead,
1254 MockProxyResolvingSocket::kCloseReadPipe,
1255 MockProxyResolvingSocket::kReadError,
1256 MockProxyResolvingSocket::kCloseObserverPipe});
1257
1258 ExpectReadSignal();
1259 ExpectNoSignal();
1260 EXPECT_EQ("data", DrainRead(1));
1261
1262 base::RunLoop().RunUntilIdle();
1263 ExpectSignalSocketState(SignalSocketState(
1264 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1265 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1266 ExpectClosed();
1267 }
1268
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadError2)1269 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadError2) {
1270 DoOpenClosed();
1271 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1272 {MockProxyResolvingSocket::kReadError,
1273 MockProxyResolvingSocket::kCloseObserverPipe,
1274 MockProxyResolvingSocket::kRead,
1275 MockProxyResolvingSocket::kCloseReadPipe});
1276
1277 ExpectReadSignal();
1278 ExpectNoSignal();
1279 EXPECT_EQ("data", DrainRead(1));
1280
1281 base::RunLoop().RunUntilIdle();
1282 ExpectSignalSocketState(SignalSocketState(
1283 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1284 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1285 ExpectClosed();
1286 }
1287
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDouble)1288 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDouble) {
1289 DoOpenClosed();
1290 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1291 {MockProxyResolvingSocket::kReadError,
1292 MockProxyResolvingSocket::kReadError,
1293 MockProxyResolvingSocket::kCloseObserverPipe,
1294 MockProxyResolvingSocket::kRead,
1295 MockProxyResolvingSocket::kCloseReadPipe});
1296
1297 ExpectReadSignal();
1298 ExpectNoSignal();
1299 EXPECT_EQ("data", DrainRead(1));
1300
1301 base::RunLoop().RunUntilIdle();
1302 ExpectSignalSocketState(SignalSocketState(
1303 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1304 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1305 ExpectClosed();
1306 }
1307
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDoubleInvalid)1308 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDoubleInvalid) {
1309 DoOpenClosed();
1310 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1311 {MockProxyResolvingSocket::kReadError,
1312 MockProxyResolvingSocket::kReadErrorInvalid,
1313 MockProxyResolvingSocket::kCloseObserverPipe,
1314 MockProxyResolvingSocket::kRead,
1315 MockProxyResolvingSocket::kCloseReadPipe});
1316
1317 ExpectReadSignal();
1318 ExpectNoSignal();
1319 EXPECT_EQ("data", DrainRead(1));
1320
1321 base::RunLoop().RunUntilIdle();
1322 ExpectSignalSocketState(SignalSocketState(
1323 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1324 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_OUT_OF_MEMORY));
1325 ExpectClosed();
1326 }
1327
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorDoubleInvalid2)1328 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorDoubleInvalid2) {
1329 DoOpenClosed();
1330 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1331 {MockProxyResolvingSocket::kReadErrorInvalid,
1332 MockProxyResolvingSocket::kReadError,
1333 MockProxyResolvingSocket::kCloseObserverPipe,
1334 MockProxyResolvingSocket::kRead,
1335 MockProxyResolvingSocket::kCloseReadPipe});
1336
1337 ExpectReadSignal();
1338 ExpectNoSignal();
1339 EXPECT_EQ("data", DrainRead(1));
1340
1341 base::RunLoop().RunUntilIdle();
1342 ExpectSignalSocketState(SignalSocketState(
1343 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1344 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1345 ExpectClosed();
1346 }
1347
TEST_F(NetworkServiceAsyncSocketMojoTest,ReadErrorClosedObserverPipe)1348 TEST_F(NetworkServiceAsyncSocketMojoTest, ReadErrorClosedObserverPipe) {
1349 DoOpenClosed();
1350 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1351 {MockProxyResolvingSocket::kRead,
1352 MockProxyResolvingSocket::kCloseObserverPipe});
1353 // Can't run kCloseReadPipe since it'll already be closed.
1354
1355 ExpectReadSignal();
1356 // Since this is a misbehaving network service process scenario, no attempt
1357 // to recover the data is made.
1358 ExpectSignalSocketState(SignalSocketState(
1359 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1360 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1361 ExpectClosed();
1362 }
1363
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteError1)1364 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteError1) {
1365 DoOpenClosed();
1366 ExpectNoSignal();
1367 ns_async_socket_->Write("atad", 4);
1368 base::RunLoop().RunUntilIdle();
1369
1370 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1371 {MockProxyResolvingSocket::kWrite,
1372 MockProxyResolvingSocket::kCloseWritePipe,
1373 MockProxyResolvingSocket::kWriteError});
1374 // Cannot close the observer pipe here at the end since the other size
1375 // would have closed it already.
1376
1377 base::RunLoop().RunUntilIdle();
1378 ExpectSignalSocketState(SignalSocketState(
1379 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1380 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1381 ExpectClosed();
1382 }
1383
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteError2)1384 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteError2) {
1385 DoOpenClosed();
1386 ExpectNoSignal();
1387 ns_async_socket_->Write("atad", 4);
1388 base::RunLoop().RunUntilIdle();
1389
1390 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1391 {MockProxyResolvingSocket::kWriteError,
1392 MockProxyResolvingSocket::kCloseObserverPipe,
1393 MockProxyResolvingSocket::kWrite,
1394 MockProxyResolvingSocket::kCloseWritePipe});
1395
1396 base::RunLoop().RunUntilIdle();
1397 ExpectSignalSocketState(SignalSocketState(
1398 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1399 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1400 ExpectClosed();
1401 }
1402
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDouble)1403 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDouble) {
1404 DoOpenClosed();
1405 ExpectNoSignal();
1406 ns_async_socket_->Write("atad", 4);
1407 base::RunLoop().RunUntilIdle();
1408
1409 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1410 {MockProxyResolvingSocket::kWriteError,
1411 MockProxyResolvingSocket::kWriteError,
1412 MockProxyResolvingSocket::kCloseObserverPipe,
1413 MockProxyResolvingSocket::kWrite,
1414 MockProxyResolvingSocket::kCloseWritePipe});
1415
1416 base::RunLoop().RunUntilIdle();
1417 ExpectSignalSocketState(SignalSocketState(
1418 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1419 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1420 ExpectClosed();
1421 }
1422
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDoubleInvalid)1423 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDoubleInvalid) {
1424 DoOpenClosed();
1425 ExpectNoSignal();
1426 ns_async_socket_->Write("atad", 4);
1427 base::RunLoop().RunUntilIdle();
1428
1429 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1430 {MockProxyResolvingSocket::kWriteError,
1431 MockProxyResolvingSocket::kWriteErrorInvalid,
1432 MockProxyResolvingSocket::kCloseObserverPipe,
1433 MockProxyResolvingSocket::kWrite,
1434 MockProxyResolvingSocket::kCloseWritePipe});
1435
1436 base::RunLoop().RunUntilIdle();
1437 ExpectSignalSocketState(SignalSocketState(
1438 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1439 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_ACCESS_DENIED));
1440 ExpectClosed();
1441 }
1442
TEST_F(NetworkServiceAsyncSocketMojoTest,WriteErrorDoubleInvalid2)1443 TEST_F(NetworkServiceAsyncSocketMojoTest, WriteErrorDoubleInvalid2) {
1444 DoOpenClosed();
1445 ExpectNoSignal();
1446 ns_async_socket_->Write("atad", 4);
1447 base::RunLoop().RunUntilIdle();
1448
1449 mock_proxy_resolving_socket_factory_->socket()->RunEvents(
1450 {MockProxyResolvingSocket::kWriteErrorInvalid,
1451 MockProxyResolvingSocket::kWriteError,
1452 MockProxyResolvingSocket::kCloseObserverPipe,
1453 MockProxyResolvingSocket::kWrite,
1454 MockProxyResolvingSocket::kCloseWritePipe});
1455
1456 base::RunLoop().RunUntilIdle();
1457 ExpectSignalSocketState(SignalSocketState(
1458 SIGNAL_CLOSE, NetworkServiceAsyncSocket::STATE_CLOSED,
1459 NetworkServiceAsyncSocket::ERROR_WINSOCK, net::ERR_FAILED));
1460 ExpectClosed();
1461 }
1462
1463 } // namespace
1464
1465 } // namespace jingle_glue
1466