quic_proxy_client_socket_unittest.cc 79 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091
  1. // Copyright (c) 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/quic/quic_proxy_client_socket.h"
  5. #include <memory>
  6. #include <tuple>
  7. #include <utility>
  8. #include <vector>
  9. #include "base/bind.h"
  10. #include "base/memory/ptr_util.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/run_loop.h"
  13. #include "base/strings/strcat.h"
  14. #include "base/strings/utf_string_conversions.h"
  15. #include "base/threading/thread_task_runner_handle.h"
  16. #include "base/time/default_tick_clock.h"
  17. #include "net/base/proxy_server.h"
  18. #include "net/base/proxy_string_util.h"
  19. #include "net/base/test_proxy_delegate.h"
  20. #include "net/dns/mock_host_resolver.h"
  21. #include "net/dns/public/secure_dns_policy.h"
  22. #include "net/http/http_auth_cache.h"
  23. #include "net/http/http_auth_handler_factory.h"
  24. #include "net/http/http_response_headers.h"
  25. #include "net/http/transport_security_state.h"
  26. #include "net/log/net_log.h"
  27. #include "net/log/test_net_log.h"
  28. #include "net/log/test_net_log_util.h"
  29. #include "net/quic/address_utils.h"
  30. #include "net/quic/crypto/proof_verifier_chromium.h"
  31. #include "net/quic/mock_crypto_client_stream_factory.h"
  32. #include "net/quic/mock_quic_data.h"
  33. #include "net/quic/quic_chromium_alarm_factory.h"
  34. #include "net/quic/quic_chromium_client_session.h"
  35. #include "net/quic/quic_chromium_connection_helper.h"
  36. #include "net/quic/quic_chromium_packet_writer.h"
  37. #include "net/quic/quic_crypto_client_config_handle.h"
  38. #include "net/quic/quic_http_utils.h"
  39. #include "net/quic/quic_server_info.h"
  40. #include "net/quic/quic_stream_factory.h"
  41. #include "net/quic/quic_test_packet_maker.h"
  42. #include "net/quic/test_quic_crypto_client_config_handle.h"
  43. #include "net/quic/test_task_runner.h"
  44. #include "net/socket/socket_test_util.h"
  45. #include "net/test/cert_test_util.h"
  46. #include "net/test/gtest_util.h"
  47. #include "net/test/test_data_directory.h"
  48. #include "net/test/test_with_task_environment.h"
  49. #include "net/third_party/quiche/src/quiche/quic/core/crypto/null_encrypter.h"
  50. #include "net/third_party/quiche/src/quiche/quic/core/quic_utils.h"
  51. #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
  52. #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_clock.h"
  53. #include "net/third_party/quiche/src/quiche/quic/test_tools/mock_random.h"
  54. #include "net/third_party/quiche/src/quiche/quic/test_tools/qpack/qpack_test_utils.h"
  55. #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_connection_peer.h"
  56. #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
  57. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  58. #include "testing/gmock/include/gmock/gmock.h"
  59. #include "testing/gtest/include/gtest/gtest.h"
  60. #include "url/gurl.h"
  61. #include "url/scheme_host_port.h"
  62. #include "url/url_constants.h"
  63. using testing::_;
  64. using testing::AnyNumber;
  65. using testing::Return;
  66. namespace net::test {
  67. namespace {
  68. static const char kOriginHost[] = "www.google.com";
  69. static const int kOriginPort = 443;
  70. static const char kProxyUrl[] = "https://myproxy:6121/";
  71. static const char kProxyHost[] = "myproxy";
  72. static const int kProxyPort = 6121;
  73. static const char kUserAgent[] = "Mozilla/1.0";
  74. static const char kRedirectUrl[] = "https://example.com/";
  75. static const char kMsg1[] = "\0hello!\xff";
  76. static const int kLen1 = 8;
  77. static const char kMsg2[] = "\0a2345678\0";
  78. static const int kLen2 = 10;
  79. static const char kMsg3[] = "bye!";
  80. static const int kLen3 = 4;
  81. static const char kMsg33[] = "bye!bye!";
  82. static const int kLen33 = kLen3 + kLen3;
  83. static const char kMsg333[] = "bye!bye!bye!";
  84. static const int kLen333 = kLen3 + kLen3 + kLen3;
  85. struct TestParams {
  86. quic::ParsedQuicVersion version;
  87. bool client_headers_include_h2_stream_dependency;
  88. };
  89. // Used by ::testing::PrintToStringParamName().
  90. std::string PrintToString(const TestParams& p) {
  91. return base::StrCat(
  92. {ParsedQuicVersionToString(p.version), "_",
  93. (p.client_headers_include_h2_stream_dependency ? "" : "No"),
  94. "Dependency"});
  95. }
  96. std::vector<TestParams> GetTestParams() {
  97. std::vector<TestParams> params;
  98. quic::ParsedQuicVersionVector all_supported_versions =
  99. quic::AllSupportedVersions();
  100. for (const auto& version : all_supported_versions) {
  101. params.push_back(TestParams{version, false});
  102. params.push_back(TestParams{version, true});
  103. }
  104. return params;
  105. }
  106. } // anonymous namespace
  107. class QuicProxyClientSocketTest : public ::testing::TestWithParam<TestParams>,
  108. public WithTaskEnvironment {
  109. protected:
  110. static const bool kFin = true;
  111. static const bool kIncludeVersion = true;
  112. static const bool kIncludeDiversificationNonce = true;
  113. static size_t GetStreamFrameDataLengthFromPacketLength(
  114. quic::QuicByteCount packet_length,
  115. quic::ParsedQuicVersion version,
  116. bool include_version,
  117. bool include_diversification_nonce,
  118. quic::QuicConnectionIdLength connection_id_length,
  119. quic::QuicPacketNumberLength packet_number_length,
  120. quic::QuicStreamOffset offset) {
  121. quiche::QuicheVariableLengthIntegerLength retry_token_length_length =
  122. quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
  123. quiche::QuicheVariableLengthIntegerLength length_length =
  124. quic::QuicVersionHasLongHeaderLengths(version.transport_version) &&
  125. include_version
  126. ? quiche::VARIABLE_LENGTH_INTEGER_LENGTH_2
  127. : quiche::VARIABLE_LENGTH_INTEGER_LENGTH_0;
  128. size_t min_data_length = 1;
  129. size_t min_packet_length =
  130. quic::NullEncrypter(quic::Perspective::IS_CLIENT)
  131. .GetCiphertextSize(min_data_length) +
  132. quic::QuicPacketCreator::StreamFramePacketOverhead(
  133. version.transport_version, quic::PACKET_8BYTE_CONNECTION_ID,
  134. quic::PACKET_0BYTE_CONNECTION_ID, include_version,
  135. include_diversification_nonce, packet_number_length,
  136. retry_token_length_length, length_length, offset);
  137. DCHECK(packet_length >= min_packet_length);
  138. return min_data_length + packet_length - min_packet_length;
  139. }
  140. QuicProxyClientSocketTest()
  141. : version_(GetParam().version),
  142. client_data_stream_id1_(
  143. quic::VersionUsesHttp3(version_.transport_version)
  144. ? quic::QuicUtils::GetFirstBidirectionalStreamId(
  145. version_.transport_version,
  146. quic::Perspective::IS_CLIENT)
  147. : quic::QuicUtils::GetFirstBidirectionalStreamId(
  148. version_.transport_version,
  149. quic::Perspective::IS_CLIENT) +
  150. quic::QuicUtils::StreamIdDelta(
  151. version_.transport_version)),
  152. client_headers_include_h2_stream_dependency_(
  153. GetParam().client_headers_include_h2_stream_dependency),
  154. mock_quic_data_(version_),
  155. crypto_config_(
  156. quic::test::crypto_test_utils::ProofVerifierForTesting()),
  157. connection_id_(quic::test::TestConnectionId(2)),
  158. client_maker_(version_,
  159. connection_id_,
  160. &clock_,
  161. kProxyHost,
  162. quic::Perspective::IS_CLIENT,
  163. client_headers_include_h2_stream_dependency_),
  164. server_maker_(version_,
  165. connection_id_,
  166. &clock_,
  167. kProxyHost,
  168. quic::Perspective::IS_SERVER,
  169. false),
  170. user_agent_(kUserAgent),
  171. proxy_endpoint_(url::kHttpsScheme, kProxyHost, kProxyPort),
  172. destination_endpoint_(url::kHttpsScheme, kOriginHost, kOriginPort),
  173. http_auth_cache_(
  174. false /* key_server_entries_by_network_isolation_key */),
  175. host_resolver_(std::make_unique<MockCachingHostResolver>()),
  176. http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()) {
  177. FLAGS_quic_enable_http3_grease_randomness = false;
  178. IPAddress ip(192, 0, 2, 33);
  179. peer_addr_ = IPEndPoint(ip, 443);
  180. clock_.AdvanceTime(quic::QuicTime::Delta::FromMilliseconds(20));
  181. quic::QuicEnableVersion(version_);
  182. }
  183. QuicProxyClientSocketTest(const QuicProxyClientSocketTest&) = delete;
  184. QuicProxyClientSocketTest& operator=(const QuicProxyClientSocketTest&) =
  185. delete;
  186. void SetUp() override {}
  187. void TearDown() override {
  188. sock_.reset();
  189. EXPECT_TRUE(mock_quic_data_.AllReadDataConsumed());
  190. EXPECT_TRUE(mock_quic_data_.AllWriteDataConsumed());
  191. }
  192. void Initialize() {
  193. auto socket = std::make_unique<MockUDPClientSocket>(
  194. mock_quic_data_.InitializeAndGetSequencedSocketData(), NetLog::Get());
  195. socket->Connect(peer_addr_);
  196. runner_ = base::MakeRefCounted<TestTaskRunner>(&clock_);
  197. send_algorithm_ = new quic::test::MockSendAlgorithm();
  198. EXPECT_CALL(*send_algorithm_, InRecovery()).WillRepeatedly(Return(false));
  199. EXPECT_CALL(*send_algorithm_, InSlowStart()).WillRepeatedly(Return(false));
  200. EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
  201. .Times(testing::AtLeast(1));
  202. EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
  203. .WillRepeatedly(Return(quic::kMaxOutgoingPacketSize));
  204. EXPECT_CALL(*send_algorithm_, PacingRate(_))
  205. .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
  206. EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
  207. EXPECT_CALL(*send_algorithm_, BandwidthEstimate())
  208. .WillRepeatedly(Return(quic::QuicBandwidth::Zero()));
  209. EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)).Times(AnyNumber());
  210. EXPECT_CALL(*send_algorithm_, OnApplicationLimited(_)).Times(AnyNumber());
  211. EXPECT_CALL(*send_algorithm_, GetCongestionControlType())
  212. .Times(AnyNumber());
  213. helper_ = std::make_unique<QuicChromiumConnectionHelper>(
  214. &clock_, &random_generator_);
  215. alarm_factory_ =
  216. std::make_unique<QuicChromiumAlarmFactory>(runner_.get(), &clock_);
  217. QuicChromiumPacketWriter* writer = new QuicChromiumPacketWriter(
  218. socket.get(), base::ThreadTaskRunnerHandle::Get().get());
  219. quic::QuicConnection* connection = new quic::QuicConnection(
  220. connection_id_, quic::QuicSocketAddress(),
  221. net::ToQuicSocketAddress(peer_addr_), helper_.get(),
  222. alarm_factory_.get(), writer, true /* owns_writer */,
  223. quic::Perspective::IS_CLIENT, quic::test::SupportedVersions(version_));
  224. connection->set_visitor(&visitor_);
  225. quic::test::QuicConnectionPeer::SetSendAlgorithm(connection,
  226. send_algorithm_);
  227. // Load a certificate that is valid for *.example.org
  228. scoped_refptr<X509Certificate> test_cert(
  229. ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
  230. EXPECT_TRUE(test_cert.get());
  231. verify_details_.cert_verify_result.verified_cert = test_cert;
  232. verify_details_.cert_verify_result.is_issued_by_known_root = true;
  233. crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
  234. base::TimeTicks dns_end = base::TimeTicks::Now();
  235. base::TimeTicks dns_start = dns_end - base::Milliseconds(1);
  236. session_ = std::make_unique<QuicChromiumClientSession>(
  237. connection, std::move(socket),
  238. /*stream_factory=*/nullptr, &crypto_client_stream_factory_, &clock_,
  239. &transport_security_state_, /*ssl_config_service=*/nullptr,
  240. base::WrapUnique(static_cast<QuicServerInfo*>(nullptr)),
  241. QuicSessionKey("mail.example.org", 80, PRIVACY_MODE_DISABLED,
  242. SocketTag(), NetworkIsolationKey(),
  243. SecureDnsPolicy::kAllow,
  244. /*require_dns_https_alpn=*/false),
  245. /*require_confirmation=*/false,
  246. /*migrate_session_early_v2=*/false,
  247. /*migrate_session_on_network_change_v2=*/false,
  248. /*default_network=*/handles::kInvalidNetworkHandle,
  249. quic::QuicTime::Delta::FromMilliseconds(
  250. kDefaultRetransmittableOnWireTimeout.InMilliseconds()),
  251. /*migrate_idle_session=*/true, /*allow_port_migration=*/false,
  252. kDefaultIdleSessionMigrationPeriod, kMaxTimeOnNonDefaultNetwork,
  253. kMaxMigrationsToNonDefaultNetworkOnWriteError,
  254. kMaxMigrationsToNonDefaultNetworkOnPathDegrading,
  255. kQuicYieldAfterPacketsRead,
  256. quic::QuicTime::Delta::FromMilliseconds(
  257. kQuicYieldAfterDurationMilliseconds),
  258. client_headers_include_h2_stream_dependency_, /*cert_verify_flags=*/0,
  259. quic::test::DefaultQuicConfig(),
  260. std::make_unique<TestQuicCryptoClientConfigHandle>(&crypto_config_),
  261. "CONNECTION_UNKNOWN", dns_start, dns_end,
  262. std::make_unique<quic::QuicClientPushPromiseIndex>(), nullptr,
  263. base::DefaultTickClock::GetInstance(),
  264. base::ThreadTaskRunnerHandle::Get().get(),
  265. /*socket_performance_watcher=*/nullptr, NetLog::Get());
  266. writer->set_delegate(session_.get());
  267. session_->Initialize();
  268. // Blackhole QPACK decoder stream instead of constructing mock writes.
  269. if (VersionUsesHttp3(version_.transport_version)) {
  270. session_->qpack_decoder()->set_qpack_stream_sender_delegate(
  271. &noop_qpack_stream_sender_delegate_);
  272. }
  273. TestCompletionCallback callback;
  274. EXPECT_THAT(session_->CryptoConnect(callback.callback()), IsOk());
  275. EXPECT_TRUE(session_->OneRttKeysAvailable());
  276. session_handle_ = session_->CreateHandle(
  277. url::SchemeHostPort(url::kHttpsScheme, "mail.example.org", 80));
  278. EXPECT_THAT(session_handle_->RequestStream(true, callback.callback(),
  279. TRAFFIC_ANNOTATION_FOR_TESTS),
  280. IsOk());
  281. std::unique_ptr<QuicChromiumClientStream::Handle> stream_handle =
  282. session_handle_->ReleaseStream();
  283. EXPECT_TRUE(stream_handle->IsOpen());
  284. sock_ = std::make_unique<QuicProxyClientSocket>(
  285. std::move(stream_handle), std::move(session_handle_),
  286. // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
  287. // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
  288. ProxyServer(ProxyServer::SCHEME_HTTPS,
  289. HostPortPair::FromSchemeHostPort(proxy_endpoint_)),
  290. user_agent_,
  291. // TODO(crbug.com/1206799) Construct `QuicProxyClientSocket` with plain
  292. // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
  293. HostPortPair::FromSchemeHostPort(destination_endpoint_),
  294. NetLogWithSource::Make(NetLogSourceType::NONE),
  295. base::MakeRefCounted<HttpAuthController>(
  296. HttpAuth::AUTH_PROXY, proxy_endpoint_.GetURL(),
  297. NetworkIsolationKey(), &http_auth_cache_,
  298. http_auth_handler_factory_.get(), host_resolver_.get()),
  299. proxy_delegate_.get());
  300. session_->StartReading();
  301. }
  302. void PopulateConnectRequestIR(spdy::Http2HeaderBlock* block) {
  303. (*block)[":method"] = "CONNECT";
  304. (*block)[":authority"] =
  305. HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
  306. (*block)["user-agent"] = kUserAgent;
  307. }
  308. // Helper functions for constructing packets sent by the client
  309. std::unique_ptr<quic::QuicReceivedPacket> ConstructSettingsPacket(
  310. uint64_t packet_number) {
  311. return client_maker_.MakeInitialSettingsPacket(packet_number);
  312. }
  313. std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstOnlyPacket(
  314. uint64_t packet_number,
  315. quic::QuicRstStreamErrorCode error_code,
  316. uint64_t largest_received,
  317. uint64_t smallest_received) {
  318. return client_maker_.MakeAckAndRstPacket(
  319. packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
  320. largest_received, smallest_received,
  321. /*include_stop_sending_if_v99=*/false);
  322. }
  323. std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndRstPacket(
  324. uint64_t packet_number,
  325. quic::QuicRstStreamErrorCode error_code,
  326. uint64_t largest_received,
  327. uint64_t smallest_received) {
  328. return client_maker_.MakeAckAndRstPacket(
  329. packet_number, !kIncludeVersion, client_data_stream_id1_, error_code,
  330. largest_received, smallest_received,
  331. /*include_stop_sending_if_v99=*/true);
  332. }
  333. std::unique_ptr<quic::QuicReceivedPacket> ConstructRstPacket(
  334. uint64_t packet_number,
  335. quic::QuicRstStreamErrorCode error_code) {
  336. return client_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
  337. client_data_stream_id1_, error_code,
  338. /*include_stop_sending_if_v99=*/true);
  339. }
  340. std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectRequestPacket(
  341. uint64_t packet_number,
  342. RequestPriority request_priority = LOWEST) {
  343. spdy::Http2HeaderBlock block;
  344. PopulateConnectRequestIR(&block);
  345. return client_maker_.MakeRequestHeadersPacket(
  346. packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
  347. ConvertRequestPriorityToQuicPriority(request_priority),
  348. std::move(block), 0, nullptr);
  349. }
  350. std::unique_ptr<quic::QuicReceivedPacket>
  351. ConstructConnectRequestPacketWithExtraHeaders(
  352. uint64_t packet_number,
  353. std::vector<std::pair<std::string, std::string>> extra_headers,
  354. RequestPriority request_priority = LOWEST) {
  355. spdy::Http2HeaderBlock block;
  356. block[":method"] = "CONNECT";
  357. block[":authority"] =
  358. HostPortPair::FromSchemeHostPort(destination_endpoint_).ToString();
  359. for (const auto& header : extra_headers) {
  360. block[header.first] = header.second;
  361. }
  362. return client_maker_.MakeRequestHeadersPacket(
  363. packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
  364. ConvertRequestPriorityToQuicPriority(request_priority),
  365. std::move(block), 0, nullptr);
  366. }
  367. std::unique_ptr<quic::QuicReceivedPacket> ConstructConnectAuthRequestPacket(
  368. uint64_t packet_number) {
  369. RequestPriority request_priority = LOWEST;
  370. spdy::Http2HeaderBlock block;
  371. PopulateConnectRequestIR(&block);
  372. block["proxy-authorization"] = "Basic Zm9vOmJhcg==";
  373. return client_maker_.MakeRequestHeadersPacket(
  374. packet_number, client_data_stream_id1_, kIncludeVersion, !kFin,
  375. ConvertRequestPriorityToQuicPriority(request_priority),
  376. std::move(block), 0, nullptr);
  377. }
  378. std::unique_ptr<quic::QuicReceivedPacket> ConstructDataPacket(
  379. uint64_t packet_number,
  380. absl::string_view data) {
  381. return client_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
  382. !kIncludeVersion, !kFin, data);
  383. }
  384. std::unique_ptr<quic::QuicReceivedPacket> ConstructAckAndDataPacket(
  385. uint64_t packet_number,
  386. uint64_t largest_received,
  387. uint64_t smallest_received,
  388. absl::string_view data) {
  389. return client_maker_.MakeAckAndDataPacket(
  390. packet_number, !kIncludeVersion, client_data_stream_id1_,
  391. largest_received, smallest_received, !kFin, data);
  392. }
  393. std::unique_ptr<quic::QuicReceivedPacket> ConstructAckPacket(
  394. uint64_t packet_number,
  395. uint64_t largest_received,
  396. uint64_t smallest_received) {
  397. return client_maker_.MakeAckPacket(packet_number, largest_received,
  398. smallest_received);
  399. }
  400. // Helper functions for constructing packets sent by the server
  401. std::unique_ptr<quic::QuicReceivedPacket> ConstructServerRstPacket(
  402. uint64_t packet_number,
  403. quic::QuicRstStreamErrorCode error_code) {
  404. return server_maker_.MakeRstPacket(packet_number, !kIncludeVersion,
  405. client_data_stream_id1_, error_code,
  406. /*include_stop_sending_if_v99=*/true);
  407. }
  408. std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataPacket(
  409. uint64_t packet_number,
  410. absl::string_view data) {
  411. return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
  412. !kIncludeVersion, !kFin, data);
  413. }
  414. std::unique_ptr<quic::QuicReceivedPacket> ConstructServerDataFinPacket(
  415. uint64_t packet_number,
  416. absl::string_view data) {
  417. return server_maker_.MakeDataPacket(packet_number, client_data_stream_id1_,
  418. !kIncludeVersion, kFin, data);
  419. }
  420. std::unique_ptr<quic::QuicReceivedPacket> ConstructServerConnectReplyPacket(
  421. uint64_t packet_number,
  422. bool fin,
  423. size_t* header_length = nullptr) {
  424. spdy::Http2HeaderBlock block;
  425. block[":status"] = "200";
  426. return server_maker_.MakeResponseHeadersPacket(
  427. packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
  428. std::move(block), header_length);
  429. }
  430. std::unique_ptr<quic::QuicReceivedPacket>
  431. ConstructServerConnectReplyPacketWithExtraHeaders(
  432. uint64_t packet_number,
  433. bool fin,
  434. std::vector<std::pair<std::string, std::string>> extra_headers) {
  435. spdy::Http2HeaderBlock block;
  436. block[":status"] = "200";
  437. for (const auto& header : extra_headers) {
  438. block[header.first] = header.second;
  439. }
  440. return server_maker_.MakeResponseHeadersPacket(
  441. packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
  442. std::move(block), nullptr);
  443. }
  444. std::unique_ptr<quic::QuicReceivedPacket>
  445. ConstructServerConnectAuthReplyPacket(uint64_t packet_number, bool fin) {
  446. spdy::Http2HeaderBlock block;
  447. block[":status"] = "407";
  448. block["proxy-authenticate"] = "Basic realm=\"MyRealm1\"";
  449. return server_maker_.MakeResponseHeadersPacket(
  450. packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
  451. std::move(block), nullptr);
  452. }
  453. std::unique_ptr<quic::QuicReceivedPacket>
  454. ConstructServerConnectRedirectReplyPacket(uint64_t packet_number, bool fin) {
  455. spdy::Http2HeaderBlock block;
  456. block[":status"] = "302";
  457. block["location"] = kRedirectUrl;
  458. block["set-cookie"] = "foo=bar";
  459. return server_maker_.MakeResponseHeadersPacket(
  460. packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
  461. std::move(block), nullptr);
  462. }
  463. std::unique_ptr<quic::QuicReceivedPacket>
  464. ConstructServerConnectErrorReplyPacket(uint64_t packet_number, bool fin) {
  465. spdy::Http2HeaderBlock block;
  466. block[":status"] = "500";
  467. return server_maker_.MakeResponseHeadersPacket(
  468. packet_number, client_data_stream_id1_, !kIncludeVersion, fin,
  469. std::move(block), nullptr);
  470. }
  471. void AssertConnectSucceeds() {
  472. TestCompletionCallback callback;
  473. ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
  474. ASSERT_THAT(callback.WaitForResult(), IsOk());
  475. }
  476. void AssertConnectFails(int result) {
  477. TestCompletionCallback callback;
  478. ASSERT_THAT(sock_->Connect(callback.callback()), IsError(ERR_IO_PENDING));
  479. ASSERT_EQ(result, callback.WaitForResult());
  480. }
  481. void ResumeAndRun() {
  482. // Run until the pause, if the provider isn't paused yet.
  483. SequencedSocketData* data = mock_quic_data_.GetSequencedSocketData();
  484. data->RunUntilPaused();
  485. data->Resume();
  486. base::RunLoop().RunUntilIdle();
  487. }
  488. void AssertWriteReturns(const char* data, int len, int rv) {
  489. scoped_refptr<IOBufferWithSize> buf =
  490. base::MakeRefCounted<IOBufferWithSize>(len);
  491. memcpy(buf->data(), data, len);
  492. EXPECT_EQ(rv,
  493. sock_->Write(buf.get(), buf->size(), write_callback_.callback(),
  494. TRAFFIC_ANNOTATION_FOR_TESTS));
  495. }
  496. void AssertSyncWriteSucceeds(const char* data, int len) {
  497. scoped_refptr<IOBufferWithSize> buf =
  498. base::MakeRefCounted<IOBufferWithSize>(len);
  499. memcpy(buf->data(), data, len);
  500. EXPECT_EQ(len,
  501. sock_->Write(buf.get(), buf->size(), CompletionOnceCallback(),
  502. TRAFFIC_ANNOTATION_FOR_TESTS));
  503. }
  504. void AssertSyncReadEquals(const char* data, int len) {
  505. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
  506. ASSERT_EQ(len, sock_->Read(buf.get(), len, CompletionOnceCallback()));
  507. ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
  508. ASSERT_TRUE(sock_->IsConnected());
  509. }
  510. void AssertAsyncReadEquals(const char* data, int len) {
  511. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(len);
  512. ASSERT_EQ(ERR_IO_PENDING,
  513. sock_->Read(buf.get(), len, read_callback_.callback()));
  514. EXPECT_TRUE(sock_->IsConnected());
  515. ResumeAndRun();
  516. EXPECT_EQ(len, read_callback_.WaitForResult());
  517. EXPECT_TRUE(sock_->IsConnected());
  518. ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
  519. }
  520. void AssertReadStarts(const char* data, int len) {
  521. // Issue the read, which will be completed asynchronously.
  522. read_buf_ = base::MakeRefCounted<IOBuffer>(len);
  523. ASSERT_EQ(ERR_IO_PENDING,
  524. sock_->Read(read_buf_.get(), len, read_callback_.callback()));
  525. EXPECT_TRUE(sock_->IsConnected());
  526. }
  527. void AssertReadReturns(const char* data, int len) {
  528. EXPECT_TRUE(sock_->IsConnected());
  529. // Now the read will return.
  530. EXPECT_EQ(len, read_callback_.WaitForResult());
  531. ASSERT_EQ(std::string(data, len), std::string(read_buf_->data(), len));
  532. }
  533. std::string ConstructDataHeader(size_t body_len) {
  534. if (!version_.HasIetfQuicFrames()) {
  535. return "";
  536. }
  537. quiche::QuicheBuffer buffer = quic::HttpEncoder::SerializeDataFrameHeader(
  538. body_len, quiche::SimpleBufferAllocator::Get());
  539. return std::string(buffer.data(), buffer.size());
  540. }
  541. RecordingNetLogObserver net_log_observer_;
  542. quic::test::QuicFlagSaver saver_;
  543. const quic::ParsedQuicVersion version_;
  544. const quic::QuicStreamId client_data_stream_id1_;
  545. const bool client_headers_include_h2_stream_dependency_;
  546. // order of destruction of these members matter
  547. quic::MockClock clock_;
  548. MockQuicData mock_quic_data_;
  549. std::unique_ptr<QuicChromiumConnectionHelper> helper_;
  550. std::unique_ptr<QuicChromiumClientSession> session_;
  551. std::unique_ptr<QuicChromiumClientSession::Handle> session_handle_;
  552. std::unique_ptr<QuicProxyClientSocket> sock_;
  553. std::unique_ptr<TestProxyDelegate> proxy_delegate_;
  554. raw_ptr<quic::test::MockSendAlgorithm> send_algorithm_;
  555. scoped_refptr<TestTaskRunner> runner_;
  556. std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_;
  557. testing::StrictMock<quic::test::MockQuicConnectionVisitor> visitor_;
  558. TransportSecurityState transport_security_state_;
  559. quic::QuicCryptoClientConfig crypto_config_;
  560. const quic::QuicConnectionId connection_id_;
  561. QuicTestPacketMaker client_maker_;
  562. QuicTestPacketMaker server_maker_;
  563. IPEndPoint peer_addr_;
  564. quic::test::MockRandom random_generator_{0};
  565. ProofVerifyDetailsChromium verify_details_;
  566. MockCryptoClientStreamFactory crypto_client_stream_factory_;
  567. std::string user_agent_;
  568. url::SchemeHostPort proxy_endpoint_;
  569. url::SchemeHostPort destination_endpoint_;
  570. HttpAuthCache http_auth_cache_;
  571. std::unique_ptr<MockHostResolverBase> host_resolver_;
  572. std::unique_ptr<HttpAuthHandlerRegistryFactory> http_auth_handler_factory_;
  573. TestCompletionCallback read_callback_;
  574. scoped_refptr<IOBuffer> read_buf_;
  575. TestCompletionCallback write_callback_;
  576. quic::test::NoopQpackStreamSenderDelegate noop_qpack_stream_sender_delegate_;
  577. };
  578. TEST_P(QuicProxyClientSocketTest, ConnectSendsCorrectRequest) {
  579. int packet_number = 1;
  580. if (VersionUsesHttp3(version_.transport_version)) {
  581. mock_quic_data_.AddWrite(SYNCHRONOUS,
  582. ConstructSettingsPacket(packet_number++));
  583. }
  584. mock_quic_data_.AddWrite(SYNCHRONOUS,
  585. ConstructConnectRequestPacket(packet_number++));
  586. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  587. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  588. mock_quic_data_.AddWrite(
  589. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  590. quic::QUIC_STREAM_CANCELLED, 1, 1));
  591. Initialize();
  592. ASSERT_FALSE(sock_->IsConnected());
  593. AssertConnectSucceeds();
  594. const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
  595. ASSERT_TRUE(response != nullptr);
  596. ASSERT_EQ(200, response->headers->response_code());
  597. // Although the underlying HTTP/3 connection uses TLS and negotiates ALPN, the
  598. // tunnel itself is a TCP connection to the origin and should not report these
  599. // values.
  600. net::SSLInfo ssl_info;
  601. EXPECT_FALSE(sock_->GetSSLInfo(&ssl_info));
  602. EXPECT_FALSE(sock_->WasAlpnNegotiated());
  603. EXPECT_EQ(sock_->GetNegotiatedProtocol(), NextProto::kProtoUnknown);
  604. }
  605. TEST_P(QuicProxyClientSocketTest, ProxyDelegateExtraHeaders) {
  606. proxy_delegate_ = std::make_unique<TestProxyDelegate>();
  607. // TODO(crbug.com/1206799) Construct `ProxyServer` with plain
  608. // `proxy_endpoint_` once it supports `url::SchemeHostPort`.
  609. ProxyServer proxy_server(ProxyServer::SCHEME_HTTPS,
  610. HostPortPair::FromSchemeHostPort(proxy_endpoint_));
  611. const char kResponseHeaderName[] = "foo";
  612. const char kResponseHeaderValue[] = "testing";
  613. int packet_number = 1;
  614. if (VersionUsesHttp3(version_.transport_version)) {
  615. mock_quic_data_.AddWrite(SYNCHRONOUS,
  616. ConstructSettingsPacket(packet_number++));
  617. }
  618. mock_quic_data_.AddWrite(SYNCHRONOUS,
  619. ConstructConnectRequestPacketWithExtraHeaders(
  620. packet_number++,
  621. // Order matters! Keep these alphabetical.
  622. {{"foo", ProxyServerToProxyUri(proxy_server)},
  623. {"user-agent", kUserAgent}}));
  624. mock_quic_data_.AddRead(
  625. ASYNC, ConstructServerConnectReplyPacketWithExtraHeaders(
  626. 1, !kFin, {{kResponseHeaderName, kResponseHeaderValue}}));
  627. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  628. mock_quic_data_.AddWrite(
  629. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  630. quic::QUIC_STREAM_CANCELLED, 1, 1));
  631. Initialize();
  632. ASSERT_FALSE(sock_->IsConnected());
  633. AssertConnectSucceeds();
  634. const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
  635. ASSERT_TRUE(response != nullptr);
  636. ASSERT_EQ(200, response->headers->response_code());
  637. proxy_delegate_->VerifyOnTunnelHeadersReceived(
  638. proxy_server, kResponseHeaderName, kResponseHeaderValue);
  639. }
  640. TEST_P(QuicProxyClientSocketTest, ConnectWithAuthRequested) {
  641. int packet_number = 1;
  642. if (VersionUsesHttp3(version_.transport_version)) {
  643. mock_quic_data_.AddWrite(SYNCHRONOUS,
  644. ConstructSettingsPacket(packet_number++));
  645. }
  646. mock_quic_data_.AddWrite(SYNCHRONOUS,
  647. ConstructConnectRequestPacket(packet_number++));
  648. mock_quic_data_.AddRead(ASYNC,
  649. ConstructServerConnectAuthReplyPacket(1, !kFin));
  650. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  651. mock_quic_data_.AddWrite(
  652. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  653. quic::QUIC_STREAM_CANCELLED, 1, 1));
  654. Initialize();
  655. AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
  656. const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
  657. ASSERT_TRUE(response != nullptr);
  658. ASSERT_EQ(407, response->headers->response_code());
  659. }
  660. TEST_P(QuicProxyClientSocketTest, ConnectWithAuthCredentials) {
  661. int packet_number = 1;
  662. if (VersionUsesHttp3(version_.transport_version)) {
  663. mock_quic_data_.AddWrite(SYNCHRONOUS,
  664. ConstructSettingsPacket(packet_number++));
  665. }
  666. mock_quic_data_.AddWrite(SYNCHRONOUS,
  667. ConstructConnectAuthRequestPacket(packet_number++));
  668. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  669. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  670. mock_quic_data_.AddWrite(
  671. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  672. quic::QUIC_STREAM_CANCELLED, 1, 1));
  673. Initialize();
  674. // Add auth to cache
  675. const std::u16string kFoo(u"foo");
  676. const std::u16string kBar(u"bar");
  677. http_auth_cache_.Add(
  678. url::SchemeHostPort(GURL(kProxyUrl)), HttpAuth::AUTH_PROXY, "MyRealm1",
  679. HttpAuth::AUTH_SCHEME_BASIC, NetworkIsolationKey(),
  680. "Basic realm=MyRealm1", AuthCredentials(kFoo, kBar), "/");
  681. AssertConnectSucceeds();
  682. const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
  683. ASSERT_TRUE(response != nullptr);
  684. ASSERT_EQ(200, response->headers->response_code());
  685. }
  686. // Tests that a redirect response from a CONNECT fails.
  687. TEST_P(QuicProxyClientSocketTest, ConnectRedirects) {
  688. int packet_number = 1;
  689. if (VersionUsesHttp3(version_.transport_version)) {
  690. mock_quic_data_.AddWrite(SYNCHRONOUS,
  691. ConstructSettingsPacket(packet_number++));
  692. }
  693. mock_quic_data_.AddWrite(SYNCHRONOUS,
  694. ConstructConnectRequestPacket(packet_number++));
  695. mock_quic_data_.AddRead(ASYNC,
  696. ConstructServerConnectRedirectReplyPacket(1, !kFin));
  697. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  698. mock_quic_data_.AddWrite(
  699. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  700. quic::QUIC_STREAM_CANCELLED, 1, 1));
  701. Initialize();
  702. AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
  703. const HttpResponseInfo* response = sock_->GetConnectResponseInfo();
  704. ASSERT_TRUE(response != nullptr);
  705. const HttpResponseHeaders* headers = response->headers.get();
  706. ASSERT_EQ(302, headers->response_code());
  707. ASSERT_TRUE(headers->HasHeader("set-cookie"));
  708. std::string location;
  709. ASSERT_TRUE(headers->IsRedirect(&location));
  710. ASSERT_EQ(location, kRedirectUrl);
  711. }
  712. TEST_P(QuicProxyClientSocketTest, ConnectFails) {
  713. int packet_number = 1;
  714. if (VersionUsesHttp3(version_.transport_version)) {
  715. mock_quic_data_.AddWrite(SYNCHRONOUS,
  716. ConstructSettingsPacket(packet_number++));
  717. }
  718. mock_quic_data_.AddWrite(SYNCHRONOUS,
  719. ConstructConnectRequestPacket(packet_number++));
  720. mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
  721. Initialize();
  722. ASSERT_FALSE(sock_->IsConnected());
  723. AssertConnectFails(ERR_QUIC_PROTOCOL_ERROR);
  724. ASSERT_FALSE(sock_->IsConnected());
  725. }
  726. TEST_P(QuicProxyClientSocketTest, WasEverUsedReturnsCorrectValue) {
  727. int packet_number = 1;
  728. if (VersionUsesHttp3(version_.transport_version)) {
  729. mock_quic_data_.AddWrite(SYNCHRONOUS,
  730. ConstructSettingsPacket(packet_number++));
  731. }
  732. mock_quic_data_.AddWrite(SYNCHRONOUS,
  733. ConstructConnectRequestPacket(packet_number++));
  734. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  735. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  736. mock_quic_data_.AddWrite(
  737. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  738. quic::QUIC_STREAM_CANCELLED, 1, 1));
  739. Initialize();
  740. if (VersionUsesHttp3(version_.transport_version))
  741. EXPECT_TRUE(sock_->WasEverUsed()); // Used due to crypto handshake
  742. AssertConnectSucceeds();
  743. EXPECT_TRUE(sock_->WasEverUsed());
  744. sock_->Disconnect();
  745. EXPECT_TRUE(sock_->WasEverUsed());
  746. }
  747. TEST_P(QuicProxyClientSocketTest, GetPeerAddressReturnsCorrectValues) {
  748. int packet_number = 1;
  749. if (VersionUsesHttp3(version_.transport_version)) {
  750. mock_quic_data_.AddWrite(SYNCHRONOUS,
  751. ConstructSettingsPacket(packet_number++));
  752. }
  753. mock_quic_data_.AddWrite(SYNCHRONOUS,
  754. ConstructConnectRequestPacket(packet_number++));
  755. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  756. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  757. mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
  758. Initialize();
  759. IPEndPoint addr;
  760. EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
  761. AssertConnectSucceeds();
  762. EXPECT_TRUE(sock_->IsConnected());
  763. EXPECT_THAT(sock_->GetPeerAddress(&addr), IsOk());
  764. ResumeAndRun();
  765. EXPECT_FALSE(sock_->IsConnected());
  766. EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
  767. sock_->Disconnect();
  768. EXPECT_THAT(sock_->GetPeerAddress(&addr), IsError(ERR_SOCKET_NOT_CONNECTED));
  769. }
  770. TEST_P(QuicProxyClientSocketTest, IsConnectedAndIdle) {
  771. int packet_number = 1;
  772. if (VersionUsesHttp3(version_.transport_version)) {
  773. mock_quic_data_.AddWrite(SYNCHRONOUS,
  774. ConstructSettingsPacket(packet_number++));
  775. }
  776. mock_quic_data_.AddWrite(SYNCHRONOUS,
  777. ConstructConnectRequestPacket(packet_number++));
  778. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  779. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  780. std::string header = ConstructDataHeader(kLen1);
  781. mock_quic_data_.AddRead(
  782. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  783. mock_quic_data_.AddWrite(SYNCHRONOUS,
  784. ConstructAckPacket(packet_number++, 2, 1));
  785. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  786. mock_quic_data_.AddWrite(
  787. SYNCHRONOUS,
  788. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  789. Initialize();
  790. EXPECT_FALSE(sock_->IsConnectedAndIdle());
  791. AssertConnectSucceeds();
  792. EXPECT_TRUE(sock_->IsConnectedAndIdle());
  793. // The next read is consumed and buffered.
  794. ResumeAndRun();
  795. EXPECT_FALSE(sock_->IsConnectedAndIdle());
  796. AssertSyncReadEquals(kMsg1, kLen1);
  797. EXPECT_TRUE(sock_->IsConnectedAndIdle());
  798. }
  799. TEST_P(QuicProxyClientSocketTest, GetTotalReceivedBytes) {
  800. int packet_number = 1;
  801. if (VersionUsesHttp3(version_.transport_version)) {
  802. mock_quic_data_.AddWrite(SYNCHRONOUS,
  803. ConstructSettingsPacket(packet_number++));
  804. }
  805. size_t header_length;
  806. mock_quic_data_.AddWrite(SYNCHRONOUS,
  807. ConstructConnectRequestPacket(packet_number++));
  808. mock_quic_data_.AddRead(
  809. ASYNC, ConstructServerConnectReplyPacket(1, !kFin, &header_length));
  810. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  811. std::string data_header = ConstructDataHeader(kLen333);
  812. mock_quic_data_.AddRead(ASYNC,
  813. ConstructServerDataPacket(
  814. 2, data_header + std::string(kMsg333, kLen333)));
  815. mock_quic_data_.AddWrite(SYNCHRONOUS,
  816. ConstructAckPacket(packet_number++, 2, 1));
  817. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  818. mock_quic_data_.AddWrite(
  819. SYNCHRONOUS,
  820. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  821. Initialize();
  822. EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
  823. AssertConnectSucceeds();
  824. if (!VersionUsesHttp3(version_.transport_version)) {
  825. header_length = 0;
  826. EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
  827. } else {
  828. // HTTP/3 sends and receives HTTP headers on the request stream.
  829. EXPECT_EQ((int64_t)(header_length), sock_->GetTotalReceivedBytes());
  830. }
  831. // The next read is consumed and buffered.
  832. ResumeAndRun();
  833. if (!VersionUsesHttp3(version_.transport_version)) {
  834. EXPECT_EQ(0, sock_->GetTotalReceivedBytes());
  835. } else {
  836. // HTTP/3 encodes data with DATA frame. The header is consumed.
  837. EXPECT_EQ((int64_t)(header_length + data_header.length()),
  838. sock_->GetTotalReceivedBytes());
  839. }
  840. // The payload from the single large data frame will be read across
  841. // two different reads.
  842. AssertSyncReadEquals(kMsg33, kLen33);
  843. EXPECT_EQ((int64_t)(header_length + data_header.length() + kLen33),
  844. sock_->GetTotalReceivedBytes());
  845. AssertSyncReadEquals(kMsg3, kLen3);
  846. EXPECT_EQ((int64_t)(header_length + kLen333 + data_header.length()),
  847. sock_->GetTotalReceivedBytes());
  848. }
  849. TEST_P(QuicProxyClientSocketTest, SetStreamPriority) {
  850. int packet_number = 1;
  851. if (VersionUsesHttp3(version_.transport_version)) {
  852. mock_quic_data_.AddWrite(SYNCHRONOUS,
  853. ConstructSettingsPacket(packet_number++));
  854. }
  855. // Despite setting the priority to HIGHEST, the requets initial priority of
  856. // LOWEST is used.
  857. mock_quic_data_.AddWrite(
  858. SYNCHRONOUS, ConstructConnectRequestPacket(packet_number++, LOWEST));
  859. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  860. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  861. mock_quic_data_.AddWrite(
  862. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  863. quic::QUIC_STREAM_CANCELLED, 1, 1));
  864. Initialize();
  865. sock_->SetStreamPriority(HIGHEST);
  866. AssertConnectSucceeds();
  867. }
  868. TEST_P(QuicProxyClientSocketTest, WriteSendsDataInDataFrame) {
  869. int packet_number = 1;
  870. if (VersionUsesHttp3(version_.transport_version)) {
  871. mock_quic_data_.AddWrite(SYNCHRONOUS,
  872. ConstructSettingsPacket(packet_number++));
  873. }
  874. mock_quic_data_.AddWrite(SYNCHRONOUS,
  875. ConstructConnectRequestPacket(packet_number++));
  876. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  877. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  878. if (version_.HasIetfQuicFrames()) {
  879. std::string header = ConstructDataHeader(kLen1);
  880. mock_quic_data_.AddWrite(
  881. SYNCHRONOUS,
  882. ConstructAckAndDataPacket(packet_number++, 1, 1,
  883. {header + std::string(kMsg1, kLen1)}));
  884. std::string header2 = ConstructDataHeader(kLen2);
  885. mock_quic_data_.AddWrite(
  886. SYNCHRONOUS,
  887. ConstructDataPacket(packet_number++,
  888. {header2 + std::string(kMsg2, kLen2)}));
  889. mock_quic_data_.AddWrite(
  890. SYNCHRONOUS,
  891. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  892. } else {
  893. mock_quic_data_.AddWrite(
  894. SYNCHRONOUS, ConstructAckAndDataPacket(packet_number++, 1, 1,
  895. std::string(kMsg1, kLen1)));
  896. mock_quic_data_.AddWrite(
  897. SYNCHRONOUS,
  898. ConstructDataPacket(packet_number++, std::string(kMsg2, kLen2)));
  899. mock_quic_data_.AddWrite(
  900. SYNCHRONOUS,
  901. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  902. }
  903. Initialize();
  904. AssertConnectSucceeds();
  905. AssertSyncWriteSucceeds(kMsg1, kLen1);
  906. AssertSyncWriteSucceeds(kMsg2, kLen2);
  907. }
  908. TEST_P(QuicProxyClientSocketTest, WriteSplitsLargeDataIntoMultiplePackets) {
  909. int write_packet_index = 1;
  910. if (VersionUsesHttp3(version_.transport_version)) {
  911. mock_quic_data_.AddWrite(SYNCHRONOUS,
  912. ConstructSettingsPacket(write_packet_index++));
  913. }
  914. mock_quic_data_.AddWrite(SYNCHRONOUS,
  915. ConstructConnectRequestPacket(write_packet_index++));
  916. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  917. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  918. std::string header = ConstructDataHeader(kLen1);
  919. if (!version_.HasIetfQuicFrames()) {
  920. mock_quic_data_.AddWrite(
  921. SYNCHRONOUS, ConstructAckAndDataPacket(write_packet_index++, 1, 1,
  922. std::string(kMsg1, kLen1)));
  923. } else {
  924. mock_quic_data_.AddWrite(
  925. SYNCHRONOUS,
  926. ConstructAckAndDataPacket(write_packet_index++, 1, 1,
  927. {header + std::string(kMsg1, kLen1)}));
  928. }
  929. // Expect |kNumDataPackets| data packets, each containing the max possible
  930. // amount of data.
  931. int numDataPackets = 3;
  932. std::string data(numDataPackets * quic::kDefaultMaxPacketSize, 'x');
  933. quic::QuicStreamOffset offset = kLen1 + header.length();
  934. if (version_.HasIetfQuicFrames()) {
  935. numDataPackets++;
  936. }
  937. size_t total_data_length = 0;
  938. for (int i = 0; i < numDataPackets; ++i) {
  939. size_t max_packet_data_length = GetStreamFrameDataLengthFromPacketLength(
  940. quic::kDefaultMaxPacketSize, version_, !kIncludeVersion,
  941. !kIncludeDiversificationNonce, quic::PACKET_8BYTE_CONNECTION_ID,
  942. quic::PACKET_1BYTE_PACKET_NUMBER, offset);
  943. if (version_.HasIetfQuicFrames() && i == 0) {
  944. // 3673 is the data frame length from packet length.
  945. std::string header2 = ConstructDataHeader(3673);
  946. mock_quic_data_.AddWrite(
  947. SYNCHRONOUS,
  948. ConstructDataPacket(
  949. write_packet_index++,
  950. {header2 +
  951. std::string(data.c_str(), max_packet_data_length - 7)}));
  952. offset += max_packet_data_length - header2.length() - 1;
  953. } else if (version_.HasIetfQuicFrames() && i == numDataPackets - 1) {
  954. mock_quic_data_.AddWrite(
  955. SYNCHRONOUS, ConstructDataPacket(write_packet_index++,
  956. std::string(data.c_str(), 7)));
  957. offset += 7;
  958. } else {
  959. mock_quic_data_.AddWrite(
  960. SYNCHRONOUS, ConstructDataPacket(
  961. write_packet_index++,
  962. std::string(data.c_str(), max_packet_data_length)));
  963. offset += max_packet_data_length;
  964. }
  965. if (i != 3) {
  966. total_data_length += max_packet_data_length;
  967. }
  968. }
  969. mock_quic_data_.AddWrite(
  970. SYNCHRONOUS,
  971. ConstructRstPacket(write_packet_index++, quic::QUIC_STREAM_CANCELLED));
  972. Initialize();
  973. AssertConnectSucceeds();
  974. // Make a small write. An ACK and STOP_WAITING will be bundled. This prevents
  975. // ACK and STOP_WAITING from being bundled with the subsequent large write.
  976. // This allows the test code for computing the size of data sent in each
  977. // packet to not become too complicated.
  978. AssertSyncWriteSucceeds(kMsg1, kLen1);
  979. // Make large write that should be split up
  980. AssertSyncWriteSucceeds(data.c_str(), total_data_length);
  981. }
  982. // ----------- Read
  983. TEST_P(QuicProxyClientSocketTest, ReadReadsDataInDataFrame) {
  984. int packet_number = 1;
  985. if (VersionUsesHttp3(version_.transport_version)) {
  986. mock_quic_data_.AddWrite(SYNCHRONOUS,
  987. ConstructSettingsPacket(packet_number++));
  988. }
  989. mock_quic_data_.AddWrite(SYNCHRONOUS,
  990. ConstructConnectRequestPacket(packet_number++));
  991. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  992. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  993. std::string header = ConstructDataHeader(kLen1);
  994. mock_quic_data_.AddRead(
  995. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  996. mock_quic_data_.AddWrite(SYNCHRONOUS,
  997. ConstructAckPacket(packet_number++, 2, 1));
  998. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  999. mock_quic_data_.AddWrite(
  1000. SYNCHRONOUS,
  1001. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  1002. Initialize();
  1003. AssertConnectSucceeds();
  1004. ResumeAndRun();
  1005. AssertSyncReadEquals(kMsg1, kLen1);
  1006. }
  1007. TEST_P(QuicProxyClientSocketTest, ReadDataFromBufferedFrames) {
  1008. int packet_number = 1;
  1009. if (VersionUsesHttp3(version_.transport_version)) {
  1010. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1011. ConstructSettingsPacket(packet_number++));
  1012. }
  1013. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1014. ConstructConnectRequestPacket(packet_number++));
  1015. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1016. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1017. std::string header = ConstructDataHeader(kLen1);
  1018. mock_quic_data_.AddRead(
  1019. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1020. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1021. ConstructAckPacket(packet_number++, 2, 1));
  1022. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1023. std::string header2 = ConstructDataHeader(kLen2);
  1024. mock_quic_data_.AddRead(
  1025. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
  1026. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1027. mock_quic_data_.AddWrite(
  1028. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1029. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1030. Initialize();
  1031. AssertConnectSucceeds();
  1032. ResumeAndRun();
  1033. AssertSyncReadEquals(kMsg1, kLen1);
  1034. ResumeAndRun();
  1035. AssertSyncReadEquals(kMsg2, kLen2);
  1036. }
  1037. TEST_P(QuicProxyClientSocketTest, ReadDataMultipleBufferedFrames) {
  1038. int packet_number = 1;
  1039. if (VersionUsesHttp3(version_.transport_version)) {
  1040. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1041. ConstructSettingsPacket(packet_number++));
  1042. }
  1043. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1044. ConstructConnectRequestPacket(packet_number++));
  1045. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1046. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1047. std::string header = ConstructDataHeader(kLen1);
  1048. mock_quic_data_.AddRead(
  1049. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1050. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1051. ConstructAckPacket(packet_number++, 2, 1));
  1052. std::string header2 = ConstructDataHeader(kLen2);
  1053. mock_quic_data_.AddRead(
  1054. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
  1055. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1056. mock_quic_data_.AddWrite(
  1057. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1058. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1059. Initialize();
  1060. AssertConnectSucceeds();
  1061. // The next two reads are consumed and buffered.
  1062. ResumeAndRun();
  1063. AssertSyncReadEquals(kMsg1, kLen1);
  1064. AssertSyncReadEquals(kMsg2, kLen2);
  1065. }
  1066. TEST_P(QuicProxyClientSocketTest, LargeReadWillMergeDataFromDifferentFrames) {
  1067. int packet_number = 1;
  1068. if (VersionUsesHttp3(version_.transport_version)) {
  1069. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1070. ConstructSettingsPacket(packet_number++));
  1071. }
  1072. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1073. ConstructConnectRequestPacket(packet_number++));
  1074. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1075. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1076. std::string header = ConstructDataHeader(kLen3);
  1077. mock_quic_data_.AddRead(
  1078. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg3, kLen3)));
  1079. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1080. ConstructAckPacket(packet_number++, 2, 1));
  1081. std::string header2 = ConstructDataHeader(kLen3);
  1082. mock_quic_data_.AddRead(
  1083. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
  1084. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1085. mock_quic_data_.AddWrite(
  1086. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1087. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1088. Initialize();
  1089. AssertConnectSucceeds();
  1090. // The next two reads are consumed and buffered.
  1091. ResumeAndRun();
  1092. // The payload from two data frames, each with kMsg3 will be combined
  1093. // together into a single read().
  1094. AssertSyncReadEquals(kMsg33, kLen33);
  1095. }
  1096. TEST_P(QuicProxyClientSocketTest, MultipleShortReadsThenMoreRead) {
  1097. int packet_number = 1;
  1098. if (VersionUsesHttp3(version_.transport_version)) {
  1099. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1100. ConstructSettingsPacket(packet_number++));
  1101. }
  1102. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1103. ConstructConnectRequestPacket(packet_number++));
  1104. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1105. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1106. std::string header = ConstructDataHeader(kLen1);
  1107. mock_quic_data_.AddRead(
  1108. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1109. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1110. ConstructAckPacket(packet_number++, 2, 1));
  1111. std::string header2 = ConstructDataHeader(kLen3);
  1112. mock_quic_data_.AddRead(
  1113. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
  1114. mock_quic_data_.AddRead(
  1115. ASYNC, ConstructServerDataPacket(4, header2 + std::string(kMsg3, kLen3)));
  1116. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1117. ConstructAckPacket(packet_number++, 4, 3));
  1118. std::string header3 = ConstructDataHeader(kLen2);
  1119. mock_quic_data_.AddRead(
  1120. ASYNC, ConstructServerDataPacket(5, header3 + std::string(kMsg2, kLen2)));
  1121. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1122. mock_quic_data_.AddWrite(
  1123. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1124. quic::QUIC_STREAM_CANCELLED, 5, 5));
  1125. Initialize();
  1126. AssertConnectSucceeds();
  1127. // The next 4 reads are consumed and buffered.
  1128. ResumeAndRun();
  1129. AssertSyncReadEquals(kMsg1, kLen1);
  1130. // The payload from two data frames, each with kMsg3 will be combined
  1131. // together into a single read().
  1132. AssertSyncReadEquals(kMsg33, kLen33);
  1133. AssertSyncReadEquals(kMsg2, kLen2);
  1134. }
  1135. TEST_P(QuicProxyClientSocketTest, ReadWillSplitDataFromLargeFrame) {
  1136. int packet_number = 1;
  1137. if (VersionUsesHttp3(version_.transport_version)) {
  1138. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1139. ConstructSettingsPacket(packet_number++));
  1140. }
  1141. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1142. ConstructConnectRequestPacket(packet_number++));
  1143. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1144. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1145. std::string header = ConstructDataHeader(kLen1);
  1146. mock_quic_data_.AddRead(
  1147. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1148. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1149. ConstructAckPacket(packet_number++, 2, 1));
  1150. std::string header2 = ConstructDataHeader(kLen33);
  1151. mock_quic_data_.AddRead(ASYNC, ConstructServerDataPacket(
  1152. 3, header2 + std::string(kMsg33, kLen33)));
  1153. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1154. mock_quic_data_.AddWrite(
  1155. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1156. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1157. Initialize();
  1158. AssertConnectSucceeds();
  1159. // The next 2 reads are consumed and buffered.
  1160. ResumeAndRun();
  1161. AssertSyncReadEquals(kMsg1, kLen1);
  1162. // The payload from the single large data frame will be read across
  1163. // two different reads.
  1164. AssertSyncReadEquals(kMsg3, kLen3);
  1165. AssertSyncReadEquals(kMsg3, kLen3);
  1166. }
  1167. TEST_P(QuicProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
  1168. int packet_number = 1;
  1169. if (VersionUsesHttp3(version_.transport_version)) {
  1170. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1171. ConstructSettingsPacket(packet_number++));
  1172. }
  1173. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1174. ConstructConnectRequestPacket(packet_number++));
  1175. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1176. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1177. std::string header = ConstructDataHeader(kLen333);
  1178. mock_quic_data_.AddRead(
  1179. ASYNC,
  1180. ConstructServerDataPacket(2, header + std::string(kMsg333, kLen333)));
  1181. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1182. ConstructAckPacket(packet_number++, 2, 1));
  1183. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1184. mock_quic_data_.AddWrite(
  1185. SYNCHRONOUS,
  1186. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  1187. Initialize();
  1188. AssertConnectSucceeds();
  1189. // The next read is consumed and buffered.
  1190. ResumeAndRun();
  1191. // The payload from the single large data frame will be read across
  1192. // two different reads.
  1193. AssertSyncReadEquals(kMsg33, kLen33);
  1194. // Now attempt to do a read of more data than remains buffered
  1195. scoped_refptr<IOBuffer> buf = base::MakeRefCounted<IOBuffer>(kLen33);
  1196. ASSERT_EQ(kLen3, sock_->Read(buf.get(), kLen33, CompletionOnceCallback()));
  1197. ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
  1198. ASSERT_TRUE(sock_->IsConnected());
  1199. }
  1200. TEST_P(QuicProxyClientSocketTest, ReadAuthResponseBody) {
  1201. int packet_number = 1;
  1202. if (VersionUsesHttp3(version_.transport_version)) {
  1203. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1204. ConstructSettingsPacket(packet_number++));
  1205. }
  1206. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1207. ConstructConnectRequestPacket(packet_number++));
  1208. mock_quic_data_.AddRead(ASYNC,
  1209. ConstructServerConnectAuthReplyPacket(1, !kFin));
  1210. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1211. std::string header = ConstructDataHeader(kLen1);
  1212. mock_quic_data_.AddRead(
  1213. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1214. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1215. ConstructAckPacket(packet_number++, 2, 1));
  1216. std::string header2 = ConstructDataHeader(kLen2);
  1217. mock_quic_data_.AddRead(
  1218. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
  1219. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1220. mock_quic_data_.AddWrite(
  1221. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1222. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1223. Initialize();
  1224. AssertConnectFails(ERR_PROXY_AUTH_REQUESTED);
  1225. // The next two reads are consumed and buffered.
  1226. ResumeAndRun();
  1227. AssertSyncReadEquals(kMsg1, kLen1);
  1228. AssertSyncReadEquals(kMsg2, kLen2);
  1229. }
  1230. TEST_P(QuicProxyClientSocketTest, ReadErrorResponseBody) {
  1231. int packet_number = 1;
  1232. if (VersionUsesHttp3(version_.transport_version)) {
  1233. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1234. ConstructSettingsPacket(packet_number++));
  1235. }
  1236. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1237. ConstructConnectRequestPacket(packet_number++));
  1238. mock_quic_data_.AddRead(ASYNC,
  1239. ConstructServerConnectErrorReplyPacket(1, !kFin));
  1240. std::string header = ConstructDataHeader(kLen1);
  1241. mock_quic_data_.AddRead(
  1242. SYNCHRONOUS,
  1243. ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1244. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1245. ConstructAckPacket(packet_number++, 2, 1));
  1246. std::string header2 = ConstructDataHeader(kLen2);
  1247. mock_quic_data_.AddRead(
  1248. SYNCHRONOUS,
  1249. ConstructServerDataPacket(3, header2 + std::string(kMsg2, kLen2)));
  1250. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1251. mock_quic_data_.AddWrite(
  1252. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1253. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1254. Initialize();
  1255. AssertConnectFails(ERR_TUNNEL_CONNECTION_FAILED);
  1256. }
  1257. // ----------- Reads and Writes
  1258. TEST_P(QuicProxyClientSocketTest, AsyncReadAroundWrite) {
  1259. int write_packet_index = 1;
  1260. if (VersionUsesHttp3(version_.transport_version)) {
  1261. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1262. ConstructSettingsPacket(write_packet_index++));
  1263. }
  1264. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1265. ConstructConnectRequestPacket(write_packet_index++));
  1266. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1267. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1268. std::string header = ConstructDataHeader(kLen1);
  1269. mock_quic_data_.AddRead(
  1270. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1271. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1272. ConstructAckPacket(write_packet_index++, 2, 1));
  1273. std::string header2 = ConstructDataHeader(kLen2);
  1274. if (version_.HasIetfQuicFrames()) {
  1275. mock_quic_data_.AddWrite(
  1276. SYNCHRONOUS,
  1277. ConstructDataPacket(write_packet_index++,
  1278. {header2 + std::string(kMsg2, kLen2)}));
  1279. } else {
  1280. mock_quic_data_.AddWrite(
  1281. SYNCHRONOUS,
  1282. ConstructDataPacket(write_packet_index++, std::string(kMsg2, kLen2)));
  1283. }
  1284. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1285. std::string header3 = ConstructDataHeader(kLen3);
  1286. mock_quic_data_.AddRead(
  1287. ASYNC, ConstructServerDataPacket(3, header3 + std::string(kMsg3, kLen3)));
  1288. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1289. mock_quic_data_.AddWrite(
  1290. SYNCHRONOUS, ConstructAckAndRstPacket(write_packet_index++,
  1291. quic::QUIC_STREAM_CANCELLED, 3, 3));
  1292. Initialize();
  1293. AssertConnectSucceeds();
  1294. ResumeAndRun();
  1295. AssertSyncReadEquals(kMsg1, kLen1);
  1296. AssertReadStarts(kMsg3, kLen3);
  1297. // Read should block until after the write succeeds.
  1298. AssertSyncWriteSucceeds(kMsg2, kLen2);
  1299. ASSERT_FALSE(read_callback_.have_result());
  1300. ResumeAndRun();
  1301. // Now the read will return.
  1302. AssertReadReturns(kMsg3, kLen3);
  1303. }
  1304. TEST_P(QuicProxyClientSocketTest, AsyncWriteAroundReads) {
  1305. int packet_number = 1;
  1306. if (VersionUsesHttp3(version_.transport_version)) {
  1307. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1308. ConstructSettingsPacket(packet_number++));
  1309. }
  1310. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1311. ConstructConnectRequestPacket(packet_number++));
  1312. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1313. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1314. std::string header = ConstructDataHeader(kLen1);
  1315. mock_quic_data_.AddRead(
  1316. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1317. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1318. ConstructAckPacket(packet_number++, 2, 1));
  1319. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1320. std::string header2 = ConstructDataHeader(kLen3);
  1321. mock_quic_data_.AddRead(
  1322. ASYNC, ConstructServerDataPacket(3, header2 + std::string(kMsg3, kLen3)));
  1323. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1324. mock_quic_data_.AddWrite(ASYNC, ERR_IO_PENDING); // Pause
  1325. std::string header3 = ConstructDataHeader(kLen2);
  1326. if (!version_.HasIetfQuicFrames()) {
  1327. mock_quic_data_.AddWrite(
  1328. ASYNC, ConstructDataPacket(packet_number++, std::string(kMsg2, kLen2)));
  1329. mock_quic_data_.AddWrite(
  1330. SYNCHRONOUS, ConstructAckAndDataPacket(packet_number++, 3, 3,
  1331. std::string(kMsg2, kLen2)));
  1332. } else {
  1333. mock_quic_data_.AddWrite(
  1334. ASYNC, ConstructDataPacket(packet_number++,
  1335. {header3 + std::string(kMsg2, kLen2)}));
  1336. mock_quic_data_.AddWrite(
  1337. ASYNC, ConstructAckAndDataPacket(packet_number++, 3, 3,
  1338. header3 + std::string(kMsg2, kLen2)));
  1339. }
  1340. mock_quic_data_.AddWrite(
  1341. SYNCHRONOUS,
  1342. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  1343. Initialize();
  1344. AssertConnectSucceeds();
  1345. ResumeAndRun();
  1346. AssertSyncReadEquals(kMsg1, kLen1);
  1347. // Write should block until the next read completes.
  1348. // QuicChromiumClientStream::Handle::WriteStreamData() will only be
  1349. // asynchronous starting with the second time it's called while the UDP socket
  1350. // is write-blocked. Therefore, at least two writes need to be called on
  1351. // |sock_| to get an asynchronous one.
  1352. AssertWriteReturns(kMsg2, kLen2, kLen2);
  1353. AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
  1354. AssertAsyncReadEquals(kMsg3, kLen3);
  1355. ASSERT_FALSE(write_callback_.have_result());
  1356. // Now the write will complete
  1357. ResumeAndRun();
  1358. EXPECT_EQ(kLen2, write_callback_.WaitForResult());
  1359. }
  1360. // ----------- Reading/Writing on Closed socket
  1361. // Reading from an already closed socket should return 0
  1362. TEST_P(QuicProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
  1363. int packet_number = 1;
  1364. if (VersionUsesHttp3(version_.transport_version)) {
  1365. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1366. ConstructSettingsPacket(packet_number++));
  1367. }
  1368. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1369. ConstructConnectRequestPacket(packet_number++));
  1370. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1371. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1372. mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
  1373. Initialize();
  1374. AssertConnectSucceeds();
  1375. ResumeAndRun();
  1376. ASSERT_FALSE(sock_->IsConnected());
  1377. ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1378. ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1379. ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1380. ASSERT_FALSE(sock_->IsConnectedAndIdle());
  1381. }
  1382. // Read pending when socket is closed should return 0
  1383. TEST_P(QuicProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
  1384. int packet_number = 1;
  1385. if (VersionUsesHttp3(version_.transport_version)) {
  1386. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1387. ConstructSettingsPacket(packet_number++));
  1388. }
  1389. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1390. ConstructConnectRequestPacket(packet_number++));
  1391. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1392. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1393. mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
  1394. Initialize();
  1395. AssertConnectSucceeds();
  1396. AssertReadStarts(kMsg1, kLen1);
  1397. ResumeAndRun();
  1398. ASSERT_EQ(0, read_callback_.WaitForResult());
  1399. }
  1400. // Reading from a disconnected socket is an error
  1401. TEST_P(QuicProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
  1402. int packet_number = 1;
  1403. if (VersionUsesHttp3(version_.transport_version)) {
  1404. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1405. ConstructSettingsPacket(packet_number++));
  1406. }
  1407. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1408. ConstructConnectRequestPacket(packet_number++));
  1409. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1410. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1411. mock_quic_data_.AddWrite(
  1412. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1413. quic::QUIC_STREAM_CANCELLED, 1, 1));
  1414. Initialize();
  1415. AssertConnectSucceeds();
  1416. sock_->Disconnect();
  1417. ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
  1418. sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1419. }
  1420. // Reading data after receiving FIN should return buffered data received before
  1421. // FIN, then 0.
  1422. TEST_P(QuicProxyClientSocketTest, ReadAfterFinReceivedReturnsBufferedData) {
  1423. int packet_number = 1;
  1424. if (VersionUsesHttp3(version_.transport_version)) {
  1425. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1426. ConstructSettingsPacket(packet_number++));
  1427. }
  1428. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1429. ConstructConnectRequestPacket(packet_number++));
  1430. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1431. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1432. std::string header = ConstructDataHeader(kLen1);
  1433. mock_quic_data_.AddRead(ASYNC, ConstructServerDataFinPacket(
  1434. 2, header + std::string(kMsg1, kLen1)));
  1435. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1436. ConstructAckPacket(packet_number++, 2, 1));
  1437. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1438. mock_quic_data_.AddWrite(
  1439. SYNCHRONOUS,
  1440. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  1441. Initialize();
  1442. AssertConnectSucceeds();
  1443. ResumeAndRun();
  1444. AssertSyncReadEquals(kMsg1, kLen1);
  1445. ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1446. ASSERT_EQ(0, sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1447. sock_->Disconnect();
  1448. ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
  1449. sock_->Read(nullptr, 1, CompletionOnceCallback()));
  1450. }
  1451. // Calling Write() on a closed socket is an error.
  1452. TEST_P(QuicProxyClientSocketTest, WriteOnClosedStream) {
  1453. int packet_number = 1;
  1454. if (VersionUsesHttp3(version_.transport_version)) {
  1455. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1456. ConstructSettingsPacket(packet_number++));
  1457. }
  1458. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1459. ConstructConnectRequestPacket(packet_number++));
  1460. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1461. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1462. mock_quic_data_.AddRead(ASYNC, ERR_CONNECTION_CLOSED);
  1463. Initialize();
  1464. AssertConnectSucceeds();
  1465. ResumeAndRun();
  1466. AssertWriteReturns(kMsg1, kLen1, ERR_QUIC_PROTOCOL_ERROR);
  1467. }
  1468. // Calling Write() on a disconnected socket is an error.
  1469. TEST_P(QuicProxyClientSocketTest, WriteOnDisconnectedSocket) {
  1470. int packet_number = 1;
  1471. if (VersionUsesHttp3(version_.transport_version)) {
  1472. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1473. ConstructSettingsPacket(packet_number++));
  1474. }
  1475. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1476. ConstructConnectRequestPacket(packet_number++));
  1477. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1478. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1479. mock_quic_data_.AddWrite(
  1480. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1481. quic::QUIC_STREAM_CANCELLED, 1, 1));
  1482. Initialize();
  1483. AssertConnectSucceeds();
  1484. sock_->Disconnect();
  1485. AssertWriteReturns(kMsg1, kLen1, ERR_SOCKET_NOT_CONNECTED);
  1486. }
  1487. // If the socket is closed with a pending Write(), the callback should be called
  1488. // with the same error the session was closed with.
  1489. TEST_P(QuicProxyClientSocketTest, WritePendingOnClose) {
  1490. int packet_number = 1;
  1491. if (VersionUsesHttp3(version_.transport_version)) {
  1492. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1493. ConstructSettingsPacket(packet_number++));
  1494. }
  1495. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1496. ConstructConnectRequestPacket(packet_number++));
  1497. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1498. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1499. mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
  1500. Initialize();
  1501. AssertConnectSucceeds();
  1502. // QuicChromiumClientStream::Handle::WriteStreamData() will only be
  1503. // asynchronous starting with the second time it's called while the UDP socket
  1504. // is write-blocked. Therefore, at least two writes need to be called on
  1505. // |sock_| to get an asynchronous one.
  1506. AssertWriteReturns(kMsg1, kLen1, kLen1);
  1507. // This second write will be async. This is the pending write that's being
  1508. // tested.
  1509. AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
  1510. // Make sure the write actually starts.
  1511. base::RunLoop().RunUntilIdle();
  1512. session_->CloseSessionOnError(ERR_CONNECTION_CLOSED,
  1513. quic::QUIC_INTERNAL_ERROR,
  1514. quic::ConnectionCloseBehavior::SILENT_CLOSE);
  1515. EXPECT_THAT(write_callback_.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
  1516. }
  1517. TEST_P(QuicProxyClientSocketTest, DisconnectWithWritePending) {
  1518. int packet_number = 1;
  1519. if (VersionUsesHttp3(version_.transport_version)) {
  1520. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1521. ConstructSettingsPacket(packet_number++));
  1522. }
  1523. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1524. ConstructConnectRequestPacket(packet_number++));
  1525. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1526. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1527. mock_quic_data_.AddWrite(SYNCHRONOUS, ERR_IO_PENDING);
  1528. Initialize();
  1529. AssertConnectSucceeds();
  1530. // QuicChromiumClientStream::Handle::WriteStreamData() will only be
  1531. // asynchronous starting with the second time it's called while the UDP socket
  1532. // is write-blocked. Therefore, at least two writes need to be called on
  1533. // |sock_| to get an asynchronous one.
  1534. AssertWriteReturns(kMsg1, kLen1, kLen1);
  1535. // This second write will be async. This is the pending write that's being
  1536. // tested.
  1537. AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
  1538. // Make sure the write actually starts.
  1539. base::RunLoop().RunUntilIdle();
  1540. sock_->Disconnect();
  1541. EXPECT_FALSE(sock_->IsConnected());
  1542. base::RunLoop().RunUntilIdle();
  1543. EXPECT_FALSE(sock_->IsConnected());
  1544. EXPECT_FALSE(write_callback_.have_result());
  1545. }
  1546. // If the socket is Disconnected with a pending Read(), the callback
  1547. // should not be called.
  1548. TEST_P(QuicProxyClientSocketTest, DisconnectWithReadPending) {
  1549. int packet_number = 1;
  1550. if (VersionUsesHttp3(version_.transport_version)) {
  1551. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1552. ConstructSettingsPacket(packet_number++));
  1553. }
  1554. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1555. ConstructConnectRequestPacket(packet_number++));
  1556. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1557. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1558. mock_quic_data_.AddWrite(
  1559. SYNCHRONOUS, ConstructAckAndRstPacket(packet_number++,
  1560. quic::QUIC_STREAM_CANCELLED, 1, 1));
  1561. Initialize();
  1562. AssertConnectSucceeds();
  1563. EXPECT_TRUE(sock_->IsConnected());
  1564. AssertReadStarts(kMsg1, kLen1);
  1565. sock_->Disconnect();
  1566. EXPECT_FALSE(sock_->IsConnected());
  1567. base::RunLoop().RunUntilIdle();
  1568. EXPECT_FALSE(sock_->IsConnected());
  1569. EXPECT_FALSE(read_callback_.have_result());
  1570. }
  1571. // If the socket is Reset when both a read and write are pending,
  1572. // both should be called back.
  1573. TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePending) {
  1574. int packet_number = 1;
  1575. if (VersionUsesHttp3(version_.transport_version)) {
  1576. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1577. ConstructSettingsPacket(packet_number++));
  1578. }
  1579. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1580. ConstructConnectRequestPacket(packet_number++));
  1581. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1582. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1583. mock_quic_data_.AddRead(
  1584. ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
  1585. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1586. std::string header = ConstructDataHeader(kLen2);
  1587. if (!version_.HasIetfQuicFrames()) {
  1588. mock_quic_data_.AddWrite(
  1589. ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
  1590. std::string(kMsg2, kLen2)));
  1591. mock_quic_data_.AddWrite(
  1592. SYNCHRONOUS,
  1593. ConstructAckAndRstPacket(packet_number++,
  1594. quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2));
  1595. } else {
  1596. mock_quic_data_.AddWrite(
  1597. ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
  1598. {header + std::string(kMsg2, kLen2)}));
  1599. mock_quic_data_.AddWrite(
  1600. SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
  1601. packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
  1602. }
  1603. Initialize();
  1604. AssertConnectSucceeds();
  1605. EXPECT_TRUE(sock_->IsConnected());
  1606. AssertReadStarts(kMsg1, kLen1);
  1607. // Write should block until the next read completes.
  1608. // QuicChromiumClientStream::Handle::WriteStreamData() will only be
  1609. // asynchronous starting with the second time it's called while the UDP socket
  1610. // is write-blocked. Therefore, at least two writes need to be called on
  1611. // |sock_| to get an asynchronous one.
  1612. AssertWriteReturns(kMsg2, kLen2, kLen2);
  1613. AssertWriteReturns(kMsg2, kLen2, ERR_IO_PENDING);
  1614. ResumeAndRun();
  1615. EXPECT_TRUE(read_callback_.have_result());
  1616. EXPECT_TRUE(write_callback_.have_result());
  1617. }
  1618. // Makes sure the proxy client socket's source gets the expected NetLog events
  1619. // and only the expected NetLog events (No SpdySession events).
  1620. TEST_P(QuicProxyClientSocketTest, NetLog) {
  1621. int packet_number = 1;
  1622. if (VersionUsesHttp3(version_.transport_version)) {
  1623. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1624. ConstructSettingsPacket(packet_number++));
  1625. }
  1626. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1627. ConstructConnectRequestPacket(packet_number++));
  1628. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1629. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1630. std::string header = ConstructDataHeader(kLen1);
  1631. mock_quic_data_.AddRead(
  1632. ASYNC, ConstructServerDataPacket(2, header + std::string(kMsg1, kLen1)));
  1633. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1634. ConstructAckPacket(packet_number++, 2, 1));
  1635. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1636. mock_quic_data_.AddWrite(
  1637. SYNCHRONOUS,
  1638. ConstructRstPacket(packet_number++, quic::QUIC_STREAM_CANCELLED));
  1639. Initialize();
  1640. AssertConnectSucceeds();
  1641. ResumeAndRun();
  1642. AssertSyncReadEquals(kMsg1, kLen1);
  1643. NetLogSource sock_source = sock_->NetLog().source();
  1644. sock_.reset();
  1645. auto entry_list = net_log_observer_.GetEntriesForSource(sock_source);
  1646. ASSERT_EQ(entry_list.size(), 10u);
  1647. EXPECT_TRUE(
  1648. LogContainsBeginEvent(entry_list, 0, NetLogEventType::SOCKET_ALIVE));
  1649. EXPECT_TRUE(LogContainsEvent(entry_list, 1,
  1650. NetLogEventType::HTTP2_PROXY_CLIENT_SESSION,
  1651. NetLogEventPhase::NONE));
  1652. EXPECT_TRUE(LogContainsBeginEvent(
  1653. entry_list, 2, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
  1654. EXPECT_TRUE(LogContainsEvent(
  1655. entry_list, 3, NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
  1656. NetLogEventPhase::NONE));
  1657. EXPECT_TRUE(LogContainsEndEvent(
  1658. entry_list, 4, NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST));
  1659. EXPECT_TRUE(LogContainsBeginEvent(
  1660. entry_list, 5, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
  1661. EXPECT_TRUE(LogContainsEvent(
  1662. entry_list, 6,
  1663. NetLogEventType::HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
  1664. NetLogEventPhase::NONE));
  1665. EXPECT_TRUE(LogContainsEndEvent(
  1666. entry_list, 7, NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS));
  1667. EXPECT_TRUE(LogContainsEvent(entry_list, 8,
  1668. NetLogEventType::SOCKET_BYTES_RECEIVED,
  1669. NetLogEventPhase::NONE));
  1670. EXPECT_TRUE(
  1671. LogContainsEndEvent(entry_list, 9, NetLogEventType::SOCKET_ALIVE));
  1672. }
  1673. // A helper class that will delete |sock| when the callback is invoked.
  1674. class DeleteSockCallback : public TestCompletionCallbackBase {
  1675. public:
  1676. explicit DeleteSockCallback(std::unique_ptr<QuicProxyClientSocket>* sock)
  1677. : sock_(sock) {}
  1678. DeleteSockCallback(const DeleteSockCallback&) = delete;
  1679. DeleteSockCallback& operator=(const DeleteSockCallback&) = delete;
  1680. ~DeleteSockCallback() override = default;
  1681. CompletionOnceCallback callback() {
  1682. return base::BindOnce(&DeleteSockCallback::OnComplete,
  1683. base::Unretained(this));
  1684. }
  1685. private:
  1686. void OnComplete(int result) {
  1687. sock_->reset(nullptr);
  1688. SetResult(result);
  1689. }
  1690. raw_ptr<std::unique_ptr<QuicProxyClientSocket>> sock_;
  1691. };
  1692. // If the socket is reset when both a read and write are pending, and the
  1693. // read callback causes the socket to be deleted, the write callback should
  1694. // not be called.
  1695. TEST_P(QuicProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
  1696. int packet_number = 1;
  1697. if (VersionUsesHttp3(version_.transport_version)) {
  1698. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1699. ConstructSettingsPacket(packet_number++));
  1700. }
  1701. mock_quic_data_.AddWrite(SYNCHRONOUS,
  1702. ConstructConnectRequestPacket(packet_number++));
  1703. mock_quic_data_.AddRead(ASYNC, ConstructServerConnectReplyPacket(1, !kFin));
  1704. mock_quic_data_.AddRead(ASYNC, ERR_IO_PENDING); // Pause
  1705. mock_quic_data_.AddRead(
  1706. ASYNC, ConstructServerRstPacket(2, quic::QUIC_STREAM_CANCELLED));
  1707. mock_quic_data_.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
  1708. if (!version_.HasIetfQuicFrames()) {
  1709. mock_quic_data_.AddWrite(
  1710. ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
  1711. std::string(kMsg1, kLen1)));
  1712. mock_quic_data_.AddWrite(
  1713. SYNCHRONOUS,
  1714. ConstructAckAndRstPacket(packet_number++,
  1715. quic::QUIC_RST_ACKNOWLEDGEMENT, 2, 2));
  1716. } else {
  1717. std::string header = ConstructDataHeader(kLen1);
  1718. mock_quic_data_.AddWrite(
  1719. ASYNC, ConstructAckAndDataPacket(packet_number++, 1, 1,
  1720. {header + std::string(kMsg1, kLen1)}));
  1721. mock_quic_data_.AddWrite(
  1722. SYNCHRONOUS, ConstructAckAndRstOnlyPacket(
  1723. packet_number++, quic::QUIC_STREAM_CANCELLED, 2, 2));
  1724. }
  1725. Initialize();
  1726. AssertConnectSucceeds();
  1727. EXPECT_TRUE(sock_->IsConnected());
  1728. DeleteSockCallback read_callback(&sock_);
  1729. scoped_refptr<IOBuffer> read_buf = base::MakeRefCounted<IOBuffer>(kLen1);
  1730. ASSERT_EQ(ERR_IO_PENDING,
  1731. sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
  1732. // QuicChromiumClientStream::Handle::WriteStreamData() will only be
  1733. // asynchronous starting with the second time it's called while the UDP socket
  1734. // is write-blocked. Therefore, at least two writes need to be called on
  1735. // |sock_| to get an asynchronous one.
  1736. AssertWriteReturns(kMsg1, kLen1, kLen1);
  1737. AssertWriteReturns(kMsg1, kLen1, ERR_IO_PENDING);
  1738. ResumeAndRun();
  1739. EXPECT_FALSE(sock_.get());
  1740. EXPECT_EQ(0, read_callback.WaitForResult());
  1741. EXPECT_FALSE(write_callback_.have_result());
  1742. }
  1743. INSTANTIATE_TEST_SUITE_P(VersionIncludeStreamDependencySequence,
  1744. QuicProxyClientSocketTest,
  1745. ::testing::ValuesIn(GetTestParams()),
  1746. ::testing::PrintToStringParamName());
  1747. } // namespace net::test