| OLD | NEW |
|---|
| (Empty) |
| 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 "net/http/http_proxy_client_socket_pool.h" | |
| 6 | |
| 7 #include "base/callback.h" | |
| 8 #include "base/compiler_specific.h" | |
| 9 #include "base/strings/string_util.h" | |
| 10 #include "base/strings/utf_string_conversions.h" | |
| 11 #include "net/base/net_errors.h" | |
| 12 #include "net/base/proxy_delegate.h" | |
| 13 #include "net/base/test_completion_callback.h" | |
| 14 #include "net/http/http_network_session.h" | |
| 15 #include "net/http/http_proxy_client_socket.h" | |
| 16 #include "net/http/http_response_headers.h" | |
| 17 #include "net/socket/client_socket_handle.h" | |
| 18 #include "net/socket/client_socket_pool_histograms.h" | |
| 19 #include "net/socket/next_proto.h" | |
| 20 #include "net/socket/socket_test_util.h" | |
| 21 #include "net/spdy/spdy_protocol.h" | |
| 22 #include "net/spdy/spdy_test_util_common.h" | |
| 23 #include "testing/gtest/include/gtest/gtest.h" | |
| 24 | |
| 25 namespace net { | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 const int kMaxSockets = 32; | |
| 30 const int kMaxSocketsPerGroup = 6; | |
| 31 const char * const kAuthHeaders[] = { | |
| 32 "proxy-authorization", "Basic Zm9vOmJhcg==" | |
| 33 }; | |
| 34 const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2; | |
| 35 | |
| 36 enum HttpProxyType { | |
| 37 HTTP, | |
| 38 HTTPS, | |
| 39 SPDY | |
| 40 }; | |
| 41 | |
| 42 struct HttpProxyClientSocketPoolTestParams { | |
| 43 HttpProxyClientSocketPoolTestParams() | |
| 44 : proxy_type(HTTP), | |
| 45 protocol(kProtoSPDY31) {} | |
| 46 | |
| 47 HttpProxyClientSocketPoolTestParams( | |
| 48 HttpProxyType proxy_type, | |
| 49 NextProto protocol) | |
| 50 : proxy_type(proxy_type), | |
| 51 protocol(protocol) {} | |
| 52 | |
| 53 HttpProxyType proxy_type; | |
| 54 NextProto protocol; | |
| 55 }; | |
| 56 | |
| 57 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam; | |
| 58 | |
| 59 const char kHttpProxyHost[] = "httpproxy.example.com"; | |
| 60 const char kHttpsProxyHost[] = "httpsproxy.example.com"; | |
| 61 | |
| 62 class TestProxyDelegate : public ProxyDelegate { | |
| 63 public: | |
| 64 TestProxyDelegate() | |
| 65 : on_before_tunnel_request_called_(false), | |
| 66 on_tunnel_request_completed_called_(false), | |
| 67 on_tunnel_headers_received_called_(false) { | |
| 68 } | |
| 69 | |
| 70 ~TestProxyDelegate() override {} | |
| 71 | |
| 72 bool on_before_tunnel_request_called() const { | |
| 73 return on_before_tunnel_request_called_; | |
| 74 } | |
| 75 | |
| 76 bool on_tunnel_request_completed_called() const { | |
| 77 return on_tunnel_request_completed_called_; | |
| 78 } | |
| 79 | |
| 80 bool on_tunnel_headers_received_called() const { | |
| 81 return on_tunnel_headers_received_called_; | |
| 82 } | |
| 83 | |
| 84 void VerifyOnTunnelRequestCompleted(const std::string& endpoint, | |
| 85 const std::string& proxy_server) const { | |
| 86 EXPECT_TRUE(on_tunnel_request_completed_called_); | |
| 87 EXPECT_TRUE(HostPortPair::FromString(endpoint).Equals( | |
| 88 on_tunnel_request_completed_endpoint_)); | |
| 89 EXPECT_TRUE(HostPortPair::FromString(proxy_server).Equals( | |
| 90 on_tunnel_request_completed_proxy_server_)); | |
| 91 } | |
| 92 | |
| 93 void VerifyOnTunnelHeadersReceived(const std::string& origin, | |
| 94 const std::string& proxy_server, | |
| 95 const std::string& status_line) const { | |
| 96 EXPECT_TRUE(on_tunnel_headers_received_called_); | |
| 97 EXPECT_TRUE(HostPortPair::FromString(origin).Equals( | |
| 98 on_tunnel_headers_received_origin_)); | |
| 99 EXPECT_TRUE(HostPortPair::FromString(proxy_server).Equals( | |
| 100 on_tunnel_headers_received_proxy_server_)); | |
| 101 EXPECT_EQ(status_line, on_tunnel_headers_received_status_line_); | |
| 102 } | |
| 103 | |
| 104 // ProxyDelegate: | |
| 105 void OnResolveProxy(const GURL& url, | |
| 106 int load_flags, | |
| 107 const ProxyService& proxy_service, | |
| 108 ProxyInfo* result) override {} | |
| 109 | |
| 110 void OnTunnelConnectCompleted(const HostPortPair& endpoint, | |
| 111 const HostPortPair& proxy_server, | |
| 112 int net_error) override { | |
| 113 on_tunnel_request_completed_called_ = true; | |
| 114 on_tunnel_request_completed_endpoint_ = endpoint; | |
| 115 on_tunnel_request_completed_proxy_server_ = proxy_server; | |
| 116 } | |
| 117 | |
| 118 void OnFallback(const ProxyServer& bad_proxy, int net_error) override {} | |
| 119 | |
| 120 void OnBeforeSendHeaders(URLRequest* request, | |
| 121 const ProxyInfo& proxy_info, | |
| 122 HttpRequestHeaders* headers) override {} | |
| 123 | |
| 124 void OnBeforeTunnelRequest(const net::HostPortPair& proxy_server, | |
| 125 net::HttpRequestHeaders* extra_headers) override { | |
| 126 on_before_tunnel_request_called_ = true; | |
| 127 if (extra_headers) { | |
| 128 extra_headers->SetHeader("Foo", proxy_server.ToString()); | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 void OnTunnelHeadersReceived( | |
| 133 const net::HostPortPair& origin, | |
| 134 const net::HostPortPair& proxy_server, | |
| 135 const net::HttpResponseHeaders& response_headers) override { | |
| 136 on_tunnel_headers_received_called_ = true; | |
| 137 on_tunnel_headers_received_origin_ = origin; | |
| 138 on_tunnel_headers_received_proxy_server_ = proxy_server; | |
| 139 on_tunnel_headers_received_status_line_ = response_headers.GetStatusLine(); | |
| 140 } | |
| 141 | |
| 142 private: | |
| 143 bool on_before_tunnel_request_called_; | |
| 144 bool on_tunnel_request_completed_called_; | |
| 145 bool on_tunnel_headers_received_called_; | |
| 146 HostPortPair on_tunnel_request_completed_endpoint_; | |
| 147 HostPortPair on_tunnel_request_completed_proxy_server_; | |
| 148 HostPortPair on_tunnel_headers_received_origin_; | |
| 149 HostPortPair on_tunnel_headers_received_proxy_server_; | |
| 150 std::string on_tunnel_headers_received_status_line_; | |
| 151 }; | |
| 152 | |
| 153 | |
| 154 class HttpProxyClientSocketPoolTest | |
| 155 : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> { | |
| 156 protected: | |
| 157 HttpProxyClientSocketPoolTest() | |
| 158 : session_deps_(GetParam().protocol), | |
| 159 tcp_histograms_("MockTCP"), | |
| 160 transport_socket_pool_( | |
| 161 kMaxSockets, | |
| 162 kMaxSocketsPerGroup, | |
| 163 &tcp_histograms_, | |
| 164 session_deps_.deterministic_socket_factory.get()), | |
| 165 ssl_histograms_("MockSSL"), | |
| 166 ssl_socket_pool_(kMaxSockets, | |
| 167 kMaxSocketsPerGroup, | |
| 168 &ssl_histograms_, | |
| 169 session_deps_.cert_verifier.get(), | |
| 170 NULL /* channel_id_store */, | |
| 171 NULL /* transport_security_state */, | |
| 172 NULL /* cert_transparency_verifier */, | |
| 173 NULL /* cert_policy_enforcer */, | |
| 174 std::string() /* ssl_session_cache_shard */, | |
| 175 session_deps_.deterministic_socket_factory.get(), | |
| 176 &transport_socket_pool_, | |
| 177 NULL, | |
| 178 NULL, | |
| 179 session_deps_.ssl_config_service.get(), | |
| 180 false, | |
| 181 BoundNetLog().net_log()), | |
| 182 session_(CreateNetworkSession()), | |
| 183 http_proxy_histograms_("HttpProxyUnitTest"), | |
| 184 spdy_util_(GetParam().protocol), | |
| 185 pool_(kMaxSockets, | |
| 186 kMaxSocketsPerGroup, | |
| 187 &http_proxy_histograms_, | |
| 188 &transport_socket_pool_, | |
| 189 &ssl_socket_pool_, | |
| 190 NULL) {} | |
| 191 | |
| 192 virtual ~HttpProxyClientSocketPoolTest() { | |
| 193 } | |
| 194 | |
| 195 void AddAuthToCache() { | |
| 196 const base::string16 kFoo(base::ASCIIToUTF16("foo")); | |
| 197 const base::string16 kBar(base::ASCIIToUTF16("bar")); | |
| 198 GURL proxy_url(GetParam().proxy_type == HTTP ? | |
| 199 (std::string("http://") + kHttpProxyHost) : | |
| 200 (std::string("https://") + kHttpsProxyHost)); | |
| 201 session_->http_auth_cache()->Add(proxy_url, | |
| 202 "MyRealm1", | |
| 203 HttpAuth::AUTH_SCHEME_BASIC, | |
| 204 "Basic realm=MyRealm1", | |
| 205 AuthCredentials(kFoo, kBar), | |
| 206 "/"); | |
| 207 } | |
| 208 | |
| 209 scoped_refptr<TransportSocketParams> CreateHttpProxyParams() const { | |
| 210 if (GetParam().proxy_type != HTTP) | |
| 211 return NULL; | |
| 212 return new TransportSocketParams( | |
| 213 HostPortPair(kHttpProxyHost, 80), | |
| 214 false, | |
| 215 false, | |
| 216 OnHostResolutionCallback(), | |
| 217 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT); | |
| 218 } | |
| 219 | |
| 220 scoped_refptr<SSLSocketParams> CreateHttpsProxyParams() const { | |
| 221 if (GetParam().proxy_type == HTTP) | |
| 222 return NULL; | |
| 223 return new SSLSocketParams( | |
| 224 new TransportSocketParams( | |
| 225 HostPortPair(kHttpsProxyHost, 443), | |
| 226 false, | |
| 227 false, | |
| 228 OnHostResolutionCallback(), | |
| 229 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT), | |
| 230 NULL, | |
| 231 NULL, | |
| 232 HostPortPair(kHttpsProxyHost, 443), | |
| 233 SSLConfig(), | |
| 234 PRIVACY_MODE_DISABLED, | |
| 235 0, | |
| 236 false, | |
| 237 false); | |
| 238 } | |
| 239 | |
| 240 // Returns the a correctly constructed HttpProxyParms | |
| 241 // for the HTTP or HTTPS proxy. | |
| 242 scoped_refptr<HttpProxySocketParams> CreateParams( | |
| 243 bool tunnel, | |
| 244 ProxyDelegate* proxy_delegate) { | |
| 245 return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams( | |
| 246 CreateHttpProxyParams(), | |
| 247 CreateHttpsProxyParams(), | |
| 248 GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), | |
| 249 std::string(), | |
| 250 HostPortPair("www.google.com", tunnel ? 443 : 80), | |
| 251 session_->http_auth_cache(), | |
| 252 session_->http_auth_handler_factory(), | |
| 253 session_->spdy_session_pool(), | |
| 254 tunnel, | |
| 255 proxy_delegate)); | |
| 256 } | |
| 257 | |
| 258 scoped_refptr<HttpProxySocketParams> CreateTunnelParams( | |
| 259 ProxyDelegate* proxy_delegate) { | |
| 260 return CreateParams(true, proxy_delegate); | |
| 261 } | |
| 262 | |
| 263 scoped_refptr<HttpProxySocketParams> CreateNoTunnelParams( | |
| 264 ProxyDelegate* proxy_delegate) { | |
| 265 return CreateParams(false, proxy_delegate); | |
| 266 } | |
| 267 | |
| 268 DeterministicMockClientSocketFactory* socket_factory() { | |
| 269 return session_deps_.deterministic_socket_factory.get(); | |
| 270 } | |
| 271 | |
| 272 void Initialize(MockRead* reads, size_t reads_count, | |
| 273 MockWrite* writes, size_t writes_count, | |
| 274 MockRead* spdy_reads, size_t spdy_reads_count, | |
| 275 MockWrite* spdy_writes, size_t spdy_writes_count) { | |
| 276 if (GetParam().proxy_type == SPDY) { | |
| 277 data_.reset(new DeterministicSocketData(spdy_reads, spdy_reads_count, | |
| 278 spdy_writes, spdy_writes_count)); | |
| 279 } else { | |
| 280 data_.reset(new DeterministicSocketData(reads, reads_count, writes, | |
| 281 writes_count)); | |
| 282 } | |
| 283 | |
| 284 data_->set_connect_data(MockConnect(SYNCHRONOUS, OK)); | |
| 285 data_->StopAfter(2); // Request / Response | |
| 286 | |
| 287 socket_factory()->AddSocketDataProvider(data_.get()); | |
| 288 | |
| 289 if (GetParam().proxy_type != HTTP) { | |
| 290 ssl_data_.reset(new SSLSocketDataProvider(SYNCHRONOUS, OK)); | |
| 291 if (GetParam().proxy_type == SPDY) { | |
| 292 InitializeSpdySsl(); | |
| 293 } | |
| 294 socket_factory()->AddSSLSocketDataProvider(ssl_data_.get()); | |
| 295 } | |
| 296 } | |
| 297 | |
| 298 void InitializeSpdySsl() { | |
| 299 ssl_data_->SetNextProto(GetParam().protocol); | |
| 300 } | |
| 301 | |
| 302 HttpNetworkSession* CreateNetworkSession() { | |
| 303 return SpdySessionDependencies::SpdyCreateSessionDeterministic( | |
| 304 &session_deps_); | |
| 305 } | |
| 306 | |
| 307 RequestPriority GetLastTransportRequestPriority() const { | |
| 308 return transport_socket_pool_.last_request_priority(); | |
| 309 } | |
| 310 | |
| 311 private: | |
| 312 SpdySessionDependencies session_deps_; | |
| 313 | |
| 314 ClientSocketPoolHistograms tcp_histograms_; | |
| 315 MockTransportClientSocketPool transport_socket_pool_; | |
| 316 ClientSocketPoolHistograms ssl_histograms_; | |
| 317 MockHostResolver host_resolver_; | |
| 318 scoped_ptr<CertVerifier> cert_verifier_; | |
| 319 SSLClientSocketPool ssl_socket_pool_; | |
| 320 | |
| 321 const scoped_refptr<HttpNetworkSession> session_; | |
| 322 ClientSocketPoolHistograms http_proxy_histograms_; | |
| 323 | |
| 324 protected: | |
| 325 SpdyTestUtil spdy_util_; | |
| 326 scoped_ptr<SSLSocketDataProvider> ssl_data_; | |
| 327 scoped_ptr<DeterministicSocketData> data_; | |
| 328 HttpProxyClientSocketPool pool_; | |
| 329 ClientSocketHandle handle_; | |
| 330 TestCompletionCallback callback_; | |
| 331 }; | |
| 332 | |
| 333 //----------------------------------------------------------------------------- | |
| 334 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY) | |
| 335 // and SPDY. | |
| 336 // | |
| 337 // TODO(akalin): Use ::testing::Combine() when we are able to use | |
| 338 // <tr1/tuple>. | |
| 339 INSTANTIATE_TEST_CASE_P( | |
| 340 HttpProxyClientSocketPoolTests, | |
| 341 HttpProxyClientSocketPoolTest, | |
| 342 ::testing::Values( | |
| 343 HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31), | |
| 344 HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31), | |
| 345 HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31), | |
| 346 HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY4_14), | |
| 347 HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY4_14), | |
| 348 HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY4_14), | |
| 349 HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY4_15), | |
| 350 HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY4_15), | |
| 351 HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY4_15))); | |
| 352 | |
| 353 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) { | |
| 354 Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0); | |
| 355 | |
| 356 scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate()); | |
| 357 int rv = handle_.Init("a", CreateNoTunnelParams(proxy_delegate.get()), LOW, | |
| 358 CompletionCallback(), &pool_, BoundNetLog()); | |
| 359 EXPECT_EQ(OK, rv); | |
| 360 EXPECT_TRUE(handle_.is_initialized()); | |
| 361 ASSERT_TRUE(handle_.socket()); | |
| 362 HttpProxyClientSocket* tunnel_socket = | |
| 363 static_cast<HttpProxyClientSocket*>(handle_.socket()); | |
| 364 EXPECT_TRUE(tunnel_socket->IsConnected()); | |
| 365 EXPECT_FALSE(proxy_delegate->on_before_tunnel_request_called()); | |
| 366 EXPECT_FALSE(proxy_delegate->on_tunnel_headers_received_called()); | |
| 367 EXPECT_TRUE(proxy_delegate->on_tunnel_request_completed_called()); | |
| 368 } | |
| 369 | |
| 370 // Make sure that HttpProxyConnectJob passes on its priority to its | |
| 371 // (non-SSL) socket request on Init. | |
| 372 TEST_P(HttpProxyClientSocketPoolTest, SetSocketRequestPriorityOnInit) { | |
| 373 Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0); | |
| 374 EXPECT_EQ(OK, | |
| 375 handle_.Init("a", CreateNoTunnelParams(NULL), HIGHEST, | |
| 376 CompletionCallback(), &pool_, BoundNetLog())); | |
| 377 EXPECT_EQ(HIGHEST, GetLastTransportRequestPriority()); | |
| 378 } | |
| 379 | |
| 380 TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) { | |
| 381 MockWrite writes[] = { | |
| 382 MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 383 "Host: www.google.com\r\n" | |
| 384 "Proxy-Connection: keep-alive\r\n\r\n"), | |
| 385 }; | |
| 386 MockRead reads[] = { | |
| 387 // No credentials. | |
| 388 MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"), | |
| 389 MockRead(ASYNC, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | |
| 390 MockRead(ASYNC, 3, "Content-Length: 10\r\n\r\n"), | |
| 391 MockRead(ASYNC, 4, "0123456789"), | |
| 392 }; | |
| 393 scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect( | |
| 394 NULL, 0, 1, LOW, HostPortPair("www.google.com", 443))); | |
| 395 scoped_ptr<SpdyFrame> rst( | |
| 396 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 397 MockWrite spdy_writes[] = { | |
| 398 CreateMockWrite(*req, 0, ASYNC), | |
| 399 CreateMockWrite(*rst, 2, ASYNC), | |
| 400 }; | |
| 401 SpdyHeaderBlock resp_block; | |
| 402 resp_block[spdy_util_.GetStatusKey()] = "407"; | |
| 403 resp_block["proxy-authenticate"] = "Basic realm=\"MyRealm1\""; | |
| 404 spdy_util_.MaybeAddVersionHeader(&resp_block); | |
| 405 | |
| 406 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyReply(1, resp_block)); | |
| 407 MockRead spdy_reads[] = { | |
| 408 CreateMockRead(*resp, 1, ASYNC), | |
| 409 MockRead(ASYNC, 0, 3) | |
| 410 }; | |
| 411 | |
| 412 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 413 spdy_reads, arraysize(spdy_reads), spdy_writes, | |
| 414 arraysize(spdy_writes)); | |
| 415 | |
| 416 data_->StopAfter(4); | |
| 417 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 418 callback_.callback(), &pool_, BoundNetLog()); | |
| 419 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 420 EXPECT_FALSE(handle_.is_initialized()); | |
| 421 EXPECT_FALSE(handle_.socket()); | |
| 422 | |
| 423 data_->RunFor(GetParam().proxy_type == SPDY ? 2 : 4); | |
| 424 rv = callback_.WaitForResult(); | |
| 425 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, rv); | |
| 426 EXPECT_TRUE(handle_.is_initialized()); | |
| 427 ASSERT_TRUE(handle_.socket()); | |
| 428 ProxyClientSocket* tunnel_socket = | |
| 429 static_cast<ProxyClientSocket*>(handle_.socket()); | |
| 430 if (GetParam().proxy_type == SPDY) { | |
| 431 EXPECT_TRUE(tunnel_socket->IsConnected()); | |
| 432 EXPECT_TRUE(tunnel_socket->IsUsingSpdy()); | |
| 433 } else { | |
| 434 EXPECT_FALSE(tunnel_socket->IsConnected()); | |
| 435 EXPECT_FALSE(tunnel_socket->IsUsingSpdy()); | |
| 436 } | |
| 437 } | |
| 438 | |
| 439 TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) { | |
| 440 // It's pretty much impossible to make the SPDY case behave synchronously | |
| 441 // so we skip this test for SPDY | |
| 442 if (GetParam().proxy_type == SPDY) | |
| 443 return; | |
| 444 std::string proxy_host_port = | |
| 445 GetParam().proxy_type == HTTP ? | |
| 446 (kHttpProxyHost + std::string(":80")) : | |
| 447 (kHttpsProxyHost + std::string(":443")); | |
| 448 std::string request = | |
| 449 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 450 "Host: www.google.com\r\n" | |
| 451 "Proxy-Connection: keep-alive\r\n" | |
| 452 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n" | |
| 453 "Foo: " + proxy_host_port + "\r\n\r\n"; | |
| 454 MockWrite writes[] = { | |
| 455 MockWrite(SYNCHRONOUS, 0, request.c_str()), | |
| 456 }; | |
| 457 MockRead reads[] = { | |
| 458 MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"), | |
| 459 }; | |
| 460 | |
| 461 Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0, | |
| 462 NULL, 0); | |
| 463 AddAuthToCache(); | |
| 464 | |
| 465 scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate()); | |
| 466 int rv = handle_.Init("a", CreateTunnelParams(proxy_delegate.get()), LOW, | |
| 467 callback_.callback(), &pool_, BoundNetLog()); | |
| 468 EXPECT_EQ(OK, rv); | |
| 469 EXPECT_TRUE(handle_.is_initialized()); | |
| 470 ASSERT_TRUE(handle_.socket()); | |
| 471 HttpProxyClientSocket* tunnel_socket = | |
| 472 static_cast<HttpProxyClientSocket*>(handle_.socket()); | |
| 473 EXPECT_TRUE(tunnel_socket->IsConnected()); | |
| 474 proxy_delegate->VerifyOnTunnelHeadersReceived( | |
| 475 "www.google.com:443", | |
| 476 proxy_host_port.c_str(), | |
| 477 "HTTP/1.1 200 Connection Established"); | |
| 478 proxy_delegate->VerifyOnTunnelRequestCompleted( | |
| 479 "www.google.com:443", | |
| 480 proxy_host_port.c_str()); | |
| 481 } | |
| 482 | |
| 483 TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) { | |
| 484 std::string proxy_host_port = | |
| 485 GetParam().proxy_type == HTTP ? | |
| 486 (kHttpProxyHost + std::string(":80")) : | |
| 487 (kHttpsProxyHost + std::string(":443")); | |
| 488 std::string request = | |
| 489 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 490 "Host: www.google.com\r\n" | |
| 491 "Proxy-Connection: keep-alive\r\n" | |
| 492 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n" | |
| 493 "Foo: " + proxy_host_port + "\r\n\r\n"; | |
| 494 MockWrite writes[] = { | |
| 495 MockWrite(ASYNC, 0, request.c_str()), | |
| 496 }; | |
| 497 MockRead reads[] = { | |
| 498 MockRead(ASYNC, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"), | |
| 499 }; | |
| 500 | |
| 501 scoped_ptr<SpdyFrame> req( | |
| 502 spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW, | |
| 503 HostPortPair("www.google.com", 443))); | |
| 504 MockWrite spdy_writes[] = { | |
| 505 CreateMockWrite(*req, 0, ASYNC) | |
| 506 }; | |
| 507 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | |
| 508 MockRead spdy_reads[] = { | |
| 509 CreateMockRead(*resp, 1, ASYNC), | |
| 510 MockRead(ASYNC, 0, 2) | |
| 511 }; | |
| 512 | |
| 513 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 514 spdy_reads, arraysize(spdy_reads), spdy_writes, | |
| 515 arraysize(spdy_writes)); | |
| 516 AddAuthToCache(); | |
| 517 | |
| 518 scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate()); | |
| 519 int rv = handle_.Init("a", CreateTunnelParams(proxy_delegate.get()), LOW, | |
| 520 callback_.callback(), &pool_, BoundNetLog()); | |
| 521 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 522 EXPECT_FALSE(handle_.is_initialized()); | |
| 523 EXPECT_FALSE(handle_.socket()); | |
| 524 | |
| 525 data_->RunFor(2); | |
| 526 EXPECT_EQ(OK, callback_.WaitForResult()); | |
| 527 EXPECT_TRUE(handle_.is_initialized()); | |
| 528 ASSERT_TRUE(handle_.socket()); | |
| 529 HttpProxyClientSocket* tunnel_socket = | |
| 530 static_cast<HttpProxyClientSocket*>(handle_.socket()); | |
| 531 EXPECT_TRUE(tunnel_socket->IsConnected()); | |
| 532 proxy_delegate->VerifyOnTunnelRequestCompleted( | |
| 533 "www.google.com:443", | |
| 534 proxy_host_port.c_str()); | |
| 535 } | |
| 536 | |
| 537 // Make sure that HttpProxyConnectJob passes on its priority to its | |
| 538 // SPDY session's socket request on Init (if applicable). | |
| 539 TEST_P(HttpProxyClientSocketPoolTest, | |
| 540 SetSpdySessionSocketRequestPriorityOnInit) { | |
| 541 if (GetParam().proxy_type != SPDY) | |
| 542 return; | |
| 543 | |
| 544 scoped_ptr<SpdyFrame> req( | |
| 545 spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, MEDIUM, | |
| 546 HostPortPair("www.google.com", 443))); | |
| 547 MockWrite spdy_writes[] = { | |
| 548 CreateMockWrite(*req, 0, ASYNC) | |
| 549 }; | |
| 550 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | |
| 551 MockRead spdy_reads[] = { | |
| 552 CreateMockRead(*resp, 1, ASYNC), | |
| 553 MockRead(ASYNC, 0, 2) | |
| 554 }; | |
| 555 | |
| 556 Initialize(NULL, 0, NULL, 0, | |
| 557 spdy_reads, arraysize(spdy_reads), | |
| 558 spdy_writes, arraysize(spdy_writes)); | |
| 559 AddAuthToCache(); | |
| 560 | |
| 561 EXPECT_EQ(ERR_IO_PENDING, | |
| 562 handle_.Init("a", CreateTunnelParams(NULL), MEDIUM, | |
| 563 callback_.callback(), &pool_, BoundNetLog())); | |
| 564 EXPECT_EQ(MEDIUM, GetLastTransportRequestPriority()); | |
| 565 | |
| 566 data_->RunFor(2); | |
| 567 EXPECT_EQ(OK, callback_.WaitForResult()); | |
| 568 } | |
| 569 | |
| 570 TEST_P(HttpProxyClientSocketPoolTest, TCPError) { | |
| 571 if (GetParam().proxy_type == SPDY) return; | |
| 572 data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0)); | |
| 573 data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED)); | |
| 574 | |
| 575 socket_factory()->AddSocketDataProvider(data_.get()); | |
| 576 | |
| 577 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 578 callback_.callback(), &pool_, BoundNetLog()); | |
| 579 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 580 EXPECT_FALSE(handle_.is_initialized()); | |
| 581 EXPECT_FALSE(handle_.socket()); | |
| 582 | |
| 583 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult()); | |
| 584 | |
| 585 EXPECT_FALSE(handle_.is_initialized()); | |
| 586 EXPECT_FALSE(handle_.socket()); | |
| 587 } | |
| 588 | |
| 589 TEST_P(HttpProxyClientSocketPoolTest, SSLError) { | |
| 590 if (GetParam().proxy_type == HTTP) return; | |
| 591 data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0)); | |
| 592 data_->set_connect_data(MockConnect(ASYNC, OK)); | |
| 593 socket_factory()->AddSocketDataProvider(data_.get()); | |
| 594 | |
| 595 ssl_data_.reset(new SSLSocketDataProvider(ASYNC, | |
| 596 ERR_CERT_AUTHORITY_INVALID)); | |
| 597 if (GetParam().proxy_type == SPDY) { | |
| 598 InitializeSpdySsl(); | |
| 599 } | |
| 600 socket_factory()->AddSSLSocketDataProvider(ssl_data_.get()); | |
| 601 | |
| 602 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 603 callback_.callback(), &pool_, BoundNetLog()); | |
| 604 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 605 EXPECT_FALSE(handle_.is_initialized()); | |
| 606 EXPECT_FALSE(handle_.socket()); | |
| 607 | |
| 608 EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult()); | |
| 609 | |
| 610 EXPECT_FALSE(handle_.is_initialized()); | |
| 611 EXPECT_FALSE(handle_.socket()); | |
| 612 } | |
| 613 | |
| 614 TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) { | |
| 615 if (GetParam().proxy_type == HTTP) return; | |
| 616 data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0)); | |
| 617 data_->set_connect_data(MockConnect(ASYNC, OK)); | |
| 618 socket_factory()->AddSocketDataProvider(data_.get()); | |
| 619 | |
| 620 ssl_data_.reset(new SSLSocketDataProvider(ASYNC, | |
| 621 ERR_SSL_CLIENT_AUTH_CERT_NEEDED)); | |
| 622 if (GetParam().proxy_type == SPDY) { | |
| 623 InitializeSpdySsl(); | |
| 624 } | |
| 625 socket_factory()->AddSSLSocketDataProvider(ssl_data_.get()); | |
| 626 | |
| 627 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 628 callback_.callback(), &pool_, BoundNetLog()); | |
| 629 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 630 EXPECT_FALSE(handle_.is_initialized()); | |
| 631 EXPECT_FALSE(handle_.socket()); | |
| 632 | |
| 633 EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, callback_.WaitForResult()); | |
| 634 | |
| 635 EXPECT_FALSE(handle_.is_initialized()); | |
| 636 EXPECT_FALSE(handle_.socket()); | |
| 637 } | |
| 638 | |
| 639 TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) { | |
| 640 MockWrite writes[] = { | |
| 641 MockWrite(ASYNC, 0, | |
| 642 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 643 "Host: www.google.com\r\n" | |
| 644 "Proxy-Connection: keep-alive\r\n" | |
| 645 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | |
| 646 }; | |
| 647 MockRead reads[] = { | |
| 648 MockRead(ASYNC, 1, "HTTP/1.1 200 Conn"), | |
| 649 MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2), | |
| 650 }; | |
| 651 scoped_ptr<SpdyFrame> req( | |
| 652 spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW, | |
| 653 HostPortPair("www.google.com", 443))); | |
| 654 MockWrite spdy_writes[] = { | |
| 655 CreateMockWrite(*req, 0, ASYNC) | |
| 656 }; | |
| 657 MockRead spdy_reads[] = { | |
| 658 MockRead(ASYNC, ERR_CONNECTION_CLOSED, 1), | |
| 659 }; | |
| 660 | |
| 661 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 662 spdy_reads, arraysize(spdy_reads), spdy_writes, | |
| 663 arraysize(spdy_writes)); | |
| 664 AddAuthToCache(); | |
| 665 | |
| 666 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 667 callback_.callback(), &pool_, BoundNetLog()); | |
| 668 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 669 EXPECT_FALSE(handle_.is_initialized()); | |
| 670 EXPECT_FALSE(handle_.socket()); | |
| 671 | |
| 672 data_->RunFor(3); | |
| 673 if (GetParam().proxy_type == SPDY) { | |
| 674 // SPDY cannot process a headers block unless it's complete and so it | |
| 675 // returns ERR_CONNECTION_CLOSED in this case. | |
| 676 EXPECT_EQ(ERR_CONNECTION_CLOSED, callback_.WaitForResult()); | |
| 677 } else { | |
| 678 EXPECT_EQ(ERR_RESPONSE_HEADERS_TRUNCATED, callback_.WaitForResult()); | |
| 679 } | |
| 680 EXPECT_FALSE(handle_.is_initialized()); | |
| 681 EXPECT_FALSE(handle_.socket()); | |
| 682 } | |
| 683 | |
| 684 TEST_P(HttpProxyClientSocketPoolTest, Tunnel1xxResponse) { | |
| 685 // Tests that 1xx responses are rejected for a CONNECT request. | |
| 686 if (GetParam().proxy_type == SPDY) { | |
| 687 // SPDY doesn't have 1xx responses. | |
| 688 return; | |
| 689 } | |
| 690 | |
| 691 MockWrite writes[] = { | |
| 692 MockWrite(ASYNC, 0, | |
| 693 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 694 "Host: www.google.com\r\n" | |
| 695 "Proxy-Connection: keep-alive\r\n\r\n"), | |
| 696 }; | |
| 697 MockRead reads[] = { | |
| 698 MockRead(ASYNC, 1, "HTTP/1.1 100 Continue\r\n\r\n"), | |
| 699 MockRead(ASYNC, 2, "HTTP/1.1 200 Connection Established\r\n\r\n"), | |
| 700 }; | |
| 701 | |
| 702 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 703 NULL, 0, NULL, 0); | |
| 704 | |
| 705 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 706 callback_.callback(), &pool_, BoundNetLog()); | |
| 707 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 708 EXPECT_FALSE(handle_.is_initialized()); | |
| 709 EXPECT_FALSE(handle_.socket()); | |
| 710 | |
| 711 data_->RunFor(2); | |
| 712 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, callback_.WaitForResult()); | |
| 713 } | |
| 714 | |
| 715 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) { | |
| 716 MockWrite writes[] = { | |
| 717 MockWrite(ASYNC, 0, | |
| 718 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 719 "Host: www.google.com\r\n" | |
| 720 "Proxy-Connection: keep-alive\r\n" | |
| 721 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | |
| 722 }; | |
| 723 MockRead reads[] = { | |
| 724 MockRead(ASYNC, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"), | |
| 725 }; | |
| 726 scoped_ptr<SpdyFrame> req( | |
| 727 spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW, | |
| 728 HostPortPair("www.google.com", 443))); | |
| 729 scoped_ptr<SpdyFrame> rst( | |
| 730 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 731 MockWrite spdy_writes[] = { | |
| 732 CreateMockWrite(*req, 0, ASYNC), | |
| 733 CreateMockWrite(*rst, 2, ASYNC), | |
| 734 }; | |
| 735 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdySynReplyError(1)); | |
| 736 MockRead spdy_reads[] = { | |
| 737 CreateMockRead(*resp, 1, ASYNC), | |
| 738 MockRead(ASYNC, 0, 3), | |
| 739 }; | |
| 740 | |
| 741 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 742 spdy_reads, arraysize(spdy_reads), spdy_writes, | |
| 743 arraysize(spdy_writes)); | |
| 744 AddAuthToCache(); | |
| 745 | |
| 746 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 747 callback_.callback(), &pool_, BoundNetLog()); | |
| 748 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 749 EXPECT_FALSE(handle_.is_initialized()); | |
| 750 EXPECT_FALSE(handle_.socket()); | |
| 751 | |
| 752 data_->RunFor(2); | |
| 753 | |
| 754 rv = callback_.WaitForResult(); | |
| 755 // All Proxy CONNECT responses are not trustworthy | |
| 756 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); | |
| 757 EXPECT_FALSE(handle_.is_initialized()); | |
| 758 EXPECT_FALSE(handle_.socket()); | |
| 759 } | |
| 760 | |
| 761 TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupRedirect) { | |
| 762 const std::string redirectTarget = "https://foo.google.com/"; | |
| 763 | |
| 764 const std::string responseText = "HTTP/1.1 302 Found\r\n" | |
| 765 "Location: " + redirectTarget + "\r\n" | |
| 766 "Set-Cookie: foo=bar\r\n" | |
| 767 "\r\n"; | |
| 768 MockWrite writes[] = { | |
| 769 MockWrite(ASYNC, 0, | |
| 770 "CONNECT www.google.com:443 HTTP/1.1\r\n" | |
| 771 "Host: www.google.com\r\n" | |
| 772 "Proxy-Connection: keep-alive\r\n" | |
| 773 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | |
| 774 }; | |
| 775 MockRead reads[] = { | |
| 776 MockRead(ASYNC, 1, responseText.c_str()), | |
| 777 }; | |
| 778 scoped_ptr<SpdyFrame> req( | |
| 779 spdy_util_.ConstructSpdyConnect(kAuthHeaders, kAuthHeadersSize, 1, LOW, | |
| 780 HostPortPair("www.google.com", 443))); | |
| 781 scoped_ptr<SpdyFrame> rst( | |
| 782 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | |
| 783 | |
| 784 MockWrite spdy_writes[] = { | |
| 785 CreateMockWrite(*req, 0, ASYNC), | |
| 786 CreateMockWrite(*rst, 3, ASYNC), | |
| 787 }; | |
| 788 | |
| 789 const char* const responseHeaders[] = { | |
| 790 "location", redirectTarget.c_str(), | |
| 791 "set-cookie", "foo=bar", | |
| 792 }; | |
| 793 const int responseHeadersSize = arraysize(responseHeaders) / 2; | |
| 794 scoped_ptr<SpdyFrame> resp( | |
| 795 spdy_util_.ConstructSpdySynReplyError( | |
| 796 "302 Found", | |
| 797 responseHeaders, responseHeadersSize, | |
| 798 1)); | |
| 799 MockRead spdy_reads[] = { | |
| 800 CreateMockRead(*resp, 1, ASYNC), | |
| 801 MockRead(ASYNC, 0, 2), | |
| 802 }; | |
| 803 | |
| 804 Initialize(reads, arraysize(reads), writes, arraysize(writes), | |
| 805 spdy_reads, arraysize(spdy_reads), spdy_writes, | |
| 806 arraysize(spdy_writes)); | |
| 807 AddAuthToCache(); | |
| 808 | |
| 809 int rv = handle_.Init("a", CreateTunnelParams(NULL), LOW, | |
| 810 callback_.callback(), &pool_, BoundNetLog()); | |
| 811 EXPECT_EQ(ERR_IO_PENDING, rv); | |
| 812 EXPECT_FALSE(handle_.is_initialized()); | |
| 813 EXPECT_FALSE(handle_.socket()); | |
| 814 | |
| 815 data_->RunFor(2); | |
| 816 | |
| 817 rv = callback_.WaitForResult(); | |
| 818 | |
| 819 if (GetParam().proxy_type == HTTP) { | |
| 820 // We don't trust 302 responses to CONNECT from HTTP proxies. | |
| 821 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); | |
| 822 EXPECT_FALSE(handle_.is_initialized()); | |
| 823 EXPECT_FALSE(handle_.socket()); | |
| 824 } else { | |
| 825 // Expect ProxyClientSocket to return the proxy's response, sanitized. | |
| 826 EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv); | |
| 827 EXPECT_TRUE(handle_.is_initialized()); | |
| 828 ASSERT_TRUE(handle_.socket()); | |
| 829 | |
| 830 const ProxyClientSocket* tunnel_socket = | |
| 831 static_cast<ProxyClientSocket*>(handle_.socket()); | |
| 832 const HttpResponseInfo* response = tunnel_socket->GetConnectResponseInfo(); | |
| 833 const HttpResponseHeaders* headers = response->headers.get(); | |
| 834 | |
| 835 // Make sure Set-Cookie header was stripped. | |
| 836 EXPECT_FALSE(headers->HasHeader("set-cookie")); | |
| 837 | |
| 838 // Make sure Content-Length: 0 header was added. | |
| 839 EXPECT_TRUE(headers->HasHeaderValue("content-length", "0")); | |
| 840 | |
| 841 // Make sure Location header was included and correct. | |
| 842 std::string location; | |
| 843 EXPECT_TRUE(headers->IsRedirect(&location)); | |
| 844 EXPECT_EQ(location, redirectTarget); | |
| 845 } | |
| 846 } | |
| 847 | |
| 848 // It would be nice to also test the timeouts in HttpProxyClientSocketPool. | |
| 849 | |
| 850 } // namespace | |
| 851 | |
| 852 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master