OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/http/http_network_transaction.h" | 5 #include "net/http/http_network_transaction.h" |
6 | 6 |
7 #include <math.h> // ceil | 7 #include <math.h> // ceil |
8 #include <stdarg.h> | 8 #include <stdarg.h> |
9 #include <string> | 9 #include <string> |
10 #include <vector> | 10 #include <vector> |
(...skipping 403 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
414 bool CheckNTLMServerAuth(const AuthChallengeInfo* auth_challenge) { | 414 bool CheckNTLMServerAuth(const AuthChallengeInfo* auth_challenge) { |
415 if (!auth_challenge) | 415 if (!auth_challenge) |
416 return false; | 416 return false; |
417 EXPECT_FALSE(auth_challenge->is_proxy); | 417 EXPECT_FALSE(auth_challenge->is_proxy); |
418 EXPECT_EQ("172.22.68.17:80", auth_challenge->challenger.ToString()); | 418 EXPECT_EQ("172.22.68.17:80", auth_challenge->challenger.ToString()); |
419 EXPECT_EQ(std::string(), auth_challenge->realm); | 419 EXPECT_EQ(std::string(), auth_challenge->realm); |
420 EXPECT_EQ("ntlm", auth_challenge->scheme); | 420 EXPECT_EQ("ntlm", auth_challenge->scheme); |
421 return true; | 421 return true; |
422 } | 422 } |
423 | 423 |
| 424 bool CheckNTLMProxyAuth(const AuthChallengeInfo* auth_challenge) { |
| 425 if (!auth_challenge) |
| 426 return false; |
| 427 EXPECT_TRUE(auth_challenge->is_proxy); |
| 428 EXPECT_EQ("proxy:70", auth_challenge->challenger.ToString()); |
| 429 EXPECT_EQ(std::string(), auth_challenge->realm); |
| 430 EXPECT_EQ("ntlm", auth_challenge->scheme); |
| 431 return true; |
| 432 } |
| 433 |
424 TEST_F(HttpNetworkTransactionTest, Basic) { | 434 TEST_F(HttpNetworkTransactionTest, Basic) { |
425 SessionDependencies session_deps; | 435 SessionDependencies session_deps; |
426 scoped_ptr<HttpTransaction> trans( | 436 scoped_ptr<HttpTransaction> trans( |
427 new HttpNetworkTransaction(CreateSession(&session_deps))); | 437 new HttpNetworkTransaction(CreateSession(&session_deps))); |
428 } | 438 } |
429 | 439 |
430 TEST_F(HttpNetworkTransactionTest, SimpleGET) { | 440 TEST_F(HttpNetworkTransactionTest, SimpleGET) { |
431 MockRead data_reads[] = { | 441 MockRead data_reads[] = { |
432 MockRead("HTTP/1.0 200 OK\r\n\r\n"), | 442 MockRead("HTTP/1.0 200 OK\r\n\r\n"), |
433 MockRead("hello world"), | 443 MockRead("hello world"), |
(...skipping 1277 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1711 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); | 1721 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1712 session_deps.net_log = log.bound().net_log(); | 1722 session_deps.net_log = log.bound().net_log(); |
1713 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); | 1723 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
1714 | 1724 |
1715 // Since we have proxy, should try to establish tunnel. | 1725 // Since we have proxy, should try to establish tunnel. |
1716 MockWrite data_writes1[] = { | 1726 MockWrite data_writes1[] = { |
1717 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" | 1727 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
1718 "Host: www.google.com\r\n" | 1728 "Host: www.google.com\r\n" |
1719 "Proxy-Connection: keep-alive\r\n\r\n"), | 1729 "Proxy-Connection: keep-alive\r\n\r\n"), |
1720 | 1730 |
| 1731 }; |
| 1732 |
| 1733 MockWrite data_writes2[] = { |
1721 // After calling trans->RestartWithAuth(), this is the request we should | 1734 // After calling trans->RestartWithAuth(), this is the request we should |
1722 // be issuing -- the final header line contains the credentials. | 1735 // be issuing -- the final header line contains the credentials. |
1723 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" | 1736 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
1724 "Host: www.google.com\r\n" | 1737 "Host: www.google.com\r\n" |
1725 "Proxy-Connection: keep-alive\r\n" | 1738 "Proxy-Connection: keep-alive\r\n" |
1726 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), | 1739 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
1727 | 1740 |
1728 MockWrite("GET / HTTP/1.1\r\n" | 1741 MockWrite("GET / HTTP/1.1\r\n" |
1729 "Host: www.google.com\r\n" | 1742 "Host: www.google.com\r\n" |
1730 "Connection: keep-alive\r\n\r\n"), | 1743 "Connection: keep-alive\r\n\r\n"), |
1731 }; | 1744 }; |
1732 | 1745 |
1733 // The proxy responds to the connect with a 407, using a persistent | 1746 // The proxy responds to the connect with a 407, using a persistent |
1734 // connection. | 1747 // connection. |
1735 MockRead data_reads1[] = { | 1748 MockRead data_reads1[] = { |
1736 // No credentials. | 1749 // No credentials. |
1737 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), | 1750 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
1738 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), | 1751 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
1739 MockRead("Proxy-Connection: close\r\n\r\n"), | 1752 MockRead("Proxy-Connection: close\r\n\r\n"), |
| 1753 }; |
1740 | 1754 |
| 1755 MockRead data_reads2[] = { |
1741 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), | 1756 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
1742 | 1757 |
1743 MockRead("HTTP/1.1 200 OK\r\n"), | 1758 MockRead("HTTP/1.1 200 OK\r\n"), |
1744 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"), | 1759 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"), |
1745 MockRead("Content-Length: 5\r\n\r\n"), | 1760 MockRead("Content-Length: 5\r\n\r\n"), |
1746 MockRead(false, "hello"), | 1761 MockRead(false, "hello"), |
1747 }; | 1762 }; |
1748 | 1763 |
1749 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), | 1764 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
1750 data_writes1, arraysize(data_writes1)); | 1765 data_writes1, arraysize(data_writes1)); |
| 1766 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 1767 data_writes2, arraysize(data_writes2)); |
1751 session_deps.socket_factory.AddSocketDataProvider(&data1); | 1768 session_deps.socket_factory.AddSocketDataProvider(&data1); |
| 1769 session_deps.socket_factory.AddSocketDataProvider(&data2); |
1752 SSLSocketDataProvider ssl(true, OK); | 1770 SSLSocketDataProvider ssl(true, OK); |
1753 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); | 1771 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); |
1754 | 1772 |
1755 TestCompletionCallback callback1; | 1773 TestCompletionCallback callback1; |
1756 | 1774 |
1757 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); | 1775 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); |
1758 | 1776 |
1759 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 1777 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
1760 EXPECT_EQ(ERR_IO_PENDING, rv); | 1778 EXPECT_EQ(ERR_IO_PENDING, rv); |
1761 | 1779 |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1956 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); | 1974 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
1957 | 1975 |
1958 std::string response_data; | 1976 std::string response_data; |
1959 rv = ReadTransaction(trans.get(), &response_data); | 1977 rv = ReadTransaction(trans.get(), &response_data); |
1960 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); | 1978 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); |
1961 | 1979 |
1962 // Flush the idle socket before the HttpNetworkTransaction goes out of scope. | 1980 // Flush the idle socket before the HttpNetworkTransaction goes out of scope. |
1963 session->CloseAllConnections(); | 1981 session->CloseAllConnections(); |
1964 } | 1982 } |
1965 | 1983 |
| 1984 // Test the request-challenge-retry sequence for basic auth, over a connection |
| 1985 // that requires a restart when setting up an SSL tunnel. |
| 1986 TEST_F(HttpNetworkTransactionTest, BasicAuthHttpsProxyNoKeepAlive) { |
| 1987 HttpRequestInfo request; |
| 1988 request.method = "GET"; |
| 1989 request.url = GURL("https://www.google.com/"); |
| 1990 // when the no authentication data flag is set. |
| 1991 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA; |
| 1992 |
| 1993 // Configure against https proxy server "myproxy:70". |
| 1994 SessionDependencies session_deps( |
| 1995 ProxyService::CreateFixed("https://myproxy:70")); |
| 1996 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 1997 session_deps.net_log = log.bound().net_log(); |
| 1998 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
| 1999 |
| 2000 // Since we have proxy, should try to establish tunnel. |
| 2001 MockWrite data_writes1[] = { |
| 2002 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 2003 "Host: www.google.com\r\n" |
| 2004 "Proxy-Connection: keep-alive\r\n\r\n"), |
| 2005 }; |
| 2006 |
| 2007 MockWrite data_writes2[] = { |
| 2008 // After calling trans->RestartWithAuth(), this is the request we should |
| 2009 // be issuing -- the final header line contains the credentials. |
| 2010 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 2011 "Host: www.google.com\r\n" |
| 2012 "Proxy-Connection: keep-alive\r\n" |
| 2013 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"), |
| 2014 |
| 2015 MockWrite("GET / HTTP/1.1\r\n" |
| 2016 "Host: www.google.com\r\n" |
| 2017 "Connection: keep-alive\r\n\r\n"), |
| 2018 }; |
| 2019 |
| 2020 // The proxy responds to the connect with a 407, using a persistent |
| 2021 // connection. |
| 2022 MockRead data_reads1[] = { |
| 2023 // No credentials. |
| 2024 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
| 2025 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
| 2026 MockRead("Proxy-Connection: close\r\n\r\n"), |
| 2027 }; |
| 2028 |
| 2029 MockRead data_reads2[] = { |
| 2030 MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"), |
| 2031 |
| 2032 MockRead("HTTP/1.1 200 OK\r\n"), |
| 2033 MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"), |
| 2034 MockRead("Content-Length: 5\r\n\r\n"), |
| 2035 MockRead(false, "hello"), |
| 2036 }; |
| 2037 |
| 2038 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2039 data_writes1, arraysize(data_writes1)); |
| 2040 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 2041 data_writes2, arraysize(data_writes2)); |
| 2042 session_deps.socket_factory.AddSocketDataProvider(&data1); |
| 2043 session_deps.socket_factory.AddSocketDataProvider(&data2); |
| 2044 SSLSocketDataProvider proxy(true, OK); |
| 2045 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy); |
| 2046 SSLSocketDataProvider proxy2(true, OK); |
| 2047 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy2); |
| 2048 SSLSocketDataProvider server(true, OK); |
| 2049 session_deps.socket_factory.AddSSLSocketDataProvider(&server); |
| 2050 |
| 2051 TestCompletionCallback callback1; |
| 2052 |
| 2053 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); |
| 2054 |
| 2055 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
| 2056 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2057 |
| 2058 rv = callback1.WaitForResult(); |
| 2059 EXPECT_EQ(OK, rv); |
| 2060 net::CapturingNetLog::EntryList entries; |
| 2061 log.GetEntries(&entries); |
| 2062 size_t pos = ExpectLogContainsSomewhere( |
| 2063 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS, |
| 2064 NetLog::PHASE_NONE); |
| 2065 ExpectLogContainsSomewhere( |
| 2066 entries, pos, |
| 2067 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS, |
| 2068 NetLog::PHASE_NONE); |
| 2069 |
| 2070 const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 2071 ASSERT_TRUE(response != NULL); |
| 2072 ASSERT_FALSE(response->headers == NULL); |
| 2073 EXPECT_EQ(407, response->headers->response_code()); |
| 2074 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2075 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); |
| 2076 |
| 2077 TestCompletionCallback callback2; |
| 2078 |
| 2079 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), |
| 2080 callback2.callback()); |
| 2081 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2082 |
| 2083 rv = callback2.WaitForResult(); |
| 2084 EXPECT_EQ(OK, rv); |
| 2085 |
| 2086 response = trans->GetResponseInfo(); |
| 2087 ASSERT_TRUE(response != NULL); |
| 2088 |
| 2089 EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 2090 EXPECT_EQ(200, response->headers->response_code()); |
| 2091 EXPECT_EQ(5, response->headers->GetContentLength()); |
| 2092 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2093 |
| 2094 // The password prompt info should not be set. |
| 2095 EXPECT_TRUE(response->auth_challenge.get() == NULL); |
| 2096 |
| 2097 trans.reset(); |
| 2098 session->CloseAllConnections(); |
| 2099 } |
| 2100 |
| 2101 // Test the request-challenge-retry sequence for basic auth, over a keep-alive |
| 2102 // proxy connection, when setting up an SSL tunnel. |
| 2103 TEST_F(HttpNetworkTransactionTest, BasicAuthHttpsProxyKeepAlive) { |
| 2104 HttpRequestInfo request; |
| 2105 request.method = "GET"; |
| 2106 request.url = GURL("https://www.google.com/"); |
| 2107 // Ensure that proxy authentication is attempted even |
| 2108 // when the no authentication data flag is set. |
| 2109 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA; |
| 2110 |
| 2111 // Configure against https proxy server "myproxy:70". |
| 2112 SessionDependencies session_deps( |
| 2113 ProxyService::CreateFixed("https://myproxy:70")); |
| 2114 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 2115 session_deps.net_log = log.bound().net_log(); |
| 2116 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
| 2117 |
| 2118 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); |
| 2119 |
| 2120 // Since we have proxy, should try to establish tunnel. |
| 2121 MockWrite data_writes1[] = { |
| 2122 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 2123 "Host: www.google.com\r\n" |
| 2124 "Proxy-Connection: keep-alive\r\n\r\n"), |
| 2125 |
| 2126 // After calling trans->RestartWithAuth(), this is the request we should |
| 2127 // be issuing -- the final header line contains the credentials. |
| 2128 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 2129 "Host: www.google.com\r\n" |
| 2130 "Proxy-Connection: keep-alive\r\n" |
| 2131 "Proxy-Authorization: Basic Zm9vOmJheg==\r\n\r\n"), |
| 2132 }; |
| 2133 |
| 2134 // The proxy responds to the connect with a 407, using a persistent |
| 2135 // connection. |
| 2136 MockRead data_reads1[] = { |
| 2137 // No credentials. |
| 2138 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
| 2139 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
| 2140 MockRead("Content-Length: 10\r\n\r\n"), |
| 2141 MockRead("0123456789"), |
| 2142 |
| 2143 // Wrong credentials (wrong password). |
| 2144 MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"), |
| 2145 MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"), |
| 2146 MockRead("Content-Length: 10\r\n\r\n"), |
| 2147 // No response body because the test stops reading here. |
| 2148 MockRead(false, ERR_UNEXPECTED), // Should not be reached. |
| 2149 }; |
| 2150 |
| 2151 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 2152 data_writes1, arraysize(data_writes1)); |
| 2153 session_deps.socket_factory.AddSocketDataProvider(&data1); |
| 2154 SSLSocketDataProvider ssl(true, OK); |
| 2155 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); |
| 2156 |
| 2157 TestCompletionCallback callback1; |
| 2158 |
| 2159 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
| 2160 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2161 |
| 2162 rv = callback1.WaitForResult(); |
| 2163 EXPECT_EQ(OK, rv); |
| 2164 net::CapturingNetLog::EntryList entries; |
| 2165 log.GetEntries(&entries); |
| 2166 size_t pos = ExpectLogContainsSomewhere( |
| 2167 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS, |
| 2168 NetLog::PHASE_NONE); |
| 2169 ExpectLogContainsSomewhere( |
| 2170 entries, pos, |
| 2171 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS, |
| 2172 NetLog::PHASE_NONE); |
| 2173 |
| 2174 const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 2175 ASSERT_TRUE(response != NULL); |
| 2176 ASSERT_FALSE(response->headers == NULL); |
| 2177 EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 2178 EXPECT_EQ(407, response->headers->response_code()); |
| 2179 EXPECT_EQ(10, response->headers->GetContentLength()); |
| 2180 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2181 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); |
| 2182 |
| 2183 TestCompletionCallback callback2; |
| 2184 |
| 2185 // Wrong password (should be "bar"). |
| 2186 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBaz), |
| 2187 callback2.callback()); |
| 2188 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2189 |
| 2190 rv = callback2.WaitForResult(); |
| 2191 EXPECT_EQ(OK, rv); |
| 2192 |
| 2193 response = trans->GetResponseInfo(); |
| 2194 ASSERT_TRUE(response != NULL); |
| 2195 ASSERT_FALSE(response->headers == NULL); |
| 2196 EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 2197 EXPECT_EQ(407, response->headers->response_code()); |
| 2198 EXPECT_EQ(10, response->headers->GetContentLength()); |
| 2199 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2200 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); |
| 2201 |
| 2202 // Flush the idle socket before the NetLog and HttpNetworkTransaction go |
| 2203 // out of scope. |
| 2204 session->CloseAllConnections(); |
| 2205 } |
| 2206 |
| 2207 // Test the request-challenge-retry sequence for basic auth, through |
| 2208 // a SPDY proxy over a single SPDY session. |
| 2209 TEST_F(HttpNetworkTransactionTest, BasicAuthSpdyProxy) { |
| 2210 HttpRequestInfo request; |
| 2211 request.method = "GET"; |
| 2212 request.url = GURL("https://www.google.com/"); |
| 2213 // when the no authentication data flag is set. |
| 2214 request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA; |
| 2215 |
| 2216 // Configure against https proxy server "myproxy:70". |
| 2217 SessionDependencies session_deps( |
| 2218 ProxyService::CreateFixed("https://myproxy:70")); |
| 2219 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 2220 session_deps.net_log = log.bound().net_log(); |
| 2221 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
| 2222 |
| 2223 // Since we have proxy, should try to establish tunnel. |
| 2224 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyConnect(NULL, 0, 1)); |
| 2225 scoped_ptr<spdy::SpdyFrame> rst(ConstructSpdyRstStream(1, spdy::CANCEL)); |
| 2226 |
| 2227 // After calling trans->RestartWithAuth(), this is the request we should |
| 2228 // be issuing -- the final header line contains the credentials. |
| 2229 const char* const kAuthCredentials[] = { |
| 2230 "proxy-authorization", "Basic Zm9vOmJhcg==", |
| 2231 }; |
| 2232 scoped_ptr<spdy::SpdyFrame> connect2( |
| 2233 ConstructSpdyConnect(kAuthCredentials, arraysize(kAuthCredentials)/2, 3)); |
| 2234 // fetch https://www.google.com/ via HTTP |
| 2235 const char get[] = "GET / HTTP/1.1\r\n" |
| 2236 "Host: www.google.com\r\n" |
| 2237 "Connection: keep-alive\r\n\r\n"; |
| 2238 scoped_ptr<spdy::SpdyFrame> wrapped_get( |
| 2239 ConstructSpdyBodyFrame(3, get, strlen(get), false)); |
| 2240 |
| 2241 MockWrite spdy_writes[] = { |
| 2242 CreateMockWrite(*req, 0, true), |
| 2243 CreateMockWrite(*rst, 2, true), |
| 2244 CreateMockWrite(*connect2, 3), |
| 2245 CreateMockWrite(*wrapped_get, 5) |
| 2246 }; |
| 2247 |
| 2248 // The proxy responds to the connect with a 407, using a persistent |
| 2249 // connection. |
| 2250 const char* const kAuthChallenge[] = { |
| 2251 "status", "407 Proxy Authentication Required", |
| 2252 "version", "HTTP/1.1", |
| 2253 "proxy-authenticate", "Basic realm=\"MyRealm1\"", |
| 2254 }; |
| 2255 |
| 2256 scoped_ptr<spdy::SpdyFrame> conn_auth_resp( |
| 2257 ConstructSpdyControlFrame(NULL, |
| 2258 0, |
| 2259 false, |
| 2260 1, |
| 2261 LOWEST, |
| 2262 spdy::SYN_REPLY, |
| 2263 spdy::CONTROL_FLAG_NONE, |
| 2264 kAuthChallenge, |
| 2265 arraysize(kAuthChallenge))); |
| 2266 |
| 2267 scoped_ptr<spdy::SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 3)); |
| 2268 const char resp[] = "HTTP/1.1 200 OK\r\n" |
| 2269 "Content-Length: 5\r\n\r\n"; |
| 2270 |
| 2271 scoped_ptr<spdy::SpdyFrame> wrapped_get_resp( |
| 2272 ConstructSpdyBodyFrame(3, resp, strlen(resp), false)); |
| 2273 scoped_ptr<spdy::SpdyFrame> wrapped_body( |
| 2274 ConstructSpdyBodyFrame(3, "hello", 5, false)); |
| 2275 MockRead spdy_reads[] = { |
| 2276 CreateMockRead(*conn_auth_resp, 1, true), |
| 2277 CreateMockRead(*conn_resp, 4, true), |
| 2278 CreateMockRead(*wrapped_get_resp, 5, true), |
| 2279 CreateMockRead(*wrapped_body, 6, true), |
| 2280 MockRead(false, ERR_IO_PENDING), |
| 2281 }; |
| 2282 |
| 2283 scoped_refptr<OrderedSocketData> spdy_data( |
| 2284 new OrderedSocketData( |
| 2285 spdy_reads, arraysize(spdy_reads), |
| 2286 spdy_writes, arraysize(spdy_writes))); |
| 2287 session_deps.socket_factory.AddSocketDataProvider(spdy_data); |
| 2288 // Negotiate SPDY to the proxy |
| 2289 SSLSocketDataProvider proxy(true, OK); |
| 2290 proxy.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
| 2291 proxy.next_proto = "spdy/2"; |
| 2292 proxy.was_npn_negotiated = true; |
| 2293 session_deps.socket_factory.AddSSLSocketDataProvider(&proxy); |
| 2294 // Vanilla SSL to the server |
| 2295 SSLSocketDataProvider server(true, OK); |
| 2296 session_deps.socket_factory.AddSSLSocketDataProvider(&server); |
| 2297 |
| 2298 TestCompletionCallback callback1; |
| 2299 |
| 2300 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); |
| 2301 |
| 2302 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
| 2303 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2304 |
| 2305 rv = callback1.WaitForResult(); |
| 2306 EXPECT_EQ(OK, rv); |
| 2307 net::CapturingNetLog::EntryList entries; |
| 2308 log.GetEntries(&entries); |
| 2309 size_t pos = ExpectLogContainsSomewhere( |
| 2310 entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS, |
| 2311 NetLog::PHASE_NONE); |
| 2312 ExpectLogContainsSomewhere( |
| 2313 entries, pos, |
| 2314 NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS, |
| 2315 NetLog::PHASE_NONE); |
| 2316 |
| 2317 const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 2318 ASSERT_TRUE(response != NULL); |
| 2319 ASSERT_FALSE(response->headers == NULL); |
| 2320 EXPECT_EQ(407, response->headers->response_code()); |
| 2321 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2322 EXPECT_TRUE(response->auth_challenge.get() != NULL); |
| 2323 EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get())); |
| 2324 |
| 2325 TestCompletionCallback callback2; |
| 2326 |
| 2327 rv = trans->RestartWithAuth(AuthCredentials(kFoo, kBar), |
| 2328 callback2.callback()); |
| 2329 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 2330 |
| 2331 rv = callback2.WaitForResult(); |
| 2332 EXPECT_EQ(OK, rv); |
| 2333 |
| 2334 response = trans->GetResponseInfo(); |
| 2335 ASSERT_TRUE(response != NULL); |
| 2336 |
| 2337 EXPECT_TRUE(response->headers->IsKeepAlive()); |
| 2338 EXPECT_EQ(200, response->headers->response_code()); |
| 2339 EXPECT_EQ(5, response->headers->GetContentLength()); |
| 2340 EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion()); |
| 2341 |
| 2342 // The password prompt info should not be set. |
| 2343 EXPECT_TRUE(response->auth_challenge.get() == NULL); |
| 2344 |
| 2345 trans.reset(); |
| 2346 session->CloseAllConnections(); |
| 2347 } |
| 2348 |
| 2349 |
1966 // Test when a server (non-proxy) returns a 407 (proxy-authenticate). | 2350 // Test when a server (non-proxy) returns a 407 (proxy-authenticate). |
1967 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH. | 2351 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH. |
1968 TEST_F(HttpNetworkTransactionTest, UnexpectedProxyAuth) { | 2352 TEST_F(HttpNetworkTransactionTest, UnexpectedProxyAuth) { |
1969 HttpRequestInfo request; | 2353 HttpRequestInfo request; |
1970 request.method = "GET"; | 2354 request.method = "GET"; |
1971 request.url = GURL("http://www.google.com/"); | 2355 request.url = GURL("http://www.google.com/"); |
1972 request.load_flags = 0; | 2356 request.load_flags = 0; |
1973 | 2357 |
1974 // We are using a DIRECT connection (i.e. no proxy) for this session. | 2358 // We are using a DIRECT connection (i.e. no proxy) for this session. |
1975 SessionDependencies session_deps; | 2359 SessionDependencies session_deps; |
(...skipping 1082 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3058 | 3442 |
3059 rv = callback3.WaitForResult(); | 3443 rv = callback3.WaitForResult(); |
3060 EXPECT_EQ(OK, rv); | 3444 EXPECT_EQ(OK, rv); |
3061 | 3445 |
3062 response = trans->GetResponseInfo(); | 3446 response = trans->GetResponseInfo(); |
3063 ASSERT_TRUE(response != NULL); | 3447 ASSERT_TRUE(response != NULL); |
3064 EXPECT_TRUE(response->auth_challenge.get() == NULL); | 3448 EXPECT_TRUE(response->auth_challenge.get() == NULL); |
3065 EXPECT_EQ(13, response->headers->GetContentLength()); | 3449 EXPECT_EQ(13, response->headers->GetContentLength()); |
3066 } | 3450 } |
3067 | 3451 |
| 3452 |
| 3453 // Enter the correct password and authenticate successfully. |
| 3454 TEST_F(HttpNetworkTransactionTest, NTLMAuthFull) { |
| 3455 HttpRequestInfo request; |
| 3456 request.method = "GET"; |
| 3457 request.url = GURL("https://www.google.com/"); |
| 3458 request.load_flags = 0; |
| 3459 |
| 3460 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom1, |
| 3461 MockGetHostName); |
| 3462 SessionDependencies session_deps(ProxyService::CreateFixed( |
| 3463 "https://proxy:70")); |
| 3464 |
| 3465 MockWrite data_writes1[] = { |
| 3466 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 3467 "Host: www.google.com\r\n" |
| 3468 "Proxy-Connection: keep-alive\r\n\r\n"), |
| 3469 }; |
| 3470 |
| 3471 MockRead data_reads1[] = { |
| 3472 MockRead("HTTP/1.1 407 Access Denied\r\n"), |
| 3473 // Negotiate and NTLM are often requested together. However, we only want |
| 3474 // to test NTLM. Since Negotiate is preferred over NTLM, we have to skip |
| 3475 // the header that requests Negotiate for this test. |
| 3476 MockRead("Proxy-Authenticate: NTLM\r\n"), |
| 3477 MockRead("Connection: close\r\n"), |
| 3478 MockRead("Content-Length: 42\r\n"), |
| 3479 MockRead("Content-Type: text/html\r\n\r\n"), |
| 3480 // Missing content -- won't matter, as connection will be reset. |
| 3481 MockRead(false, ERR_UNEXPECTED), |
| 3482 }; |
| 3483 |
| 3484 MockWrite data_writes2[] = { |
| 3485 // After restarting with a null identity, this is the |
| 3486 // request we should be issuing -- the final header line contains a Type |
| 3487 // 1 message. |
| 3488 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 3489 "Host: www.google.com\r\n" |
| 3490 "Proxy-Connection: keep-alive\r\n" |
| 3491 "Proxy-Authorization: NTLM " |
| 3492 "TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=\r\n\r\n"), |
| 3493 |
| 3494 // After calling trans->RestartWithAuth(), we should send a Type 3 message |
| 3495 // (the credentials for the origin server). The second request continues |
| 3496 // on the same connection. |
| 3497 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
| 3498 "Host: www.google.com\r\n" |
| 3499 "Proxy-Connection: keep-alive\r\n" |
| 3500 "Proxy-Authorization: NTLM TlRMTVNTUAADAAAAGAAYAGgAAAAYABgAgA" |
| 3501 "AAAAAAAABAAAAAGAAYAEAAAAAQABAAWAAAAAAAAAAAAAAABYIIAHQA" |
| 3502 "ZQBzAHQAaQBuAGcALQBuAHQAbABtAFcAVABDAC0AVwBJAE4ANwBVKW" |
| 3503 "Yma5xzVAAAAAAAAAAAAAAAAAAAAACH+gWcm+YsP9Tqb9zCR3WAeZZX" |
| 3504 "ahlhx5I=\r\n\r\n"), |
| 3505 |
| 3506 MockWrite("GET / HTTP/1.1\r\n" |
| 3507 "Host: www.google.com\r\n" |
| 3508 "Connection: keep-alive\r\n\r\n"), |
| 3509 }; |
| 3510 |
| 3511 MockRead data_reads2[] = { |
| 3512 // The origin server responds with a Type 2 message. |
| 3513 MockRead("HTTP/1.1 407 Access Denied\r\n"), |
| 3514 MockRead("Proxy-Authenticate: NTLM " |
| 3515 "TlRMTVNTUAACAAAADAAMADgAAAAFgokCjGpMpPGlYKkAAAAAAAAAALo" |
| 3516 "AugBEAAAABQEoCgAAAA9HAE8ATwBHAEwARQACAAwARwBPAE8ARwBMAE" |
| 3517 "UAAQAaAEEASwBFAEUAUwBBAFIAQQAtAEMATwBSAFAABAAeAGMAbwByA" |
| 3518 "HAALgBnAG8AbwBnAGwAZQAuAGMAbwBtAAMAQABhAGsAZQBlAHMAYQBy" |
| 3519 "AGEALQBjAG8AcgBwAC4AYQBkAC4AYwBvAHIAcAAuAGcAbwBvAGcAbAB" |
| 3520 "lAC4AYwBvAG0ABQAeAGMAbwByAHAALgBnAG8AbwBnAGwAZQAuAGMAbw" |
| 3521 "BtAAAAAAA=\r\n"), |
| 3522 MockRead("Content-Length: 42\r\n"), |
| 3523 MockRead("Content-Type: text/html\r\n\r\n"), |
| 3524 MockRead("You are not authorized to view this page\r\n"), |
| 3525 |
| 3526 // Connect succeeds |
| 3527 MockRead("HTTP/1.0 200 Connected\r\n\r\n"), |
| 3528 |
| 3529 // Lastly we get the desired content. |
| 3530 MockRead("HTTP/1.1 200 OK\r\n"), |
| 3531 MockRead("Content-Type: text/html; charset=utf-8\r\n"), |
| 3532 MockRead("Content-Length: 13\r\n\r\n"), |
| 3533 MockRead("Please Login\r\n"), |
| 3534 MockRead(false, OK), |
| 3535 }; |
| 3536 |
| 3537 StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), |
| 3538 data_writes1, arraysize(data_writes1)); |
| 3539 StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), |
| 3540 data_writes2, arraysize(data_writes2)); |
| 3541 SSLSocketDataProvider ssl(true, OK); |
| 3542 SSLSocketDataProvider ssl2(true, OK); |
| 3543 SSLSocketDataProvider ssl3(true, OK); |
| 3544 SSLSocketDataProvider ssl_server(true, OK); |
| 3545 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); |
| 3546 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2); |
| 3547 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl3); |
| 3548 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl_server); |
| 3549 session_deps.socket_factory.AddSocketDataProvider(&data1); |
| 3550 session_deps.socket_factory.AddSocketDataProvider(&data2); |
| 3551 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
| 3552 |
| 3553 TestCompletionCallback callback1; |
| 3554 |
| 3555 scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(session)); |
| 3556 |
| 3557 int rv = trans->Start(&request, callback1.callback(), BoundNetLog()); |
| 3558 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 3559 |
| 3560 rv = callback1.WaitForResult(); |
| 3561 EXPECT_EQ(OK, rv); |
| 3562 |
| 3563 EXPECT_FALSE(trans->IsReadyToRestartForAuth()); |
| 3564 |
| 3565 const HttpResponseInfo* response = trans->GetResponseInfo(); |
| 3566 ASSERT_FALSE(response == NULL); |
| 3567 EXPECT_TRUE(CheckNTLMProxyAuth(response->auth_challenge.get())); |
| 3568 |
| 3569 TestCompletionCallback callback2; |
| 3570 |
| 3571 rv = trans->RestartWithAuth(AuthCredentials(kTestingNTLM, kTestingNTLM), |
| 3572 callback2.callback()); |
| 3573 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 3574 |
| 3575 rv = callback2.WaitForResult(); |
| 3576 EXPECT_EQ(OK, rv); |
| 3577 |
| 3578 EXPECT_TRUE(trans->IsReadyToRestartForAuth()); |
| 3579 |
| 3580 response = trans->GetResponseInfo(); |
| 3581 ASSERT_TRUE(response != NULL); |
| 3582 EXPECT_TRUE(response->auth_challenge.get() == NULL); |
| 3583 |
| 3584 TestCompletionCallback callback3; |
| 3585 |
| 3586 rv = trans->RestartWithAuth(AuthCredentials(), callback3.callback()); |
| 3587 EXPECT_EQ(ERR_IO_PENDING, rv); |
| 3588 |
| 3589 rv = callback3.WaitForResult(); |
| 3590 EXPECT_EQ(OK, rv); |
| 3591 |
| 3592 response = trans->GetResponseInfo(); |
| 3593 ASSERT_TRUE(response != NULL); |
| 3594 EXPECT_TRUE(response->auth_challenge.get() == NULL); |
| 3595 EXPECT_EQ(13, response->headers->GetContentLength()); |
| 3596 } |
| 3597 |
3068 // Enter a wrong password, and then the correct one. | 3598 // Enter a wrong password, and then the correct one. |
3069 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { | 3599 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) { |
3070 HttpRequestInfo request; | 3600 HttpRequestInfo request; |
3071 request.method = "GET"; | 3601 request.method = "GET"; |
3072 request.url = GURL("http://172.22.68.17/kids/login.aspx"); | 3602 request.url = GURL("http://172.22.68.17/kids/login.aspx"); |
3073 request.load_flags = 0; | 3603 request.load_flags = 0; |
3074 | 3604 |
3075 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2, | 3605 HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2, |
3076 MockGetHostName); | 3606 MockGetHostName); |
3077 SessionDependencies session_deps; | 3607 SessionDependencies session_deps; |
(...skipping 4313 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7391 } | 7921 } |
7392 | 7922 |
7393 // GenerateAuthToken is a mighty big test. | 7923 // GenerateAuthToken is a mighty big test. |
7394 // It tests all permutation of GenerateAuthToken behavior: | 7924 // It tests all permutation of GenerateAuthToken behavior: |
7395 // - Synchronous and Asynchronous completion. | 7925 // - Synchronous and Asynchronous completion. |
7396 // - OK or error on completion. | 7926 // - OK or error on completion. |
7397 // - Direct connection, non-authenticating proxy, and authenticating proxy. | 7927 // - Direct connection, non-authenticating proxy, and authenticating proxy. |
7398 // - HTTP or HTTPS backend (to include proxy tunneling). | 7928 // - HTTP or HTTPS backend (to include proxy tunneling). |
7399 // - Non-authenticating and authenticating backend. | 7929 // - Non-authenticating and authenticating backend. |
7400 // | 7930 // |
7401 // In all, there are 44 reasonable permuations (for example, if there are | 7931 // In all, there are 44 reasonable permutations (for example, if there are |
7402 // problems generating an auth token for an authenticating proxy, we don't | 7932 // problems generating an auth token for an authenticating proxy, we don't |
7403 // need to test all permutations of the backend server). | 7933 // need to test all permutations of the backend server). |
7404 // | 7934 // |
7405 // The test proceeds by going over each of the configuration cases, and | 7935 // The test proceeds by going over each of the configuration cases, and |
7406 // potentially running up to three rounds in each of the tests. The TestConfig | 7936 // potentially running up to three rounds in each of the tests. The TestConfig |
7407 // specifies both the configuration for the test as well as the expectations | 7937 // specifies both the configuration for the test as well as the expectations |
7408 // for the results. | 7938 // for the results. |
7409 TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) { | 7939 TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) { |
7410 static const char kServer[] = "http://www.example.com"; | 7940 static const char kServer[] = "http://www.example.com"; |
7411 static const char kSecureServer[] = "https://www.example.com"; | 7941 static const char kSecureServer[] = "https://www.example.com"; |
(...skipping 837 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8249 }; | 8779 }; |
8250 StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1), | 8780 StaticSocketDataProvider data_1(data_reads_1, arraysize(data_reads_1), |
8251 data_writes_1, arraysize(data_writes_1)); | 8781 data_writes_1, arraysize(data_writes_1)); |
8252 | 8782 |
8253 // Second round tries to tunnel to www.google.com due to the | 8783 // Second round tries to tunnel to www.google.com due to the |
8254 // Alternate-Protocol announcement in the first round. It fails due | 8784 // Alternate-Protocol announcement in the first round. It fails due |
8255 // to a proxy authentication challenge. | 8785 // to a proxy authentication challenge. |
8256 // After the failure, a tunnel is established to www.google.com using | 8786 // After the failure, a tunnel is established to www.google.com using |
8257 // Proxy-Authorization headers. There is then a SPDY request round. | 8787 // Proxy-Authorization headers. There is then a SPDY request round. |
8258 // | 8788 // |
8259 // NOTE: Despite the "Proxy-Connection: Close", these are done on the | |
8260 // same MockTCPClientSocket since the underlying HttpNetworkClientSocket | |
8261 // does a Disconnect and Connect on the same socket, rather than trying | |
8262 // to obtain a new one. | |
8263 // | |
8264 // NOTE: Originally, the proxy response to the second CONNECT request | 8789 // NOTE: Originally, the proxy response to the second CONNECT request |
8265 // simply returned another 407 so the unit test could skip the SSL connection | 8790 // simply returned another 407 so the unit test could skip the SSL connection |
8266 // establishment and SPDY framing issues. Alas, the | 8791 // establishment and SPDY framing issues. Alas, the |
8267 // retry-http-when-alternate-protocol fails logic kicks in, which was more | 8792 // retry-http-when-alternate-protocol fails logic kicks in, which was more |
8268 // complicated to set up expectations for than the SPDY session. | 8793 // complicated to set up expectations for than the SPDY session. |
8269 | 8794 |
8270 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST)); | 8795 scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST)); |
8271 scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1)); | 8796 scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1)); |
8272 scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true)); | 8797 scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true)); |
8273 | 8798 |
8274 MockWrite data_writes_2[] = { | 8799 MockWrite data_writes_2[] = { |
8275 // First connection attempt without Proxy-Authorization. | 8800 // First connection attempt without Proxy-Authorization. |
8276 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" | 8801 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
8277 "Host: www.google.com\r\n" | 8802 "Host: www.google.com\r\n" |
8278 "Proxy-Connection: keep-alive\r\n" | 8803 "Proxy-Connection: keep-alive\r\n" |
8279 "\r\n"), | 8804 "\r\n"), |
| 8805 }; |
8280 | 8806 |
| 8807 MockWrite data_writes_3[] = { |
| 8808 // Non-alternate protocol job that will run in parallel |
| 8809 MockWrite("GET https://www.google.com/ HTTP/1.1\r\n" |
| 8810 "Host: www.google.com\r\n" |
| 8811 "Proxy-Connection: keep-alive\r\n" |
| 8812 "\r\n"), |
| 8813 }; |
| 8814 |
| 8815 MockWrite data_writes_4[] = { |
8281 // Second connection attempt with Proxy-Authorization. | 8816 // Second connection attempt with Proxy-Authorization. |
8282 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" | 8817 MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n" |
8283 "Host: www.google.com\r\n" | 8818 "Host: www.google.com\r\n" |
8284 "Proxy-Connection: keep-alive\r\n" | 8819 "Proxy-Connection: keep-alive\r\n" |
8285 "Proxy-Authorization: auth_token\r\n" | 8820 "Proxy-Authorization: auth_token\r\n" |
8286 "\r\n"), | 8821 "\r\n"), |
8287 | 8822 |
8288 // SPDY request | 8823 // SPDY request |
8289 CreateMockWrite(*req), | 8824 CreateMockWrite(*req), |
8290 }; | 8825 }; |
8291 const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n" | 8826 const char kRejectConnectResponse[] = ("HTTP/1.1 407 Unauthorized\r\n" |
8292 "Proxy-Authenticate: Mock\r\n" | 8827 "Proxy-Authenticate: Mock\r\n" |
8293 "Proxy-Connection: close\r\n" | 8828 "Proxy-Connection: close\r\n" |
| 8829 "Content-Length: 0\r\n" |
8294 "\r\n"); | 8830 "\r\n"); |
8295 const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n"; | 8831 const char kAcceptConnectResponse[] = "HTTP/1.1 200 Connected\r\n\r\n"; |
8296 MockRead data_reads_2[] = { | 8832 MockRead data_reads_2[] = { |
8297 // First connection attempt fails | 8833 // First connection attempt fails |
8298 MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1), | 8834 MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ, 1), |
8299 MockRead(true, kRejectConnectResponse, | 8835 MockRead(true, kRejectConnectResponse, |
8300 arraysize(kRejectConnectResponse) - 1, 1), | 8836 arraysize(kRejectConnectResponse) - 1, 1), |
| 8837 }; |
8301 | 8838 |
| 8839 // Hang forever so we can ensure the alt job wins |
| 8840 MockRead data_reads_3[] = { |
| 8841 MockRead(false, ERR_IO_PENDING), |
| 8842 }; |
| 8843 |
| 8844 MockRead data_reads_4[] = { |
8302 // Second connection attempt passes | 8845 // Second connection attempt passes |
8303 MockRead(true, kAcceptConnectResponse, | 8846 MockRead(true, kAcceptConnectResponse, |
8304 arraysize(kAcceptConnectResponse) -1, 4), | 8847 arraysize(kAcceptConnectResponse) -1, 1), |
8305 | 8848 |
8306 // SPDY response | 8849 // SPDY response |
8307 CreateMockRead(*resp.get(), 6), | 8850 CreateMockRead(*resp.get(), 3), |
8308 CreateMockRead(*data.get(), 6), | 8851 CreateMockRead(*data.get(), 3), |
8309 MockRead(true, 0, 0, 6), | 8852 MockRead(true, 0, 0, 4), |
8310 }; | 8853 }; |
8311 scoped_refptr<OrderedSocketData> data_2( | 8854 scoped_refptr<OrderedSocketData> data_2( |
8312 new OrderedSocketData(data_reads_2, arraysize(data_reads_2), | 8855 new OrderedSocketData(data_reads_2, arraysize(data_reads_2), |
8313 data_writes_2, arraysize(data_writes_2))); | 8856 data_writes_2, arraysize(data_writes_2))); |
| 8857 scoped_refptr<OrderedSocketData> data_3( |
| 8858 new OrderedSocketData(data_reads_3, arraysize(data_reads_3), |
| 8859 data_writes_3, arraysize(data_writes_3))); |
| 8860 // Hang forever so we can ensure the alt job wins |
| 8861 MockConnect conn_3(false, ERR_IO_PENDING); |
| 8862 data_3->set_connect_data(conn_3); |
| 8863 scoped_refptr<OrderedSocketData> data_4( |
| 8864 new OrderedSocketData(data_reads_4, arraysize(data_reads_4), |
| 8865 data_writes_4, arraysize(data_writes_4))); |
8314 | 8866 |
8315 SSLSocketDataProvider ssl(true, OK); | 8867 SSLSocketDataProvider ssl(true, OK); |
8316 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; | 8868 ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated; |
8317 ssl.next_proto = "spdy/2"; | 8869 ssl.next_proto = "spdy/2"; |
8318 ssl.was_npn_negotiated = true; | 8870 ssl.was_npn_negotiated = true; |
8319 ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2; | 8871 ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2; |
8320 | 8872 |
8321 MockConnect never_finishing_connect(false, ERR_IO_PENDING); | 8873 MockConnect never_finishing_connect(false, ERR_IO_PENDING); |
8322 StaticSocketDataProvider hanging_non_alternate_protocol_socket( | 8874 StaticSocketDataProvider hanging_non_alternate_protocol_socket( |
8323 NULL, 0, NULL, 0); | 8875 NULL, 0, NULL, 0); |
8324 hanging_non_alternate_protocol_socket.set_connect_data( | 8876 hanging_non_alternate_protocol_socket.set_connect_data( |
8325 never_finishing_connect); | 8877 never_finishing_connect); |
8326 | 8878 |
8327 session_deps.socket_factory.AddSocketDataProvider(&data_1); | 8879 session_deps.socket_factory.AddSocketDataProvider(&data_1); |
8328 session_deps.socket_factory.AddSocketDataProvider(data_2.get()); | 8880 session_deps.socket_factory.AddSocketDataProvider(data_2.get()); |
| 8881 session_deps.socket_factory.AddSocketDataProvider(data_3.get()); |
| 8882 session_deps.socket_factory.AddSocketDataProvider(data_4.get()); |
| 8883 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); |
8329 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); | 8884 session_deps.socket_factory.AddSSLSocketDataProvider(&ssl); |
8330 session_deps.socket_factory.AddSocketDataProvider( | 8885 session_deps.socket_factory.AddSocketDataProvider( |
8331 &hanging_non_alternate_protocol_socket); | 8886 &hanging_non_alternate_protocol_socket); |
8332 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); | 8887 scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps)); |
8333 | 8888 |
8334 // First round should work and provide the Alternate-Protocol state. | 8889 // First round should work and provide the Alternate-Protocol state. |
8335 TestCompletionCallback callback_1; | 8890 TestCompletionCallback callback_1; |
8336 scoped_ptr<HttpTransaction> trans_1(new HttpNetworkTransaction(session)); | 8891 scoped_ptr<HttpTransaction> trans_1(new HttpNetworkTransaction(session)); |
8337 int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog()); | 8892 int rv = trans_1->Start(&request, callback_1.callback(), BoundNetLog()); |
8338 EXPECT_EQ(ERR_IO_PENDING, rv); | 8893 EXPECT_EQ(ERR_IO_PENDING, rv); |
(...skipping 1160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9499 session->spdy_session_pool()->HasSession(host_port_proxy_pair_b)); | 10054 session->spdy_session_pool()->HasSession(host_port_proxy_pair_b)); |
9500 | 10055 |
9501 HttpStreamFactory::set_next_protos(std::vector<std::string>()); | 10056 HttpStreamFactory::set_next_protos(std::vector<std::string>()); |
9502 ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool); | 10057 ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool); |
9503 ClientSocketPoolManager::set_max_sockets_per_proxy_server( | 10058 ClientSocketPoolManager::set_max_sockets_per_proxy_server( |
9504 old_max_sockets_per_proxy_server); | 10059 old_max_sockets_per_proxy_server); |
9505 ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group); | 10060 ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group); |
9506 } | 10061 } |
9507 | 10062 |
9508 } // namespace net | 10063 } // namespace net |
OLD | NEW |