blob: 13c950406fb0ee5b28664b2e8a19269193b15029 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/proxy_resolution/dhcp_pac_file_fetcher_win.h"
#include <memory>
#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/containers/queue.h"
#include "base/memory/free_deleter.h"
#include "base/synchronization/lock.h"
#include "base/task/post_task.h"
#include "base/task_runner.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/values.h"
#include "net/base/net_errors.h"
#include "net/log/net_log.h"
#include "net/proxy_resolution/dhcp_pac_file_adapter_fetcher_win.h"
#include <winsock2.h>
#include <iphlpapi.h>
namespace net {
namespace {
// Returns true if |adapter| should be considered when probing for WPAD via
// DHCP.
bool IsDhcpCapableAdapter(IP_ADAPTER_ADDRESSES* adapter) {
if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK)
return false;
if ((adapter->Flags & IP_ADAPTER_DHCP_ENABLED) == 0)
return false;
// Don't probe interfaces which are not up and ready to pass packets.
//
// This is a speculative fix for https://crbug.com/770201, in case calling
// dhcpsvc!DhcpRequestParams on interfaces that aren't ready yet blocks for
// a long time.
//
// Since ProxyResolutionService restarts WPAD probes in response to other
// network level changes, this will likely get called again once the
// interface is up.
if (adapter->OperStatus != IfOperStatusUp)
return false;
return true;
}
} // namespace
// This struct contains logging information describing how
// GetCandidateAdapterNames() performed, for output to NetLog.
struct DhcpAdapterNamesLoggingInfo {
DhcpAdapterNamesLoggingInfo() = default;
~DhcpAdapterNamesLoggingInfo() = default;
// The error that iphlpapi!GetAdaptersAddresses returned.
ULONG error;
// The adapters list that iphlpapi!GetAdaptersAddresses returned.
std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> adapters;
// The time immediately before GetCandidateAdapterNames was posted to a worker
// thread from the origin thread.
base::TimeTicks origin_thread_start_time;
// The time when GetCandidateAdapterNames began running on the worker thread.
base::TimeTicks worker_thread_start_time;
// The time when GetCandidateAdapterNames completed running on the worker
// thread.
base::TimeTicks worker_thread_end_time;
// The time when control returned to the origin thread
// (OnGetCandidateAdapterNamesDone)
base::TimeTicks origin_thread_end_time;
private:
DISALLOW_COPY_AND_ASSIGN(DhcpAdapterNamesLoggingInfo);
};
namespace {
// Maximum number of DHCP lookup tasks running concurrently. This is chosen
// based on the following UMA data:
// - When OnWaitTimer fires, ~99.8% of users have 6 or fewer network
// adapters enabled for DHCP in total.
// - At the same measurement point, ~99.7% of users have 3 or fewer pending
// DHCP adapter lookups.
// - There is however a very long and thin tail of users who have
// systems reporting up to 100+ adapters (this must be some very weird
// OS bug (?), probably the cause of http://crbug.com/240034).
//
// Th value is chosen such that DHCP lookup tasks don't prevent other tasks from
// running even on systems that report a huge number of network adapters, while
// giving a good chance of getting back results for any responsive adapters.
constexpr int kMaxConcurrentDhcpLookupTasks = 12;
// How long to wait at maximum after we get results (a PAC file or
// knowledge that no PAC file is configured) from whichever network
// adapter finishes first.
constexpr base::TimeDelta kMaxWaitAfterFirstResult =
base::TimeDelta::FromMilliseconds(400);
// A TaskRunner that never schedules more than |kMaxConcurrentDhcpLookupTasks|
// tasks concurrently.
class TaskRunnerWithCap : public base::TaskRunner {
public:
TaskRunnerWithCap() = default;
bool PostDelayedTask(const base::Location& from_here,
base::OnceClosure task,
base::TimeDelta delay) override {
// Delayed tasks are not supported.
DCHECK(delay.is_zero());
// Wrap the task in a callback that runs |task|, then tries to schedule a
// task from |pending_tasks_|.
base::OnceClosure wrapped_task =
base::BindOnce(&TaskRunnerWithCap::RunTaskAndSchedulePendingTask, this,
std::move(task));
{
base::AutoLock auto_lock(lock_);
// If |kMaxConcurrentDhcpLookupTasks| tasks are scheduled, move the task
// to |pending_tasks_|.
DCHECK_LE(num_scheduled_tasks_, kMaxConcurrentDhcpLookupTasks);
if (num_scheduled_tasks_ == kMaxConcurrentDhcpLookupTasks) {
pending_tasks_.emplace(from_here, std::move(wrapped_task));
return true;
}
// If less than |kMaxConcurrentDhcpLookupTasks| tasks are scheduled,
// increment |num_scheduled_tasks_| and schedule the task.
++num_scheduled_tasks_;
}
task_runner_->PostTask(from_here, std::move(wrapped_task));
return true;
}
bool RunsTasksInCurrentSequence() const override {
return task_runner_->RunsTasksInCurrentSequence();
}
private:
struct LocationAndTask {
LocationAndTask() = default;
LocationAndTask(const base::Location& from_here, base::OnceClosure task)
: from_here(from_here), task(std::move(task)) {}
base::Location from_here;
base::OnceClosure task;
};
~TaskRunnerWithCap() override = default;
void RunTaskAndSchedulePendingTask(base::OnceClosure task) {
// Run |task|.
std::move(task).Run();
// If |pending_tasks_| is non-empty, schedule a task from it. Otherwise,
// decrement |num_scheduled_tasks_|.
LocationAndTask task_to_schedule;
{
base::AutoLock auto_lock(lock_);
DCHECK_GT(num_scheduled_tasks_, 0);
if (pending_tasks_.empty()) {
--num_scheduled_tasks_;
return;
}
task_to_schedule = std::move(pending_tasks_.front());
pending_tasks_.pop();
}
DCHECK(task_to_schedule.task);
task_runner_->PostTask(task_to_schedule.from_here,
std::move(task_to_schedule.task));
}
const scoped_refptr<base::TaskRunner> task_runner_ =
base::CreateTaskRunnerWithTraits(
{base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN,
base::TaskPriority::USER_VISIBLE});
// Synchronizes access to members below.
base::Lock lock_;
// Number of tasks that are currently scheduled.
int num_scheduled_tasks_ = 0;
// Tasks that are waiting to be scheduled.
base::queue<LocationAndTask> pending_tasks_;
DISALLOW_COPY_AND_ASSIGN(TaskRunnerWithCap);
};
base::Value NetLogGetAdaptersDoneParams(DhcpAdapterNamesLoggingInfo* info) {
base::Value result(base::Value::Type::DICTIONARY);
// Add information on each of the adapters enumerated (including those that
// were subsequently skipped).
base::Value adapters_value(base::Value::Type::LIST);
for (IP_ADAPTER_ADDRESSES* adapter = info->adapters.get(); adapter;
adapter = adapter->Next) {
base::Value adapter_value(base::Value::Type::DICTIONARY);
adapter_value.SetStringKey("AdapterName", adapter->AdapterName);
adapter_value.SetIntKey("IfType", adapter->IfType);
adapter_value.SetIntKey("Flags", adapter->Flags);
adapter_value.SetIntKey("OperStatus", adapter->OperStatus);
adapter_value.SetIntKey("TunnelType", adapter->TunnelType);
// "skipped" means the adapter was not ultimately chosen as a candidate for
// testing WPAD.
bool skipped = !IsDhcpCapableAdapter(adapter);
adapter_value.SetKey("skipped", base::Value(skipped));
adapters_value.GetList().push_back(std::move(adapter_value));
}
result.SetKey("adapters", std::move(adapters_value));
result.SetIntKey(
"origin_to_worker_thread_hop_dt",
(info->worker_thread_start_time - info->origin_thread_start_time)
.InMilliseconds());
result.SetIntKey("worker_to_origin_thread_hop_dt",
(info->origin_thread_end_time - info->worker_thread_end_time)
.InMilliseconds());
result.SetIntKey("worker_dt", (info->worker_thread_end_time -
info->worker_thread_start_time)
.InMilliseconds());
if (info->error != ERROR_SUCCESS)
result.SetIntKey("error", info->error);
return result;
}
base::Value NetLogFetcherDoneParams(int fetcher_index, int net_error) {
base::Value result(base::Value::Type::DICTIONARY);
result.SetIntKey("fetcher_index", fetcher_index);
result.SetIntKey("net_error", net_error);
return result;
}
} // namespace
DhcpPacFileFetcherWin::DhcpPacFileFetcherWin(
URLRequestContext* url_request_context)
: state_(STATE_START),
num_pending_fetchers_(0),
destination_string_(nullptr),
url_request_context_(url_request_context),
task_runner_(base::MakeRefCounted<TaskRunnerWithCap>()) {
DCHECK(url_request_context_);
}
DhcpPacFileFetcherWin::~DhcpPacFileFetcherWin() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Count as user-initiated if we are not yet in STATE_DONE.
Cancel();
}
int DhcpPacFileFetcherWin::Fetch(
base::string16* utf16_text,
CompletionOnceCallback callback,
const NetLogWithSource& net_log,
const NetworkTrafficAnnotationTag traffic_annotation) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (state_ != STATE_START && state_ != STATE_DONE) {
NOTREACHED();
return ERR_UNEXPECTED;
}
net_log_ = net_log;
if (!url_request_context_)
return ERR_CONTEXT_SHUT_DOWN;
state_ = STATE_WAIT_ADAPTERS;
callback_ = std::move(callback);
destination_string_ = utf16_text;
net_log.BeginEvent(NetLogEventType::WPAD_DHCP_WIN_FETCH);
// TODO(eroman): This event is not ended in the case of cancellation.
net_log.BeginEvent(NetLogEventType::WPAD_DHCP_WIN_GET_ADAPTERS);
last_query_ = ImplCreateAdapterQuery();
last_query_->logging_info()->origin_thread_start_time =
base::TimeTicks::Now();
task_runner_->PostTaskAndReply(
FROM_HERE,
base::Bind(&DhcpPacFileFetcherWin::AdapterQuery::GetCandidateAdapterNames,
last_query_.get()),
base::Bind(&DhcpPacFileFetcherWin::OnGetCandidateAdapterNamesDone,
AsWeakPtr(), last_query_, traffic_annotation));
return ERR_IO_PENDING;
}
void DhcpPacFileFetcherWin::Cancel() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
CancelImpl();
}
void DhcpPacFileFetcherWin::OnShutdown() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Cancel current request, if there is one.
CancelImpl();
// Prevent future network requests.
url_request_context_ = nullptr;
}
void DhcpPacFileFetcherWin::CancelImpl() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (state_ != STATE_DONE) {
callback_.Reset();
wait_timer_.Stop();
state_ = STATE_DONE;
for (FetcherVector::iterator it = fetchers_.begin();
it != fetchers_.end();
++it) {
(*it)->Cancel();
}
fetchers_.clear();
}
}
void DhcpPacFileFetcherWin::OnGetCandidateAdapterNamesDone(
scoped_refptr<AdapterQuery> query,
const NetworkTrafficAnnotationTag traffic_annotation) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// This can happen if this object is reused for multiple queries,
// and a previous query was cancelled before it completed.
if (query.get() != last_query_.get())
return;
last_query_ = nullptr;
DhcpAdapterNamesLoggingInfo* logging_info = query->logging_info();
logging_info->origin_thread_end_time = base::TimeTicks::Now();
net_log_.EndEvent(NetLogEventType::WPAD_DHCP_WIN_GET_ADAPTERS,
[&] { return NetLogGetAdaptersDoneParams(logging_info); });
// Enable unit tests to wait for this to happen; in production this function
// call is a no-op.
ImplOnGetCandidateAdapterNamesDone();
// We may have been cancelled.
if (state_ != STATE_WAIT_ADAPTERS)
return;
state_ = STATE_NO_RESULTS;
const std::set<std::string>& adapter_names = query->adapter_names();
if (adapter_names.empty()) {
TransitionToDone();
return;
}
for (const std::string& adapter_name : adapter_names) {
std::unique_ptr<DhcpPacFileAdapterFetcher> fetcher(
ImplCreateAdapterFetcher());
size_t fetcher_index = fetchers_.size();
fetcher->Fetch(adapter_name,
base::Bind(&DhcpPacFileFetcherWin::OnFetcherDone,
base::Unretained(this), fetcher_index),
traffic_annotation);
fetchers_.push_back(std::move(fetcher));
}
num_pending_fetchers_ = fetchers_.size();
}
std::string DhcpPacFileFetcherWin::GetFetcherName() const {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return "win";
}
const GURL& DhcpPacFileFetcherWin::GetPacURL() const {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK_EQ(state_, STATE_DONE);
return pac_url_;
}
void DhcpPacFileFetcherWin::OnFetcherDone(size_t fetcher_index,
int result) {
DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS);
net_log_.AddEvent(NetLogEventType::WPAD_DHCP_WIN_ON_FETCHER_DONE, [&] {
return NetLogFetcherDoneParams(fetcher_index, result);
});
if (--num_pending_fetchers_ == 0) {
TransitionToDone();
return;
}
// If the only pending adapters are those less preferred than one
// with a valid PAC script, we do not need to wait any longer.
for (FetcherVector::iterator it = fetchers_.begin();
it != fetchers_.end();
++it) {
bool did_finish = (*it)->DidFinish();
int result = (*it)->GetResult();
if (did_finish && result == OK) {
TransitionToDone();
return;
}
if (!did_finish || result != ERR_PAC_NOT_IN_DHCP) {
break;
}
}
// Once we have a single result, we set a maximum on how long to wait
// for the rest of the results.
if (state_ == STATE_NO_RESULTS) {
state_ = STATE_SOME_RESULTS;
net_log_.AddEvent(NetLogEventType::WPAD_DHCP_WIN_START_WAIT_TIMER);
wait_timer_.Start(FROM_HERE,
ImplGetMaxWait(), this, &DhcpPacFileFetcherWin::OnWaitTimer);
}
}
void DhcpPacFileFetcherWin::OnWaitTimer() {
DCHECK_EQ(state_, STATE_SOME_RESULTS);
net_log_.AddEvent(NetLogEventType::WPAD_DHCP_WIN_ON_WAIT_TIMER);
TransitionToDone();
}
void DhcpPacFileFetcherWin::TransitionToDone() {
DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS);
int used_fetcher_index = -1;
int result = ERR_PAC_NOT_IN_DHCP; // Default if no fetchers.
if (!fetchers_.empty()) {
// Scan twice for the result; once through the whole list for success,
// then if no success, return result for most preferred network adapter,
// preferring "real" network errors to the ERR_PAC_NOT_IN_DHCP error.
// Default to ERR_ABORTED if no fetcher completed.
result = ERR_ABORTED;
for (size_t i = 0; i < fetchers_.size(); ++i) {
const auto& fetcher = fetchers_[i];
if (fetcher->DidFinish() && fetcher->GetResult() == OK) {
result = OK;
*destination_string_ = fetcher->GetPacScript();
pac_url_ = fetcher->GetPacURL();
used_fetcher_index = i;
break;
}
}
if (result != OK) {
destination_string_->clear();
for (size_t i = 0; i < fetchers_.size(); ++i) {
const auto& fetcher = fetchers_[i];
if (fetcher->DidFinish()) {
result = fetcher->GetResult();
used_fetcher_index = i;
if (result != ERR_PAC_NOT_IN_DHCP) {
break;
}
}
}
}
}
CompletionOnceCallback callback = std::move(callback_);
CancelImpl();
DCHECK_EQ(state_, STATE_DONE);
DCHECK(fetchers_.empty());
net_log_.EndEvent(NetLogEventType::WPAD_DHCP_WIN_FETCH, [&] {
return NetLogFetcherDoneParams(used_fetcher_index, result);
});
// We may be deleted re-entrantly within this outcall.
std::move(callback).Run(result);
}
int DhcpPacFileFetcherWin::num_pending_fetchers() const {
return num_pending_fetchers_;
}
URLRequestContext* DhcpPacFileFetcherWin::url_request_context() const {
return url_request_context_;
}
scoped_refptr<base::TaskRunner> DhcpPacFileFetcherWin::GetTaskRunner() {
return task_runner_;
}
DhcpPacFileAdapterFetcher* DhcpPacFileFetcherWin::ImplCreateAdapterFetcher() {
return new DhcpPacFileAdapterFetcher(url_request_context_, task_runner_);
}
DhcpPacFileFetcherWin::AdapterQuery*
DhcpPacFileFetcherWin::ImplCreateAdapterQuery() {
return new AdapterQuery();
}
base::TimeDelta DhcpPacFileFetcherWin::ImplGetMaxWait() {
return kMaxWaitAfterFirstResult;
}
bool DhcpPacFileFetcherWin::GetCandidateAdapterNames(
std::set<std::string>* adapter_names,
DhcpAdapterNamesLoggingInfo* info) {
DCHECK(adapter_names);
adapter_names->clear();
// The GetAdaptersAddresses MSDN page recommends using a size of 15000 to
// avoid reallocation.
ULONG adapters_size = 15000;
std::unique_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> adapters;
ULONG error = ERROR_SUCCESS;
int num_tries = 0;
do {
adapters.reset(static_cast<IP_ADAPTER_ADDRESSES*>(malloc(adapters_size)));
// Return only unicast addresses, and skip information we do not need.
base::ScopedBlockingCall scoped_blocking_call(
FROM_HERE, base::BlockingType::MAY_BLOCK);
error = GetAdaptersAddresses(
AF_UNSPEC,
GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME,
nullptr, adapters.get(), &adapters_size);
++num_tries;
} while (error == ERROR_BUFFER_OVERFLOW && num_tries <= 3);
if (info)
info->error = error;
if (error == ERROR_NO_DATA) {
// There are no adapters that we care about.
return true;
}
if (error != ERROR_SUCCESS) {
LOG(WARNING) << "Unexpected error retrieving WPAD configuration from DHCP.";
return false;
}
IP_ADAPTER_ADDRESSES* adapter = nullptr;
for (adapter = adapters.get(); adapter; adapter = adapter->Next) {
if (IsDhcpCapableAdapter(adapter)) {
DCHECK(adapter->AdapterName);
adapter_names->insert(adapter->AdapterName);
}
}
// Transfer the buffer containing the adapters, so it can be used later for
// emitting NetLog parameters from the origin thread.
if (info)
info->adapters = std::move(adapters);
return true;
}
DhcpPacFileFetcherWin::AdapterQuery::AdapterQuery()
: logging_info_(new DhcpAdapterNamesLoggingInfo()) {}
void DhcpPacFileFetcherWin::AdapterQuery::GetCandidateAdapterNames() {
logging_info_->error = ERROR_NO_DATA;
logging_info_->adapters.reset();
logging_info_->worker_thread_start_time = base::TimeTicks::Now();
ImplGetCandidateAdapterNames(&adapter_names_, logging_info_.get());
logging_info_->worker_thread_end_time = base::TimeTicks::Now();
}
const std::set<std::string>&
DhcpPacFileFetcherWin::AdapterQuery::adapter_names() const {
return adapter_names_;
}
bool DhcpPacFileFetcherWin::AdapterQuery::ImplGetCandidateAdapterNames(
std::set<std::string>* adapter_names,
DhcpAdapterNamesLoggingInfo* info) {
return DhcpPacFileFetcherWin::GetCandidateAdapterNames(adapter_names,
info);
}
DhcpPacFileFetcherWin::AdapterQuery::~AdapterQuery() {}
} // namespace net