1 // Copyright 2014 The Chromium Authors
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 "components/cronet/cronet_url_request.h"
6
7 #include <limits>
8 #include <utility>
9
10 #include "base/functional/bind.h"
11 #include "base/location.h"
12 #include "base/logging.h"
13 #include "build/build_config.h"
14 #include "components/cronet/cronet_context.h"
15 #include "net/base/idempotency.h"
16 #include "net/base/io_buffer.h"
17 #include "net/base/load_flags.h"
18 #include "net/base/load_states.h"
19 #include "net/base/net_errors.h"
20 #include "net/base/proxy_chain.h"
21 #include "net/base/proxy_server.h"
22 #include "net/base/request_priority.h"
23 #include "net/base/upload_data_stream.h"
24 #include "net/cert/cert_status_flags.h"
25 #include "net/cert/x509_certificate.h"
26 #include "net/http/http_response_headers.h"
27 #include "net/http/http_status_code.h"
28 #include "net/http/http_util.h"
29 #include "net/ssl/ssl_info.h"
30 #include "net/ssl/ssl_private_key.h"
31 #include "net/third_party/quiche/src/quiche/quic/core/quic_packets.h"
32 #include "net/traffic_annotation/network_traffic_annotation.h"
33 #include "net/url_request/redirect_info.h"
34 #include "net/url_request/url_request_context.h"
35
36 namespace cronet {
37
38 namespace {
39
40 // Returns the string representation of the HostPortPair of the proxy server
41 // that was used to fetch the response.
GetProxy(const net::HttpResponseInfo & info)42 std::string GetProxy(const net::HttpResponseInfo& info) {
43 if (!info.proxy_chain.IsValid() || info.proxy_chain.is_direct()) {
44 return net::HostPortPair().ToString();
45 }
46 CHECK(info.proxy_chain.is_single_proxy());
47 return info.proxy_chain.GetProxyServer(/*chain_index=*/0)
48 .host_port_pair()
49 .ToString();
50 }
51
CalculateLoadFlags(int load_flags,bool disable_cache,bool disable_connection_migration)52 int CalculateLoadFlags(int load_flags,
53 bool disable_cache,
54 bool disable_connection_migration) {
55 if (disable_cache)
56 load_flags |= net::LOAD_DISABLE_CACHE;
57 if (disable_connection_migration)
58 load_flags |= net::LOAD_DISABLE_CONNECTION_MIGRATION_TO_CELLULAR;
59 return load_flags;
60 }
61
62 } // namespace
63
CronetURLRequest(CronetContext * context,std::unique_ptr<Callback> callback,const GURL & url,net::RequestPriority priority,bool disable_cache,bool disable_connection_migration,bool traffic_stats_tag_set,int32_t traffic_stats_tag,bool traffic_stats_uid_set,int32_t traffic_stats_uid,net::Idempotency idempotency,net::handles::NetworkHandle network)64 CronetURLRequest::CronetURLRequest(CronetContext* context,
65 std::unique_ptr<Callback> callback,
66 const GURL& url,
67 net::RequestPriority priority,
68 bool disable_cache,
69 bool disable_connection_migration,
70 bool traffic_stats_tag_set,
71 int32_t traffic_stats_tag,
72 bool traffic_stats_uid_set,
73 int32_t traffic_stats_uid,
74 net::Idempotency idempotency,
75 net::handles::NetworkHandle network)
76 : context_(context),
77 network_tasks_(std::move(callback),
78 url,
79 priority,
80 CalculateLoadFlags(context->default_load_flags(),
81 disable_cache,
82 disable_connection_migration),
83 traffic_stats_tag_set,
84 traffic_stats_tag,
85 traffic_stats_uid_set,
86 traffic_stats_uid,
87 idempotency,
88 network),
89 initial_method_("GET"),
90 initial_request_headers_(std::make_unique<net::HttpRequestHeaders>()) {
91 DCHECK(!context_->IsOnNetworkThread());
92 }
93
~CronetURLRequest()94 CronetURLRequest::~CronetURLRequest() {
95 DCHECK(context_->IsOnNetworkThread());
96 }
97
SetHttpMethod(const std::string & method)98 bool CronetURLRequest::SetHttpMethod(const std::string& method) {
99 DCHECK(!context_->IsOnNetworkThread());
100 // Http method is a token, just as header name.
101 if (!net::HttpUtil::IsValidHeaderName(method))
102 return false;
103 initial_method_ = method;
104 return true;
105 }
106
AddRequestHeader(const std::string & name,const std::string & value)107 bool CronetURLRequest::AddRequestHeader(const std::string& name,
108 const std::string& value) {
109 DCHECK(!context_->IsOnNetworkThread());
110 DCHECK(initial_request_headers_);
111 if (!net::HttpUtil::IsValidHeaderName(name) ||
112 !net::HttpUtil::IsValidHeaderValue(value)) {
113 return false;
114 }
115 initial_request_headers_->SetHeader(name, value);
116 return true;
117 }
118
SetUpload(std::unique_ptr<net::UploadDataStream> upload)119 void CronetURLRequest::SetUpload(
120 std::unique_ptr<net::UploadDataStream> upload) {
121 DCHECK(!context_->IsOnNetworkThread());
122 DCHECK(!upload_);
123 upload_ = std::move(upload);
124 }
125
Start()126 void CronetURLRequest::Start() {
127 DCHECK(!context_->IsOnNetworkThread());
128 context_->PostTaskToNetworkThread(
129 FROM_HERE,
130 base::BindOnce(&CronetURLRequest::NetworkTasks::Start,
131 base::Unretained(&network_tasks_),
132 base::Unretained(context_), initial_method_,
133 std::move(initial_request_headers_), std::move(upload_)));
134 }
135
GetStatus(OnStatusCallback callback) const136 void CronetURLRequest::GetStatus(OnStatusCallback callback) const {
137 context_->PostTaskToNetworkThread(
138 FROM_HERE,
139 base::BindOnce(&CronetURLRequest::NetworkTasks::GetStatus,
140 base::Unretained(&network_tasks_), std::move(callback)));
141 }
142
FollowDeferredRedirect()143 void CronetURLRequest::FollowDeferredRedirect() {
144 context_->PostTaskToNetworkThread(
145 FROM_HERE,
146 base::BindOnce(&CronetURLRequest::NetworkTasks::FollowDeferredRedirect,
147 base::Unretained(&network_tasks_)));
148 }
149
ReadData(net::IOBuffer * raw_read_buffer,int max_size)150 bool CronetURLRequest::ReadData(net::IOBuffer* raw_read_buffer, int max_size) {
151 // TODO(https://crbug.com/1335423): Change to DCHECK() or remove after bug
152 // is fixed.
153 CHECK(max_size == 0 || (raw_read_buffer && raw_read_buffer->data()));
154
155 scoped_refptr<net::IOBuffer> read_buffer(raw_read_buffer);
156 context_->PostTaskToNetworkThread(
157 FROM_HERE,
158 base::BindOnce(&CronetURLRequest::NetworkTasks::ReadData,
159 base::Unretained(&network_tasks_), read_buffer, max_size));
160 return true;
161 }
162
Destroy(bool send_on_canceled)163 void CronetURLRequest::Destroy(bool send_on_canceled) {
164 // Destroy could be called from any thread, including network thread (if
165 // posting task to executor throws an exception), but is posted, so |this|
166 // is valid until calling task is complete. Destroy() must be called from
167 // within a synchronized block that guarantees no future posts to the
168 // network thread with the request pointer.
169 context_->PostTaskToNetworkThread(
170 FROM_HERE, base::BindOnce(&CronetURLRequest::NetworkTasks::Destroy,
171 base::Unretained(&network_tasks_),
172 base::Unretained(this), send_on_canceled));
173 }
174
MaybeReportMetricsAndRunCallback(base::OnceClosure callback)175 void CronetURLRequest::MaybeReportMetricsAndRunCallback(
176 base::OnceClosure callback) {
177 context_->PostTaskToNetworkThread(
178 FROM_HERE,
179 base::BindOnce(
180 &CronetURLRequest::NetworkTasks::MaybeReportMetricsAndRunCallback,
181 base::Unretained(&network_tasks_), std::move(callback)));
182 }
183
NetworkTasks(std::unique_ptr<Callback> callback,const GURL & url,net::RequestPriority priority,int load_flags,bool traffic_stats_tag_set,int32_t traffic_stats_tag,bool traffic_stats_uid_set,int32_t traffic_stats_uid,net::Idempotency idempotency,net::handles::NetworkHandle network)184 CronetURLRequest::NetworkTasks::NetworkTasks(
185 std::unique_ptr<Callback> callback,
186 const GURL& url,
187 net::RequestPriority priority,
188 int load_flags,
189 bool traffic_stats_tag_set,
190 int32_t traffic_stats_tag,
191 bool traffic_stats_uid_set,
192 int32_t traffic_stats_uid,
193 net::Idempotency idempotency,
194 net::handles::NetworkHandle network)
195 : callback_(std::move(callback)),
196 initial_url_(url),
197 initial_priority_(priority),
198 initial_load_flags_(load_flags),
199 received_byte_count_from_redirects_(0l),
200 error_reported_(false),
201 metrics_reported_(false),
202 traffic_stats_tag_set_(traffic_stats_tag_set),
203 traffic_stats_tag_(traffic_stats_tag),
204 traffic_stats_uid_set_(traffic_stats_uid_set),
205 traffic_stats_uid_(traffic_stats_uid),
206 idempotency_(idempotency),
207 network_(network) {
208 DETACH_FROM_THREAD(network_thread_checker_);
209 }
210
~NetworkTasks()211 CronetURLRequest::NetworkTasks::~NetworkTasks() {
212 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
213 }
214
OnReceivedRedirect(net::URLRequest * request,const net::RedirectInfo & redirect_info,bool * defer_redirect)215 void CronetURLRequest::NetworkTasks::OnReceivedRedirect(
216 net::URLRequest* request,
217 const net::RedirectInfo& redirect_info,
218 bool* defer_redirect) {
219 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
220 received_byte_count_from_redirects_ += request->GetTotalReceivedBytes();
221 callback_->OnReceivedRedirect(
222 redirect_info.new_url.spec(), redirect_info.status_code,
223 request->response_headers()->GetStatusText(), request->response_headers(),
224 request->response_info().was_cached,
225 request->response_info().alpn_negotiated_protocol,
226 GetProxy(request->response_info()), received_byte_count_from_redirects_);
227 *defer_redirect = true;
228 }
229
OnCertificateRequested(net::URLRequest * request,net::SSLCertRequestInfo * cert_request_info)230 void CronetURLRequest::NetworkTasks::OnCertificateRequested(
231 net::URLRequest* request,
232 net::SSLCertRequestInfo* cert_request_info) {
233 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
234 // Cronet does not support client certificates.
235 request->ContinueWithCertificate(nullptr, nullptr);
236 }
237
OnSSLCertificateError(net::URLRequest * request,int net_error,const net::SSLInfo & ssl_info,bool fatal)238 void CronetURLRequest::NetworkTasks::OnSSLCertificateError(
239 net::URLRequest* request,
240 int net_error,
241 const net::SSLInfo& ssl_info,
242 bool fatal) {
243 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
244 ReportError(request, net_error);
245 request->Cancel();
246 }
247
OnResponseStarted(net::URLRequest * request,int net_error)248 void CronetURLRequest::NetworkTasks::OnResponseStarted(net::URLRequest* request,
249 int net_error) {
250 DCHECK_NE(net::ERR_IO_PENDING, net_error);
251 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
252
253 if (net_error != net::OK) {
254 ReportError(request, net_error);
255 return;
256 }
257 callback_->OnResponseStarted(
258 request->GetResponseCode(), request->response_headers()->GetStatusText(),
259 request->response_headers(), request->response_info().was_cached,
260 request->response_info().alpn_negotiated_protocol,
261 GetProxy(request->response_info()),
262 received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
263 }
264
OnReadCompleted(net::URLRequest * request,int bytes_read)265 void CronetURLRequest::NetworkTasks::OnReadCompleted(net::URLRequest* request,
266 int bytes_read) {
267 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
268
269 if (bytes_read < 0) {
270 ReportError(request, bytes_read);
271 return;
272 }
273
274 if (bytes_read == 0) {
275 DCHECK(!error_reported_);
276 MaybeReportMetrics();
277 callback_->OnSucceeded(received_byte_count_from_redirects_ +
278 request->GetTotalReceivedBytes());
279 } else {
280 callback_->OnReadCompleted(
281 read_buffer_, bytes_read,
282 received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
283 }
284 // Free the read buffer.
285 read_buffer_ = nullptr;
286 }
287
Start(CronetContext * context,const std::string & method,std::unique_ptr<net::HttpRequestHeaders> request_headers,std::unique_ptr<net::UploadDataStream> upload)288 void CronetURLRequest::NetworkTasks::Start(
289 CronetContext* context,
290 const std::string& method,
291 std::unique_ptr<net::HttpRequestHeaders> request_headers,
292 std::unique_ptr<net::UploadDataStream> upload) {
293 DCHECK(context->IsOnNetworkThread());
294 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
295 VLOG(1) << "Starting chromium request: "
296 << initial_url_.possibly_invalid_spec().c_str()
297 << " priority: " << RequestPriorityToString(initial_priority_);
298 url_request_ = context->GetURLRequestContext(network_)->CreateRequest(
299 initial_url_, net::DEFAULT_PRIORITY, this, MISSING_TRAFFIC_ANNOTATION);
300 url_request_->SetLoadFlags(initial_load_flags_);
301 url_request_->set_method(method);
302 url_request_->SetExtraRequestHeaders(*request_headers);
303 url_request_->SetPriority(initial_priority_);
304 url_request_->SetIdempotency(idempotency_);
305 std::string referer;
306 if (request_headers->GetHeader(net::HttpRequestHeaders::kReferer, &referer)) {
307 url_request_->SetReferrer(referer);
308 }
309 if (upload)
310 url_request_->set_upload(std::move(upload));
311 if (traffic_stats_tag_set_ || traffic_stats_uid_set_) {
312 #if BUILDFLAG(IS_ANDROID)
313 url_request_->set_socket_tag(net::SocketTag(
314 traffic_stats_uid_set_ ? traffic_stats_uid_ : net::SocketTag::UNSET_UID,
315 traffic_stats_tag_set_ ? traffic_stats_tag_
316 : net::SocketTag::UNSET_TAG));
317 #else
318 CHECK(false);
319 #endif
320 }
321 url_request_->Start();
322 }
323
GetStatus(OnStatusCallback callback) const324 void CronetURLRequest::NetworkTasks::GetStatus(
325 OnStatusCallback callback) const {
326 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
327 net::LoadState status = net::LOAD_STATE_IDLE;
328 // |url_request_| is initialized in StartOnNetworkThread, and it is
329 // never nulled. If it is null, it must be that StartOnNetworkThread
330 // has not been called, pretend that we are in LOAD_STATE_IDLE.
331 // See https://crbug.com/606872.
332 if (url_request_)
333 status = url_request_->GetLoadState().state;
334 std::move(callback).Run(status);
335 }
336
FollowDeferredRedirect()337 void CronetURLRequest::NetworkTasks::FollowDeferredRedirect() {
338 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
339 url_request_->FollowDeferredRedirect(
340 absl::nullopt /* removed_request_headers */,
341 absl::nullopt /* modified_request_headers */);
342 }
343
ReadData(scoped_refptr<net::IOBuffer> read_buffer,int buffer_size)344 void CronetURLRequest::NetworkTasks::ReadData(
345 scoped_refptr<net::IOBuffer> read_buffer,
346 int buffer_size) {
347 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
348 DCHECK(read_buffer);
349 DCHECK(!read_buffer_);
350
351 read_buffer_ = read_buffer;
352
353 int result = url_request_->Read(read_buffer_.get(), buffer_size);
354 // If IO is pending, wait for the URLRequest to call OnReadCompleted.
355 if (result == net::ERR_IO_PENDING)
356 return;
357
358 OnReadCompleted(url_request_.get(), result);
359 }
360
Destroy(CronetURLRequest * request,bool send_on_canceled)361 void CronetURLRequest::NetworkTasks::Destroy(CronetURLRequest* request,
362 bool send_on_canceled) {
363 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
364 MaybeReportMetrics();
365 if (send_on_canceled)
366 callback_->OnCanceled();
367 callback_->OnDestroyed();
368 // Check if the URLRequestContext associated to `network_` has become eligible
369 // for destruction. To simplify MaybeDestroyURLRequestContext's logic: destroy
370 // the underlying URLRequest in advance, so that it has already deregistered
371 // from its URLRequestContext by the time MaybeDestroyURLRequestContext is
372 // called.
373 url_request_.reset();
374 request->context_->MaybeDestroyURLRequestContext(network_);
375 // Deleting owner request also deletes `this`.
376 delete request;
377 }
378
ReportError(net::URLRequest * request,int net_error)379 void CronetURLRequest::NetworkTasks::ReportError(net::URLRequest* request,
380 int net_error) {
381 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
382 DCHECK_NE(net::ERR_IO_PENDING, net_error);
383 DCHECK_LT(net_error, 0);
384 DCHECK_EQ(request, url_request_.get());
385 // Error may have already been reported.
386 if (error_reported_)
387 return;
388 error_reported_ = true;
389 net::NetErrorDetails net_error_details;
390 url_request_->PopulateNetErrorDetails(&net_error_details);
391 VLOG(1) << "Error " << net::ErrorToString(net_error)
392 << " on chromium request: " << initial_url_.possibly_invalid_spec();
393 MaybeReportMetrics();
394 callback_->OnError(
395 net_error, net_error_details.quic_connection_error,
396 net::ErrorToString(net_error),
397 received_byte_count_from_redirects_ + request->GetTotalReceivedBytes());
398 }
399
MaybeReportMetrics()400 void CronetURLRequest::NetworkTasks::MaybeReportMetrics() {
401 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
402 // If there was an exception while starting the CronetUrlRequest, there won't
403 // be a native URLRequest. In this case, the caller gets the exception
404 // immediately, and the onFailed callback isn't called, so don't report
405 // metrics either.
406 if (metrics_reported_ || !url_request_) {
407 return;
408 }
409 metrics_reported_ = true;
410 net::LoadTimingInfo metrics;
411 url_request_->GetLoadTimingInfo(&metrics);
412 net::NetErrorDetails net_error_details;
413 url_request_->PopulateNetErrorDetails(&net_error_details);
414 callback_->OnMetricsCollected(
415 metrics.request_start_time, metrics.request_start,
416 metrics.connect_timing.domain_lookup_start,
417 metrics.connect_timing.domain_lookup_end,
418 metrics.connect_timing.connect_start, metrics.connect_timing.connect_end,
419 metrics.connect_timing.ssl_start, metrics.connect_timing.ssl_end,
420 metrics.send_start, metrics.send_end, metrics.push_start,
421 metrics.push_end, metrics.receive_headers_end, base::TimeTicks::Now(),
422 metrics.socket_reused, url_request_->GetTotalSentBytes(),
423 received_byte_count_from_redirects_ +
424 url_request_->GetTotalReceivedBytes(),
425 net_error_details.quic_connection_migration_attempted,
426 net_error_details.quic_connection_migration_successful);
427 }
428
MaybeReportMetricsAndRunCallback(base::OnceClosure callback)429 void CronetURLRequest::NetworkTasks::MaybeReportMetricsAndRunCallback(
430 base::OnceClosure callback) {
431 DCHECK_CALLED_ON_VALID_THREAD(network_thread_checker_);
432 MaybeReportMetrics();
433 std::move(callback).Run();
434 }
435
436 } // namespace cronet
437