net/proxy_resolution/configured_proxy_resolution_request.cc - codesearch/chromium/src - Git at Google

 // Copyright 2020 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "net/proxy_resolution/configured_proxy_resolution_request.h"

 #include <optional>
 #include <utility>

 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source_type.h"
 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
 #include "net/proxy_resolution/proxy_info.h"
 #include "third_party/abseil-cpp/absl/container/flat_hash_set.h"

 namespace net {

 namespace {

 bool CheckDnsCondition(
     const ProxyConfig::ProxyOverrideRule::DnsProbeCondition& dns_condition,
     const ResolveHostResult& dns_result) {
   switch (dns_condition.result) {
     case ProxyConfig::ProxyOverrideRule::DnsProbeCondition::Result::kNotFound:
       return dns_result.is_address_list_empty;
     case ProxyConfig::ProxyOverrideRule::DnsProbeCondition::Result::kResolved:
       return !dns_result.is_address_list_empty;
   }
 }

 base::Value::Dict CreateEndHostResolutionNetLogParams(
     const url::SchemeHostPort& host,
     const ResolveHostResult& result,
     bool was_resolved_sync) {
   base::Value::Dict dict;
   dict.Set("host", host.Serialize());
   dict.Set("was_resolved_sync", was_resolved_sync);
   result.AddToDict(dict);
   return dict;
 }

 }  // namespace

 ConfiguredProxyResolutionRequest::ConfiguredProxyResolutionRequest(
     ConfiguredProxyResolutionService* service,
     const GURL& url,
     const std::string& method,
     const NetworkAnonymizationKey& network_anonymization_key,
     ProxyInfo* results,
     CompletionOnceCallback user_callback,
     const NetLogWithSource& net_log,
     RequestPriority priority)
     : service_(service),
       user_callback_(std::move(user_callback)),
       results_(results),
       url_(url),
       method_(method),
       network_anonymization_key_(network_anonymization_key),
       net_log_(net_log),
       priority_(priority),
       creation_time_(base::TimeTicks::Now()) {
   CHECK(!user_callback_.is_null());
 }

 ConfiguredProxyResolutionRequest::~ConfiguredProxyResolutionRequest() {
   if (service_) {
     service_->RemovePendingRequest(this);
     Cancel();

     // This should be emitted last, after any message `Cancel()` may
     // trigger.
     net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_SERVICE);
   }
 }

 // Starts the resolve proxy request.
 int ConfiguredProxyResolutionRequest::Start() {
   CHECK(!was_completed());
   CHECK(!is_started());

   CHECK(service_->config_);
   traffic_annotation_ = MutableNetworkTrafficAnnotationTag(
       service_->config_->traffic_annotation());

   if (!service_->config_->value().proxy_override_rules().empty()) {
     net_log_.BeginEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);

     for (const auto& rule : service_->config_->value().proxy_override_rules()) {
       if (rule.MatchesDestination(url_)) {
         bool skip_rule = false;
         for (const auto& dns_condition : rule.dns_conditions) {
           // DNS resolution requests are keyed by the host and the network
           // anonymization key, but not by listeners. This means that a given
           // request may end up as listener multiple times for the same DNS host
           // resolution requests (e.g. if the same host is in multiple rules).
           // This is fine, as long as `OnDnsHostResolved` knows how to handle
           // multiple calls for the same host.
           auto result = service_->RequestHostResolution(
               dns_condition, weak_factory_.GetWeakPtr(),
               network_anonymization_key_, net_log_, priority_);
           if (result) {
             net_log_.AddEvent(
                 NetLogEventType::PROXY_OVERRIDE_END_HOST_RESOLUTION, [&] {
                   return CreateEndHostResolutionNetLogParams(
                       dns_condition.host, result.value(),
                       /*was_resolved_sync=*/true);
                 });

             if (!CheckDnsCondition(dns_condition, result.value())) {
               // No need to trigger DNS resolutions for the remaining hosts
               // in this rule, as it does not apply.
               skip_rule = true;
               break;
             }

             dns_results_.emplace(dns_condition.host, result.value());
           }
         }
         if (!skip_rule) {
           applicable_override_rules_.push(rule);
         }
       }
     }

     if (applicable_override_rules_.empty()) {
       // No override rules applied.
       net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
     }
   }

   return ContinueProxyResolution();
 }

 void ConfiguredProxyResolutionRequest::
     StartAndCompleteCheckingForSynchronous() {
   int rv = service_->TryToCompleteSynchronously(
       url_, /*bypass_override_rules=*/false, net_log_, results_);
   if (rv == ERR_IO_PENDING) {
     rv = Start();
   }

   if (rv != ERR_IO_PENDING) {
     QueryComplete(rv);
   }
 }

 void ConfiguredProxyResolutionRequest::Cancel() {
   net_log_.AddEvent(NetLogEventType::CANCELLED);

   if (!applicable_override_rules_.empty()) {
     net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
   }

   Reset();
   CHECK(!is_started());
 }

 int ConfiguredProxyResolutionRequest::QueryDidComplete(int result_code) {
   CHECK(!was_completed());

   // Clear state so that `is_started()` returns false while
   // DidFinishResolvingProxy() runs.
   if (is_started()) {
     Reset();
   }

   // Note that DidFinishResolvingProxy might modify `results_`.
   int rv = service_->DidFinishResolvingProxy(url_, network_anonymization_key_,
                                              method_, results_, result_code,
                                              net_log_);

   // Make a note in the results which configuration was in use at the
   // time of the resolve.
   results_->set_proxy_resolve_start_time(creation_time_);
   results_->set_proxy_resolve_end_time(base::TimeTicks::Now());

   // If annotation is not already set, e.g. through TryToCompleteSynchronously
   // function, use in-progress-resolve annotation.
   if (!results_->traffic_annotation().is_valid())
     results_->set_traffic_annotation(traffic_annotation_);

   // If proxy is set without error, ensure that an annotation is provided.
   if (result_code != ERR_ABORTED && !rv) {
     // TODO(crbug.com/469006851): Turn this back into a CHECK once crashes were
     // fully fixed.
     DCHECK(results_->traffic_annotation().is_valid());
   }

   // Reset the state associated with in-progress-resolve.
   traffic_annotation_.reset();

   return rv;
 }

 int ConfiguredProxyResolutionRequest::QueryDidCompleteSynchronously(
     int result_code) {
   int rv = QueryDidComplete(result_code);
   service_ = nullptr;
   return rv;
 }

 LoadState ConfiguredProxyResolutionRequest::GetLoadState() const {
   LoadState load_state = LOAD_STATE_IDLE;
   if (service_ && service_->GetLoadStateIfAvailable(&load_state))
     return load_state;

   if (is_started())
     return resolve_job_->GetLoadState();
   return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 }

 // Callback for when the ProxyResolver request has completed.
 void ConfiguredProxyResolutionRequest::QueryComplete(int result_code) {
   result_code = QueryDidComplete(result_code);

   CompletionOnceCallback callback = std::move(user_callback_);

   service_->RemovePendingRequest(this);
   service_ = nullptr;
   user_callback_.Reset();
   std::move(callback).Run(result_code);
 }

 int ConfiguredProxyResolutionRequest::ContinueProxyResolution() {
   if (!applicable_override_rules_.empty()) {
     int rv = EvaluateApplicableOverrideRules();
     if (rv == ERR_IO_PENDING || !results_->is_empty()) {
       return rv;
     }
   }

   if (service_->ApplyPacBypassRules(url_, results_)) {
     return OK;
   }

   // Required in case some override rules needed to run asynchronously, but
   // ended up not applying, and there are e.g. manual proxy settings as
   // fallback.
   int rv = service_->TryToCompleteSynchronously(
       url_, /*bypass_override_rules=*/true, net_log_, results_);
   if (rv != ERR_IO_PENDING) {
     return rv;
   }

   return service_->GetProxyResolver()->GetProxyForURL(
       url_, network_anonymization_key_, results_,
       base::BindOnce(&ConfiguredProxyResolutionRequest::QueryComplete,
                      base::Unretained(this)),
       &resolve_job_, net_log_);
 }

 void ConfiguredProxyResolutionRequest::OnDnsHostResolved(
     const url::SchemeHostPort& host,
     const ResolveHostResult& result) {
   if (applicable_override_rules_.empty()) {
     // DNS resolution is only required for override rules. Ignore these function
     // calls if the current request is not resolving override rules.
     return;
   }

   // Using `try_emplace` as this line may be hit multiple times for the same
   // host (see comment in `Start`).
   auto [unused, inserted] = dns_results_.try_emplace(host, result);
   // Entry already existed, likely with the same value as before. Same value or
   // not, we keep the old result, so there's nothing else to do.
   if (!inserted) {
     return;
   }

   net_log_.AddEvent(NetLogEventType::PROXY_OVERRIDE_END_HOST_RESOLUTION, [&] {
     return CreateEndHostResolutionNetLogParams(host, result,
                                                /*was_resolved_sync=*/false);
   });

   if (!service_ || !service_->IsReady()) {
     // Something happened during DNS resolution which invalidated the
     // service's state (e.g. config update). The service will resume
     // the current request if/when needed.
     return;
   }

   int rv = ContinueProxyResolution();
   if (rv == ERR_IO_PENDING) {
     // Missing a required DNS resolution.
     return;
   }

   QueryComplete(rv);
 }

 int ConfiguredProxyResolutionRequest::EvaluateApplicableOverrideRules() {
   while (!applicable_override_rules_.empty()) {
     const auto& applicable_rule = applicable_override_rules_.front();

     // Not having any conditions means they are all satisfied.
     bool conditions_satisfied = true;
     for (const auto& dns_condition : applicable_rule.dns_conditions) {
       // If no results are found in the DNS results map, it means that the DNS
       // resolution request owned by the service is still pending.
       auto dns_result_it = dns_results_.find(dns_condition.host);
       if (dns_result_it == dns_results_.end()) {
         return ERR_IO_PENDING;
       }

       conditions_satisfied =
           conditions_satisfied &&
           CheckDnsCondition(dns_condition, dns_result_it->second);
     }

     if (conditions_satisfied) {
       net_log_.AddEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULE_APPLIED,
                         [&] { return applicable_rule.ToDict(); });
       results_->UseProxyList(applicable_rule.proxy_list);
       break;
     }

     // Conditions were evaluated successfully, but are not satisfied. This
     // current rule is therefore no longer applicable.
     applicable_override_rules_.pop();
   }

   dns_results_.clear();
   net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
   return OK;
 }

 void ConfiguredProxyResolutionRequest::Reset() {
   // The request may already be running in the resolver.
   resolve_job_.reset();
   applicable_override_rules_ = base::queue<ProxyConfig::ProxyOverrideRule>();
   dns_results_.clear();
 }

 }  // namespace net
	// Copyright 2020 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "net/proxy_resolution/configured_proxy_resolution_request.h"

	#include <optional>
	#include <utility>

	#include "base/functional/bind.h"
	#include "base/functional/callback_helpers.h"
	#include "net/base/net_errors.h"
	#include "net/log/net_log_event_type.h"
	#include "net/log/net_log_source_type.h"
	#include "net/proxy_resolution/configured_proxy_resolution_service.h"
	#include "net/proxy_resolution/proxy_info.h"
	#include "third_party/abseil-cpp/absl/container/flat_hash_set.h"

	namespace net {

	namespace {

	bool CheckDnsCondition(
	const ProxyConfig::ProxyOverrideRule::DnsProbeCondition& dns_condition,
	const ResolveHostResult& dns_result) {
	switch (dns_condition.result) {
	case ProxyConfig::ProxyOverrideRule::DnsProbeCondition::Result::kNotFound:
	return dns_result.is_address_list_empty;
	case ProxyConfig::ProxyOverrideRule::DnsProbeCondition::Result::kResolved:
	return !dns_result.is_address_list_empty;
	}
	}

	base::Value::Dict CreateEndHostResolutionNetLogParams(
	const url::SchemeHostPort& host,
	const ResolveHostResult& result,
	bool was_resolved_sync) {
	base::Value::Dict dict;
	dict.Set("host", host.Serialize());
	dict.Set("was_resolved_sync", was_resolved_sync);
	result.AddToDict(dict);
	return dict;
	}

	} // namespace

	ConfiguredProxyResolutionRequest::ConfiguredProxyResolutionRequest(
	ConfiguredProxyResolutionService* service,
	const GURL& url,
	const std::string& method,
	const NetworkAnonymizationKey& network_anonymization_key,
	ProxyInfo* results,
	CompletionOnceCallback user_callback,
	const NetLogWithSource& net_log,
	RequestPriority priority)
	: service_(service),
	user_callback_(std::move(user_callback)),
	results_(results),
	url_(url),
	method_(method),
	network_anonymization_key_(network_anonymization_key),
	net_log_(net_log),
	priority_(priority),
	creation_time_(base::TimeTicks::Now()) {
	CHECK(!user_callback_.is_null());
	}

	ConfiguredProxyResolutionRequest::~ConfiguredProxyResolutionRequest() {
	if (service_) {
	service_->RemovePendingRequest(this);
	Cancel();

	// This should be emitted last, after any message `Cancel()` may
	// trigger.
	net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_SERVICE);
	}
	}

	// Starts the resolve proxy request.
	int ConfiguredProxyResolutionRequest::Start() {
	CHECK(!was_completed());
	CHECK(!is_started());

	CHECK(service_->config_);
	traffic_annotation_ = MutableNetworkTrafficAnnotationTag(
	service_->config_->traffic_annotation());

	if (!service_->config_->value().proxy_override_rules().empty()) {
	net_log_.BeginEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);

	for (const auto& rule : service_->config_->value().proxy_override_rules()) {
	if (rule.MatchesDestination(url_)) {
	bool skip_rule = false;
	for (const auto& dns_condition : rule.dns_conditions) {
	// DNS resolution requests are keyed by the host and the network
	// anonymization key, but not by listeners. This means that a given
	// request may end up as listener multiple times for the same DNS host
	// resolution requests (e.g. if the same host is in multiple rules).
	// This is fine, as long as `OnDnsHostResolved` knows how to handle
	// multiple calls for the same host.
	auto result = service_->RequestHostResolution(
	dns_condition, weak_factory_.GetWeakPtr(),
	network_anonymization_key_, net_log_, priority_);
	if (result) {
	net_log_.AddEvent(
	NetLogEventType::PROXY_OVERRIDE_END_HOST_RESOLUTION, [&] {
	return CreateEndHostResolutionNetLogParams(
	dns_condition.host, result.value(),
	/was_resolved_sync=/true);
	});

	if (!CheckDnsCondition(dns_condition, result.value())) {
	// No need to trigger DNS resolutions for the remaining hosts
	// in this rule, as it does not apply.
	skip_rule = true;
	break;
	}

	dns_results_.emplace(dns_condition.host, result.value());
	}
	}
	if (!skip_rule) {
	applicable_override_rules_.push(rule);
	}
	}
	}

	if (applicable_override_rules_.empty()) {
	// No override rules applied.
	net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
	}
	}

	return ContinueProxyResolution();
	}

	void ConfiguredProxyResolutionRequest::
	StartAndCompleteCheckingForSynchronous() {
	int rv = service_->TryToCompleteSynchronously(
	url_, /bypass_override_rules=/false, net_log_, results_);
	if (rv == ERR_IO_PENDING) {
	rv = Start();
	}

	if (rv != ERR_IO_PENDING) {
	QueryComplete(rv);
	}
	}

	void ConfiguredProxyResolutionRequest::Cancel() {
	net_log_.AddEvent(NetLogEventType::CANCELLED);

	if (!applicable_override_rules_.empty()) {
	net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
	}

	Reset();
	CHECK(!is_started());
	}

	int ConfiguredProxyResolutionRequest::QueryDidComplete(int result_code) {
	CHECK(!was_completed());

	// Clear state so that `is_started()` returns false while
	// DidFinishResolvingProxy() runs.
	if (is_started()) {
	Reset();
	}

	// Note that DidFinishResolvingProxy might modify `results_`.
	int rv = service_->DidFinishResolvingProxy(url_, network_anonymization_key_,
	method_, results_, result_code,
	net_log_);

	// Make a note in the results which configuration was in use at the
	// time of the resolve.
	results_->set_proxy_resolve_start_time(creation_time_);
	results_->set_proxy_resolve_end_time(base::TimeTicks::Now());

	// If annotation is not already set, e.g. through TryToCompleteSynchronously
	// function, use in-progress-resolve annotation.
	if (!results_->traffic_annotation().is_valid())
	results_->set_traffic_annotation(traffic_annotation_);

	// If proxy is set without error, ensure that an annotation is provided.
	if (result_code != ERR_ABORTED && !rv) {
	// TODO(crbug.com/469006851): Turn this back into a CHECK once crashes were
	// fully fixed.
	DCHECK(results_->traffic_annotation().is_valid());
	}

	// Reset the state associated with in-progress-resolve.
	traffic_annotation_.reset();

	return rv;
	}

	int ConfiguredProxyResolutionRequest::QueryDidCompleteSynchronously(
	int result_code) {
	int rv = QueryDidComplete(result_code);
	service_ = nullptr;
	return rv;
	}

	LoadState ConfiguredProxyResolutionRequest::GetLoadState() const {
	LoadState load_state = LOAD_STATE_IDLE;
	if (service_ && service_->GetLoadStateIfAvailable(&load_state))
	return load_state;

	if (is_started())
	return resolve_job_->GetLoadState();
	return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
	}

	// Callback for when the ProxyResolver request has completed.
	void ConfiguredProxyResolutionRequest::QueryComplete(int result_code) {
	result_code = QueryDidComplete(result_code);

	CompletionOnceCallback callback = std::move(user_callback_);

	service_->RemovePendingRequest(this);
	service_ = nullptr;
	user_callback_.Reset();
	std::move(callback).Run(result_code);
	}

	int ConfiguredProxyResolutionRequest::ContinueProxyResolution() {
	if (!applicable_override_rules_.empty()) {
	int rv = EvaluateApplicableOverrideRules();
	if (rv == ERR_IO_PENDING \|\| !results_->is_empty()) {
	return rv;
	}
	}

	if (service_->ApplyPacBypassRules(url_, results_)) {
	return OK;
	}

	// Required in case some override rules needed to run asynchronously, but
	// ended up not applying, and there are e.g. manual proxy settings as
	// fallback.
	int rv = service_->TryToCompleteSynchronously(
	url_, /bypass_override_rules=/true, net_log_, results_);
	if (rv != ERR_IO_PENDING) {
	return rv;
	}

	return service_->GetProxyResolver()->GetProxyForURL(
	url_, network_anonymization_key_, results_,
	base::BindOnce(&ConfiguredProxyResolutionRequest::QueryComplete,
	base::Unretained(this)),
	&resolve_job_, net_log_);
	}

	void ConfiguredProxyResolutionRequest::OnDnsHostResolved(
	const url::SchemeHostPort& host,
	const ResolveHostResult& result) {
	if (applicable_override_rules_.empty()) {
	// DNS resolution is only required for override rules. Ignore these function
	// calls if the current request is not resolving override rules.
	return;
	}

	// Using `try_emplace` as this line may be hit multiple times for the same
	// host (see comment in `Start`).
	auto [unused, inserted] = dns_results_.try_emplace(host, result);
	// Entry already existed, likely with the same value as before. Same value or
	// not, we keep the old result, so there's nothing else to do.
	if (!inserted) {
	return;
	}

	net_log_.AddEvent(NetLogEventType::PROXY_OVERRIDE_END_HOST_RESOLUTION, [&] {
	return CreateEndHostResolutionNetLogParams(host, result,
	/was_resolved_sync=/false);
	});

	if (!service_ \|\| !service_->IsReady()) {
	// Something happened during DNS resolution which invalidated the
	// service's state (e.g. config update). The service will resume
	// the current request if/when needed.
	return;
	}

	int rv = ContinueProxyResolution();
	if (rv == ERR_IO_PENDING) {
	// Missing a required DNS resolution.
	return;
	}

	QueryComplete(rv);
	}

	int ConfiguredProxyResolutionRequest::EvaluateApplicableOverrideRules() {
	while (!applicable_override_rules_.empty()) {
	const auto& applicable_rule = applicable_override_rules_.front();

	// Not having any conditions means they are all satisfied.
	bool conditions_satisfied = true;
	for (const auto& dns_condition : applicable_rule.dns_conditions) {
	// If no results are found in the DNS results map, it means that the DNS
	// resolution request owned by the service is still pending.
	auto dns_result_it = dns_results_.find(dns_condition.host);
	if (dns_result_it == dns_results_.end()) {
	return ERR_IO_PENDING;
	}

	conditions_satisfied =
	conditions_satisfied &&
	CheckDnsCondition(dns_condition, dns_result_it->second);
	}

	if (conditions_satisfied) {
	net_log_.AddEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULE_APPLIED,
	[&] { return applicable_rule.ToDict(); });
	results_->UseProxyList(applicable_rule.proxy_list);
	break;
	}

	// Conditions were evaluated successfully, but are not satisfied. This
	// current rule is therefore no longer applicable.
	applicable_override_rules_.pop();
	}

	dns_results_.clear();
	net_log_.EndEvent(NetLogEventType::PROXY_RESOLUTION_OVERRIDE_RULES);
	return OK;
	}

	void ConfiguredProxyResolutionRequest::Reset() {
	// The request may already be running in the resolver.
	resolve_job_.reset();
	applicable_override_rules_ = base::queue<ProxyConfig::ProxyOverrideRule>();
	dns_results_.clear();
	}

	} // namespace net