Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 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 | |
Ryan Hamilton | a3ee93a7 | 2018-08-01 22:03:08 | [diff] [blame] | 5 | #include "net/quic/quic_proxy_client_socket.h" |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 6 | |
Bence Béky | 9983223 | 2018-02-11 04:21:00 | [diff] [blame] | 7 | #include <cstdio> |
| 8 | #include <utility> |
| 9 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 10 | #include "base/bind.h" |
| 11 | #include "base/bind_helpers.h" |
| 12 | #include "base/callback_helpers.h" |
| 13 | #include "base/values.h" |
| 14 | #include "net/http/http_auth_controller.h" |
Eric Roman | 06bd974 | 2019-07-13 15:19:13 | [diff] [blame] | 15 | #include "net/http/http_log_util.h" |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 16 | #include "net/http/http_response_headers.h" |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 17 | #include "net/log/net_log_source.h" |
| 18 | #include "net/log/net_log_source_type.h" |
Lily Chen | 8116b617 | 2018-12-04 23:30:42 | [diff] [blame] | 19 | #include "net/quic/quic_http_utils.h" |
Bence Béky | 94658bf | 2018-05-11 19:22:58 | [diff] [blame] | 20 | #include "net/spdy/spdy_http_utils.h" |
[email protected] | a2b2cfc | 2017-12-06 09:06:08 | [diff] [blame] | 21 | #include "net/traffic_annotation/network_traffic_annotation.h" |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 22 | |
| 23 | namespace net { |
| 24 | |
| 25 | QuicProxyClientSocket::QuicProxyClientSocket( |
| 26 | std::unique_ptr<QuicChromiumClientStream::Handle> stream, |
| 27 | std::unique_ptr<QuicChromiumClientSession::Handle> session, |
| 28 | const std::string& user_agent, |
| 29 | const HostPortPair& endpoint, |
| 30 | const NetLogWithSource& net_log, |
| 31 | HttpAuthController* auth_controller) |
| 32 | : next_state_(STATE_DISCONNECTED), |
| 33 | stream_(std::move(stream)), |
| 34 | session_(std::move(session)), |
| 35 | read_buf_(nullptr), |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 36 | write_buf_len_(0), |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 37 | endpoint_(endpoint), |
| 38 | auth_(auth_controller), |
| 39 | user_agent_(user_agent), |
Jeremy Roman | d54000b2 | 2019-07-08 18:40:16 | [diff] [blame] | 40 | net_log_(net_log) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 41 | DCHECK(stream_->IsOpen()); |
| 42 | |
| 43 | request_.method = "CONNECT"; |
| 44 | request_.url = GURL("https://" + endpoint.ToString()); |
| 45 | |
Eric Roman | 06bd974 | 2019-07-13 15:19:13 | [diff] [blame] | 46 | net_log_.BeginEventReferencingSource(NetLogEventType::SOCKET_ALIVE, |
| 47 | net_log_.source()); |
| 48 | net_log_.AddEventReferencingSource( |
| 49 | NetLogEventType::HTTP2_PROXY_CLIENT_SESSION, stream_->net_log().source()); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 50 | } |
| 51 | |
| 52 | QuicProxyClientSocket::~QuicProxyClientSocket() { |
| 53 | Disconnect(); |
| 54 | net_log_.EndEvent(NetLogEventType::SOCKET_ALIVE); |
| 55 | } |
| 56 | |
| 57 | const HttpResponseInfo* QuicProxyClientSocket::GetConnectResponseInfo() const { |
| 58 | return response_.headers.get() ? &response_ : nullptr; |
| 59 | } |
| 60 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 61 | const scoped_refptr<HttpAuthController>& |
| 62 | QuicProxyClientSocket::GetAuthController() const { |
| 63 | return auth_; |
| 64 | } |
| 65 | |
Bence Béky | 9983223 | 2018-02-11 04:21:00 | [diff] [blame] | 66 | int QuicProxyClientSocket::RestartWithAuth(CompletionOnceCallback callback) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 67 | // A QUIC Stream can only handle a single request, so the underlying |
| 68 | // stream may not be reused and a new QuicProxyClientSocket must be |
| 69 | // created (possibly on top of the same QUIC Session). |
| 70 | next_state_ = STATE_DISCONNECTED; |
Matt Menke | ae2cbb8 | 2019-02-21 20:20:13 | [diff] [blame] | 71 | return ERR_UNABLE_TO_REUSE_CONNECTION_FOR_PROXY_AUTH; |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 72 | } |
| 73 | |
| 74 | bool QuicProxyClientSocket::IsUsingSpdy() const { |
| 75 | return false; |
| 76 | } |
| 77 | |
| 78 | NextProto QuicProxyClientSocket::GetProxyNegotiatedProtocol() const { |
| 79 | return kProtoQUIC; |
| 80 | } |
| 81 | |
Matt Menke | edaf3b8 | 2019-03-14 21:39:44 | [diff] [blame] | 82 | // Ignore priority changes, just use priority of initial request. Since multiple |
| 83 | // requests are pooled on the QuicProxyClientSocket, reprioritization doesn't |
| 84 | // really work. |
| 85 | // |
| 86 | // TODO(mmenke): Use a single priority value for all QuicProxyClientSockets, |
| 87 | // regardless of what priority they're created with. |
| 88 | void QuicProxyClientSocket::SetStreamPriority(RequestPriority priority) {} |
Lily Chen | f11e129 | 2018-11-29 16:42:09 | [diff] [blame] | 89 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 90 | // Sends a HEADERS frame to the proxy with a CONNECT request |
| 91 | // for the specified endpoint. Waits for the server to send back |
| 92 | // a HEADERS frame. OK will be returned if the status is 200. |
| 93 | // ERR_TUNNEL_CONNECTION_FAILED will be returned for any other status. |
| 94 | // In any of these cases, Read() may be called to retrieve the HTTP |
| 95 | // response body. Any other return values should be considered fatal. |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 96 | int QuicProxyClientSocket::Connect(CompletionOnceCallback callback) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 97 | DCHECK(connect_callback_.is_null()); |
| 98 | if (!stream_->IsOpen()) |
| 99 | return ERR_CONNECTION_CLOSED; |
| 100 | |
| 101 | DCHECK_EQ(STATE_DISCONNECTED, next_state_); |
| 102 | next_state_ = STATE_GENERATE_AUTH_TOKEN; |
| 103 | |
| 104 | int rv = DoLoop(OK); |
| 105 | if (rv == ERR_IO_PENDING) |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 106 | connect_callback_ = std::move(callback); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 107 | return rv; |
| 108 | } |
| 109 | |
| 110 | void QuicProxyClientSocket::Disconnect() { |
| 111 | connect_callback_.Reset(); |
| 112 | read_callback_.Reset(); |
| 113 | read_buf_ = nullptr; |
| 114 | write_callback_.Reset(); |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 115 | write_buf_len_ = 0; |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 116 | |
| 117 | next_state_ = STATE_DISCONNECTED; |
| 118 | |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 119 | stream_->Reset(quic::QUIC_STREAM_CANCELLED); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 120 | } |
| 121 | |
| 122 | bool QuicProxyClientSocket::IsConnected() const { |
| 123 | return next_state_ == STATE_CONNECT_COMPLETE && stream_->IsOpen(); |
| 124 | } |
| 125 | |
| 126 | bool QuicProxyClientSocket::IsConnectedAndIdle() const { |
| 127 | return IsConnected() && !stream_->HasBytesToRead(); |
| 128 | } |
| 129 | |
| 130 | const NetLogWithSource& QuicProxyClientSocket::NetLog() const { |
| 131 | return net_log_; |
| 132 | } |
| 133 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 134 | bool QuicProxyClientSocket::WasEverUsed() const { |
| 135 | return session_->WasEverUsed(); |
| 136 | } |
| 137 | |
| 138 | bool QuicProxyClientSocket::WasAlpnNegotiated() const { |
| 139 | return false; |
| 140 | } |
| 141 | |
| 142 | NextProto QuicProxyClientSocket::GetNegotiatedProtocol() const { |
| 143 | return kProtoUnknown; |
| 144 | } |
| 145 | |
| 146 | bool QuicProxyClientSocket::GetSSLInfo(SSLInfo* ssl_info) { |
| 147 | return session_->GetSSLInfo(ssl_info); |
| 148 | } |
| 149 | |
| 150 | void QuicProxyClientSocket::GetConnectionAttempts( |
| 151 | ConnectionAttempts* out) const { |
| 152 | out->clear(); |
| 153 | } |
| 154 | |
| 155 | int64_t QuicProxyClientSocket::GetTotalReceivedBytes() const { |
| 156 | return stream_->NumBytesConsumed(); |
| 157 | } |
| 158 | |
Paul Jensen | 0f49dec | 2017-12-12 23:39:58 | [diff] [blame] | 159 | void QuicProxyClientSocket::ApplySocketTag(const SocketTag& tag) { |
Matt Menke | 5b7974fa | 2019-03-09 01:18:12 | [diff] [blame] | 160 | // In the case of a connection to the proxy using HTTP/2 or HTTP/3 where the |
| 161 | // underlying socket may multiplex multiple streams, applying this request's |
| 162 | // socket tag to the multiplexed session would incorrectly apply the socket |
| 163 | // tag to all mutliplexed streams. Fortunately socket tagging is only |
| 164 | // supported on Android without the data reduction proxy, so only simple HTTP |
| 165 | // proxies are supported, so proxies won't be using HTTP/2 or HTTP/3. Enforce |
| 166 | // that a specific (non-default) tag isn't being applied. |
| 167 | CHECK(tag == SocketTag()); |
Paul Jensen | 0f49dec | 2017-12-12 23:39:58 | [diff] [blame] | 168 | } |
| 169 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 170 | int QuicProxyClientSocket::Read(IOBuffer* buf, |
| 171 | int buf_len, |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 172 | CompletionOnceCallback callback) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 173 | DCHECK(connect_callback_.is_null()); |
| 174 | DCHECK(read_callback_.is_null()); |
| 175 | DCHECK(!read_buf_); |
| 176 | |
| 177 | if (next_state_ == STATE_DISCONNECTED) |
| 178 | return ERR_SOCKET_NOT_CONNECTED; |
| 179 | |
| 180 | if (!stream_->IsOpen()) { |
| 181 | return 0; |
| 182 | } |
| 183 | |
Yannic Bonenberger | 3c96beb | 2019-09-03 20:41:37 | [diff] [blame] | 184 | int rv = |
| 185 | stream_->ReadBody(buf, buf_len, |
| 186 | base::BindOnce(&QuicProxyClientSocket::OnReadComplete, |
| 187 | weak_factory_.GetWeakPtr())); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 188 | |
| 189 | if (rv == ERR_IO_PENDING) { |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 190 | read_callback_ = std::move(callback); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 191 | read_buf_ = buf; |
| 192 | } else if (rv == 0) { |
| 193 | net_log_.AddByteTransferEvent(NetLogEventType::SOCKET_BYTES_RECEIVED, 0, |
| 194 | nullptr); |
| 195 | } else if (rv > 0) { |
| 196 | net_log_.AddByteTransferEvent(NetLogEventType::SOCKET_BYTES_RECEIVED, rv, |
| 197 | buf->data()); |
| 198 | } |
| 199 | return rv; |
| 200 | } |
| 201 | |
| 202 | void QuicProxyClientSocket::OnReadComplete(int rv) { |
| 203 | if (!stream_->IsOpen()) |
| 204 | rv = 0; |
| 205 | |
| 206 | if (!read_callback_.is_null()) { |
| 207 | DCHECK(read_buf_); |
| 208 | if (rv >= 0) { |
| 209 | net_log_.AddByteTransferEvent(NetLogEventType::SOCKET_BYTES_RECEIVED, rv, |
| 210 | read_buf_->data()); |
| 211 | } |
| 212 | read_buf_ = nullptr; |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 213 | std::move(read_callback_).Run(rv); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 214 | } |
| 215 | } |
| 216 | |
[email protected] | a2b2cfc | 2017-12-06 09:06:08 | [diff] [blame] | 217 | int QuicProxyClientSocket::Write( |
| 218 | IOBuffer* buf, |
| 219 | int buf_len, |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 220 | CompletionOnceCallback callback, |
[email protected] | a2b2cfc | 2017-12-06 09:06:08 | [diff] [blame] | 221 | const NetworkTrafficAnnotationTag& traffic_annotation) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 222 | DCHECK(connect_callback_.is_null()); |
| 223 | DCHECK(write_callback_.is_null()); |
| 224 | |
| 225 | if (next_state_ != STATE_CONNECT_COMPLETE) |
| 226 | return ERR_SOCKET_NOT_CONNECTED; |
| 227 | |
| 228 | net_log_.AddByteTransferEvent(NetLogEventType::SOCKET_BYTES_SENT, buf_len, |
| 229 | buf->data()); |
| 230 | |
| 231 | int rv = stream_->WriteStreamData( |
Ryan Hamilton | 8d9ee76e | 2018-05-29 23:52:52 | [diff] [blame] | 232 | quic::QuicStringPiece(buf->data(), buf_len), false, |
Yannic Bonenberger | 3c96beb | 2019-09-03 20:41:37 | [diff] [blame] | 233 | base::BindOnce(&QuicProxyClientSocket::OnWriteComplete, |
| 234 | weak_factory_.GetWeakPtr())); |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 235 | if (rv == OK) |
| 236 | return buf_len; |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 237 | |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 238 | if (rv == ERR_IO_PENDING) { |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 239 | write_callback_ = std::move(callback); |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 240 | write_buf_len_ = buf_len; |
| 241 | } |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 242 | |
| 243 | return rv; |
| 244 | } |
| 245 | |
| 246 | void QuicProxyClientSocket::OnWriteComplete(int rv) { |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 247 | if (!write_callback_.is_null()) { |
| 248 | if (rv == OK) |
| 249 | rv = write_buf_len_; |
| 250 | write_buf_len_ = 0; |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 251 | std::move(write_callback_).Run(rv); |
Yixin Wang | dbbd875 | 2018-01-17 21:50:02 | [diff] [blame] | 252 | } |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | int QuicProxyClientSocket::SetReceiveBufferSize(int32_t size) { |
| 256 | return ERR_NOT_IMPLEMENTED; |
| 257 | } |
| 258 | |
| 259 | int QuicProxyClientSocket::SetSendBufferSize(int32_t size) { |
| 260 | return ERR_NOT_IMPLEMENTED; |
| 261 | } |
| 262 | |
| 263 | int QuicProxyClientSocket::GetPeerAddress(IPEndPoint* address) const { |
| 264 | return IsConnected() ? session_->GetPeerAddress(address) |
| 265 | : ERR_SOCKET_NOT_CONNECTED; |
| 266 | } |
| 267 | |
| 268 | int QuicProxyClientSocket::GetLocalAddress(IPEndPoint* address) const { |
| 269 | return IsConnected() ? session_->GetSelfAddress(address) |
| 270 | : ERR_SOCKET_NOT_CONNECTED; |
| 271 | } |
| 272 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 273 | void QuicProxyClientSocket::OnIOComplete(int result) { |
| 274 | DCHECK_NE(STATE_DISCONNECTED, next_state_); |
| 275 | int rv = DoLoop(result); |
| 276 | if (rv != ERR_IO_PENDING) { |
| 277 | // Connect() finished (successfully or unsuccessfully). |
| 278 | DCHECK(!connect_callback_.is_null()); |
Brad Lassey | 3a81417 | 2018-04-26 03:30:21 | [diff] [blame] | 279 | std::move(connect_callback_).Run(rv); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 280 | } |
| 281 | } |
| 282 | |
| 283 | int QuicProxyClientSocket::DoLoop(int last_io_result) { |
| 284 | DCHECK_NE(next_state_, STATE_DISCONNECTED); |
| 285 | int rv = last_io_result; |
| 286 | do { |
| 287 | State state = next_state_; |
| 288 | next_state_ = STATE_DISCONNECTED; |
| 289 | switch (state) { |
| 290 | case STATE_GENERATE_AUTH_TOKEN: |
| 291 | DCHECK_EQ(OK, rv); |
| 292 | rv = DoGenerateAuthToken(); |
| 293 | break; |
| 294 | case STATE_GENERATE_AUTH_TOKEN_COMPLETE: |
| 295 | rv = DoGenerateAuthTokenComplete(rv); |
| 296 | break; |
| 297 | case STATE_SEND_REQUEST: |
| 298 | DCHECK_EQ(OK, rv); |
| 299 | net_log_.BeginEvent( |
| 300 | NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST); |
| 301 | rv = DoSendRequest(); |
| 302 | break; |
| 303 | case STATE_SEND_REQUEST_COMPLETE: |
| 304 | net_log_.EndEventWithNetErrorCode( |
| 305 | NetLogEventType::HTTP_TRANSACTION_TUNNEL_SEND_REQUEST, rv); |
| 306 | rv = DoSendRequestComplete(rv); |
| 307 | break; |
| 308 | case STATE_READ_REPLY: |
| 309 | rv = DoReadReply(); |
| 310 | break; |
| 311 | case STATE_READ_REPLY_COMPLETE: |
| 312 | rv = DoReadReplyComplete(rv); |
| 313 | net_log_.EndEventWithNetErrorCode( |
| 314 | NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS, rv); |
| 315 | break; |
| 316 | default: |
| 317 | NOTREACHED() << "bad state"; |
| 318 | rv = ERR_UNEXPECTED; |
| 319 | break; |
| 320 | } |
| 321 | } while (rv != ERR_IO_PENDING && next_state_ != STATE_DISCONNECTED && |
| 322 | next_state_ != STATE_CONNECT_COMPLETE); |
| 323 | return rv; |
| 324 | } |
| 325 | |
| 326 | int QuicProxyClientSocket::DoGenerateAuthToken() { |
| 327 | next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE; |
| 328 | return auth_->MaybeGenerateAuthToken( |
| 329 | &request_, |
Yannic Bonenberger | 3c96beb | 2019-09-03 20:41:37 | [diff] [blame] | 330 | base::BindOnce(&QuicProxyClientSocket::OnIOComplete, |
| 331 | weak_factory_.GetWeakPtr()), |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 332 | net_log_); |
| 333 | } |
| 334 | |
| 335 | int QuicProxyClientSocket::DoGenerateAuthTokenComplete(int result) { |
| 336 | DCHECK_NE(ERR_IO_PENDING, result); |
| 337 | if (result == OK) |
| 338 | next_state_ = STATE_SEND_REQUEST; |
| 339 | return result; |
| 340 | } |
| 341 | |
| 342 | int QuicProxyClientSocket::DoSendRequest() { |
| 343 | next_state_ = STATE_SEND_REQUEST_COMPLETE; |
| 344 | |
| 345 | // Add Proxy-Authentication header if necessary. |
| 346 | HttpRequestHeaders authorization_headers; |
| 347 | if (auth_->HaveAuth()) { |
| 348 | auth_->AddAuthorizationHeader(&authorization_headers); |
| 349 | } |
| 350 | |
| 351 | std::string request_line; |
| 352 | BuildTunnelRequest(endpoint_, authorization_headers, user_agent_, |
| 353 | &request_line, &request_.extra_headers); |
| 354 | |
Eric Roman | 06bd974 | 2019-07-13 15:19:13 | [diff] [blame] | 355 | NetLogRequestHeaders(net_log_, |
| 356 | NetLogEventType::HTTP_TRANSACTION_SEND_TUNNEL_HEADERS, |
| 357 | request_line, &request_.extra_headers); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 358 | |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 359 | spdy::SpdyHeaderBlock headers; |
Bence Béky | 1af94d6f | 2018-02-08 00:40:14 | [diff] [blame] | 360 | CreateSpdyHeadersFromHttpRequest(request_, request_.extra_headers, &headers); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 361 | |
| 362 | return stream_->WriteHeaders(std::move(headers), false, nullptr); |
| 363 | } |
| 364 | |
| 365 | int QuicProxyClientSocket::DoSendRequestComplete(int result) { |
| 366 | if (result >= 0) { |
| 367 | // Wait for HEADERS frame from the server |
| 368 | next_state_ = STATE_READ_REPLY; // STATE_READ_REPLY_COMPLETE; |
| 369 | result = OK; |
| 370 | } |
| 371 | |
| 372 | if (result >= 0 || result == ERR_IO_PENDING) { |
| 373 | // Emit extra event so can use the same events as HttpProxyClientSocket. |
| 374 | net_log_.BeginEvent(NetLogEventType::HTTP_TRANSACTION_TUNNEL_READ_HEADERS); |
| 375 | } |
| 376 | |
| 377 | return result; |
| 378 | } |
| 379 | |
| 380 | int QuicProxyClientSocket::DoReadReply() { |
| 381 | next_state_ = STATE_READ_REPLY_COMPLETE; |
| 382 | |
| 383 | int rv = stream_->ReadInitialHeaders( |
| 384 | &response_header_block_, |
Yannic Bonenberger | 3c96beb | 2019-09-03 20:41:37 | [diff] [blame] | 385 | base::BindOnce(&QuicProxyClientSocket::OnReadResponseHeadersComplete, |
| 386 | weak_factory_.GetWeakPtr())); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 387 | if (rv == ERR_IO_PENDING) |
| 388 | return ERR_IO_PENDING; |
| 389 | if (rv < 0) |
| 390 | return rv; |
| 391 | |
| 392 | return ProcessResponseHeaders(response_header_block_); |
| 393 | } |
| 394 | |
| 395 | int QuicProxyClientSocket::DoReadReplyComplete(int result) { |
| 396 | if (result < 0) |
| 397 | return result; |
| 398 | |
| 399 | // Require the "HTTP/1.x" status line for SSL CONNECT. |
| 400 | if (response_.headers->GetHttpVersion() < HttpVersion(1, 0)) |
| 401 | return ERR_TUNNEL_CONNECTION_FAILED; |
| 402 | |
Eric Roman | 06bd974 | 2019-07-13 15:19:13 | [diff] [blame] | 403 | NetLogResponseHeaders( |
| 404 | net_log_, NetLogEventType::HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS, |
| 405 | response_.headers.get()); |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 406 | |
| 407 | switch (response_.headers->response_code()) { |
| 408 | case 200: // OK |
| 409 | next_state_ = STATE_CONNECT_COMPLETE; |
| 410 | return OK; |
| 411 | |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 412 | case 407: // Proxy Authentication Required |
| 413 | next_state_ = STATE_CONNECT_COMPLETE; |
Matt Menke | abd9da8 | 2018-05-10 19:02:58 | [diff] [blame] | 414 | if (!SanitizeProxyAuth(&response_)) |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 415 | return ERR_TUNNEL_CONNECTION_FAILED; |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 416 | return HandleProxyAuthChallenge(auth_.get(), &response_, net_log_); |
| 417 | |
| 418 | default: |
| 419 | // Ignore response to avoid letting the proxy impersonate the target |
| 420 | // server. (See http://crbug.com/137891.) |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 421 | return ERR_TUNNEL_CONNECTION_FAILED; |
| 422 | } |
| 423 | } |
| 424 | |
| 425 | void QuicProxyClientSocket::OnReadResponseHeadersComplete(int result) { |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 426 | // Convert the now-populated spdy::SpdyHeaderBlock to HttpResponseInfo |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 427 | if (result > 0) |
| 428 | result = ProcessResponseHeaders(response_header_block_); |
| 429 | |
| 430 | if (result != ERR_IO_PENDING) |
| 431 | OnIOComplete(result); |
| 432 | } |
| 433 | |
| 434 | int QuicProxyClientSocket::ProcessResponseHeaders( |
Ryan Hamilton | 0239aac | 2018-05-19 00:03:13 | [diff] [blame] | 435 | const spdy::SpdyHeaderBlock& headers) { |
Yixin Wang | 0d2c6b7e1 | 2017-08-16 21:12:55 | [diff] [blame] | 436 | if (!SpdyHeadersToHttpResponse(headers, &response_)) { |
| 437 | DLOG(WARNING) << "Invalid headers"; |
| 438 | return ERR_QUIC_PROTOCOL_ERROR; |
| 439 | } |
| 440 | // Populate |connect_timing_| when response headers are received. This |
| 441 | // should take care of 0-RTT where request is sent before handshake is |
| 442 | // confirmed. |
| 443 | connect_timing_ = session_->GetConnectTiming(); |
| 444 | return OK; |
| 445 | } |
| 446 | |
| 447 | bool QuicProxyClientSocket::GetLoadTimingInfo( |
| 448 | LoadTimingInfo* load_timing_info) const { |
| 449 | bool is_first_stream = stream_->IsFirstStream(); |
| 450 | if (stream_) |
| 451 | is_first_stream = stream_->IsFirstStream(); |
| 452 | if (is_first_stream) { |
| 453 | load_timing_info->socket_reused = false; |
| 454 | load_timing_info->connect_timing = connect_timing_; |
| 455 | } else { |
| 456 | load_timing_info->socket_reused = true; |
| 457 | } |
| 458 | return true; |
| 459 | } |
| 460 | |
| 461 | } // namespace net |