blob: cdad9144ab414c91742ca251d59cb5bae6a78dd2 [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/dns/host_resolver_impl.h"
#if defined(OS_WIN)
#include <Winsock2.h>
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
#include <netdb.h>
#include <netinet/in.h>
#if !defined(OS_NACL)
#include <net/if.h>
#if !defined(OS_ANDROID)
#include <ifaddrs.h>
#endif // !defined(OS_ANDROID)
#endif // !defined(OS_NACL)
#endif // defined(OS_WIN)
#include <algorithm>
#include <cmath>
#include <limits>
#include <memory>
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback.h"
#include "base/callback_helpers.h"
#include "base/compiler_specific.h"
#include "base/containers/linked_list.h"
#include "base/debug/debugger.h"
#include "base/debug/stack_trace.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/field_trial.h"
#include "base/metrics/field_trial_params.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/post_task.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/default_tick_clock.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "base/values.h"
#include "build/build_config.h"
#include "net/base/address_family.h"
#include "net/base/address_list.h"
#include "net/base/host_port_pair.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/base/trace_constants.h"
#include "net/base/url_util.h"
#include "net/dns/address_sorter.h"
#include "net/dns/dns_client.h"
#include "net/dns/dns_protocol.h"
#include "net/dns/dns_reloader.h"
#include "net/dns/dns_response.h"
#include "net/dns/dns_transaction.h"
#include "net/dns/dns_util.h"
#include "net/dns/host_resolver_mdns_task.h"
#include "net/dns/host_resolver_proc.h"
#include "net/dns/mdns_client.h"
#include "net/log/net_log.h"
#include "net/log/net_log_capture_mode.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_parameters_callback.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_source_type.h"
#include "net/log/net_log_with_source.h"
#include "net/socket/client_socket_factory.h"
#include "net/socket/datagram_client_socket.h"
#include "url/url_canon_ip.h"
#if BUILDFLAG(ENABLE_MDNS)
#include "net/dns/mdns_client_impl.h"
#endif
#if defined(OS_WIN)
#include "net/base/winsock_init.h"
#endif
#if defined(OS_ANDROID)
#include "net/android/network_library.h"
#endif
namespace net {
namespace {
// Default delay between calls to the system resolver for the same hostname.
// (Can be overridden by field trial.)
const int64_t kDnsDefaultUnresponsiveDelayMs = 6000;
// Limit the size of hostnames that will be resolved to combat issues in
// some platform's resolvers.
const size_t kMaxHostLength = 4096;
// Default TTL for successful resolutions with ProcTask.
const unsigned kCacheEntryTTLSeconds = 60;
// Default TTL for unsuccessful resolutions with ProcTask.
const unsigned kNegativeCacheEntryTTLSeconds = 0;
// Minimum TTL for successful resolutions with DnsTask.
const unsigned kMinimumTTLSeconds = kCacheEntryTTLSeconds;
// Time between IPv6 probes, i.e. for how long results of each IPv6 probe are
// cached.
const int kIPv6ProbePeriodMs = 1000;
// Google DNS address used for IPv6 probes.
const uint8_t kIPv6ProbeAddress[] =
{ 0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88 };
// We use a separate histogram name for each platform to facilitate the
// display of error codes by their symbolic name (since each platform has
// different mappings).
const char kOSErrorsForGetAddrinfoHistogramName[] =
#if defined(OS_WIN)
"Net.OSErrorsForGetAddrinfo_Win";
#elif defined(OS_MACOSX)
"Net.OSErrorsForGetAddrinfo_Mac";
#elif defined(OS_LINUX)
"Net.OSErrorsForGetAddrinfo_Linux";
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
"Net.OSErrorsForGetAddrinfo";
#endif
// Gets a list of the likely error codes that getaddrinfo() can return
// (non-exhaustive). These are the error codes that we will track via
// a histogram.
std::vector<int> GetAllGetAddrinfoOSErrors() {
int os_errors[] = {
#if defined(OS_WIN)
// See: http://msdn.microsoft.com/en-us/library/ms738520(VS.85).aspx
WSA_NOT_ENOUGH_MEMORY,
WSAEAFNOSUPPORT,
WSAEINVAL,
WSAESOCKTNOSUPPORT,
WSAHOST_NOT_FOUND,
WSANO_DATA,
WSANO_RECOVERY,
WSANOTINITIALISED,
WSATRY_AGAIN,
WSATYPE_NOT_FOUND,
// The following are not in doc, but might be to appearing in results :-(.
WSA_INVALID_HANDLE,
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
#if !defined(OS_FREEBSD)
#if !defined(OS_ANDROID)
// EAI_ADDRFAMILY has been declared obsolete in Android's and
// FreeBSD's netdb.h.
EAI_ADDRFAMILY,
#endif
// EAI_NODATA has been declared obsolete in FreeBSD's netdb.h.
EAI_NODATA,
#endif
EAI_AGAIN,
EAI_BADFLAGS,
EAI_FAIL,
EAI_FAMILY,
EAI_MEMORY,
EAI_NONAME,
EAI_SERVICE,
EAI_SOCKTYPE,
EAI_SYSTEM,
#endif
};
// Ensure all errors are positive, as histogram only tracks positive values.
for (size_t i = 0; i < arraysize(os_errors); ++i) {
os_errors[i] = std::abs(os_errors[i]);
}
return base::CustomHistogram::ArrayToCustomEnumRanges(os_errors);
}
enum DnsResolveStatus {
RESOLVE_STATUS_DNS_SUCCESS = 0,
RESOLVE_STATUS_PROC_SUCCESS,
RESOLVE_STATUS_FAIL,
RESOLVE_STATUS_SUSPECT_NETBIOS,
RESOLVE_STATUS_MAX
};
// ICANN uses this localhost address to indicate a name collision.
//
// The policy in Chromium is to fail host resolving if it resolves to
// this special address.
//
// Not however that IP literals are exempt from this policy, so it is still
// possible to navigate to http://127.0.53.53/ directly.
//
// For more details: https://www.icann.org/news/announcement-2-2014-08-01-en
const uint8_t kIcanNameCollisionIp[] = {127, 0, 53, 53};
bool ContainsIcannNameCollisionIp(const AddressList& addr_list) {
for (const auto& endpoint : addr_list) {
const IPAddress& addr = endpoint.address();
if (addr.IsIPv4() && IPAddressStartsWith(addr, kIcanNameCollisionIp)) {
return true;
}
}
return false;
}
void UmaAsyncDnsResolveStatus(DnsResolveStatus result) {
UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ResolveStatus",
result,
RESOLVE_STATUS_MAX);
}
bool ResemblesNetBIOSName(const std::string& hostname) {
return (hostname.size() < 16) && (hostname.find('.') == std::string::npos);
}
// True if |hostname| ends with either ".local" or ".local.".
bool ResemblesMulticastDNSName(const std::string& hostname) {
DCHECK(!hostname.empty());
const char kSuffix[] = ".local.";
const size_t kSuffixLen = sizeof(kSuffix) - 1;
const size_t kSuffixLenTrimmed = kSuffixLen - 1;
if (hostname.back() == '.') {
return hostname.size() > kSuffixLen &&
!hostname.compare(hostname.size() - kSuffixLen, kSuffixLen, kSuffix);
}
return hostname.size() > kSuffixLenTrimmed &&
!hostname.compare(hostname.size() - kSuffixLenTrimmed, kSuffixLenTrimmed,
kSuffix, kSuffixLenTrimmed);
}
// A macro to simplify code and readability.
#define DNS_HISTOGRAM_BY_PRIORITY(basename, priority, time) \
do { \
switch (priority) { \
case HIGHEST: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".HIGHEST", time); \
break; \
case MEDIUM: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".MEDIUM", time); \
break; \
case LOW: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".LOW", time); \
break; \
case LOWEST: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".LOWEST", time); \
break; \
case IDLE: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".IDLE", time); \
break; \
case THROTTLED: \
UMA_HISTOGRAM_LONG_TIMES_100(basename ".THROTTLED", time); \
break; \
} \
UMA_HISTOGRAM_LONG_TIMES_100(basename, time); \
} while (0)
// Record time from Request creation until a valid DNS response.
void RecordTotalTime(bool speculative,
bool from_cache,
base::TimeDelta duration) {
if (!speculative) {
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.TotalTime", duration);
if (!from_cache)
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.TotalTimeNotCached", duration);
}
}
void RecordTTL(base::TimeDelta ttl) {
UMA_HISTOGRAM_CUSTOM_TIMES("AsyncDNS.TTL", ttl,
base::TimeDelta::FromSeconds(1),
base::TimeDelta::FromDays(1), 100);
}
bool ConfigureAsyncDnsNoFallbackFieldTrial() {
const bool kDefault = false;
// Configure the AsyncDns field trial as follows:
// groups AsyncDnsNoFallbackA and AsyncDnsNoFallbackB: return true,
// groups AsyncDnsA and AsyncDnsB: return false,
// groups SystemDnsA and SystemDnsB: return false,
// otherwise (trial absent): return default.
std::string group_name = base::FieldTrialList::FindFullName("AsyncDns");
if (!group_name.empty()) {
return base::StartsWith(group_name, "AsyncDnsNoFallback",
base::CompareCase::INSENSITIVE_ASCII);
}
return kDefault;
}
const base::FeatureParam<base::TaskPriority>::Option prio_modes[] = {
{base::TaskPriority::USER_VISIBLE, "default"},
{base::TaskPriority::USER_BLOCKING, "user_blocking"}};
const base::Feature kSystemResolverPriorityExperiment = {
"SystemResolverPriorityExperiment", base::FEATURE_DISABLED_BY_DEFAULT};
const base::FeatureParam<base::TaskPriority> priority_mode{
&kSystemResolverPriorityExperiment, "mode",
base::TaskPriority::USER_VISIBLE, &prio_modes};
//-----------------------------------------------------------------------------
AddressList EnsurePortOnAddressList(const AddressList& list, uint16_t port) {
if (list.empty() || list.front().port() == port)
return list;
return AddressList::CopyWithPort(list, port);
}
// Returns true if |addresses| contains only IPv4 loopback addresses.
bool IsAllIPv4Loopback(const AddressList& addresses) {
for (unsigned i = 0; i < addresses.size(); ++i) {
const IPAddress& address = addresses[i].address();
switch (addresses[i].GetFamily()) {
case ADDRESS_FAMILY_IPV4:
if (address.bytes()[0] != 127)
return false;
break;
case ADDRESS_FAMILY_IPV6:
return false;
default:
NOTREACHED();
return false;
}
}
return true;
}
// Returns true if it can determine that only loopback addresses are configured.
// i.e. if only 127.0.0.1 and ::1 are routable.
// Also returns false if it cannot determine this.
bool HaveOnlyLoopbackAddresses() {
base::ScopedBlockingCall scoped_blocking_call(base::BlockingType::WILL_BLOCK);
#if defined(OS_WIN)
// TODO(wtc): implement with the GetAdaptersAddresses function.
NOTIMPLEMENTED();
return false;
#elif defined(OS_ANDROID)
return android::HaveOnlyLoopbackAddresses();
#elif defined(OS_NACL)
NOTIMPLEMENTED();
return false;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
struct ifaddrs* interface_addr = NULL;
int rv = getifaddrs(&interface_addr);
if (rv != 0) {
DVLOG(1) << "getifaddrs() failed with errno = " << errno;
return false;
}
bool result = true;
for (struct ifaddrs* interface = interface_addr;
interface != NULL;
interface = interface->ifa_next) {
if (!(IFF_UP & interface->ifa_flags))
continue;
if (IFF_LOOPBACK & interface->ifa_flags)
continue;
const struct sockaddr* addr = interface->ifa_addr;
if (!addr)
continue;
if (addr->sa_family == AF_INET6) {
// Safe cast since this is AF_INET6.
const struct sockaddr_in6* addr_in6 =
reinterpret_cast<const struct sockaddr_in6*>(addr);
const struct in6_addr* sin6_addr = &addr_in6->sin6_addr;
if (IN6_IS_ADDR_LOOPBACK(sin6_addr) || IN6_IS_ADDR_LINKLOCAL(sin6_addr))
continue;
}
if (addr->sa_family != AF_INET6 && addr->sa_family != AF_INET)
continue;
result = false;
break;
}
freeifaddrs(interface_addr);
return result;
#endif // defined(various platforms)
}
// Creates NetLog parameters when the resolve failed.
std::unique_ptr<base::Value> NetLogProcTaskFailedCallback(
uint32_t attempt_number,
int net_error,
int os_error,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
if (attempt_number)
dict->SetInteger("attempt_number", attempt_number);
dict->SetInteger("net_error", net_error);
if (os_error) {
dict->SetInteger("os_error", os_error);
#if defined(OS_WIN)
// Map the error code to a human-readable string.
LPWSTR error_string = nullptr;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
0, // Use the internal message table.
os_error,
0, // Use default language.
(LPWSTR)&error_string,
0, // Buffer size.
0); // Arguments (unused).
dict->SetString("os_error_string", base::WideToUTF8(error_string));
LocalFree(error_string);
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
dict->SetString("os_error_string", gai_strerror(os_error));
#endif
}
return std::move(dict);
}
// Creates NetLog parameters when the DnsTask failed.
std::unique_ptr<base::Value> NetLogDnsTaskFailedCallback(
int net_error,
int dns_error,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("net_error", net_error);
if (dns_error)
dict->SetInteger("dns_error", dns_error);
return std::move(dict);
}
// Creates NetLog parameters containing the information in a RequestInfo object,
// along with the associated NetLogSource. Use NetLogRequestCallback() if the
// request information is not specified via RequestInfo.
std::unique_ptr<base::Value> NetLogRequestInfoCallback(
const HostResolver::RequestInfo* info,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("host", info->host_port_pair().ToString());
dict->SetInteger("address_family",
static_cast<int>(info->address_family()));
dict->SetBoolean("allow_cached_response", info->allow_cached_response());
dict->SetBoolean("is_speculative", info->is_speculative());
return std::move(dict);
}
// Creates NetLog parameters containing the information of the request. Use
// NetLogRequestInfoCallback if the request is specified via RequestInfo.
std::unique_ptr<base::Value> NetLogRequestCallback(
const HostPortPair& host,
NetLogCaptureMode /* capture_mode */) {
auto dict = std::make_unique<base::DictionaryValue>();
dict->SetString("host", host.ToString());
dict->SetInteger("address_family",
static_cast<int>(ADDRESS_FAMILY_UNSPECIFIED));
dict->SetBoolean("allow_cached_response", true);
dict->SetBoolean("is_speculative", false);
return std::move(dict);
}
// Creates NetLog parameters for the creation of a HostResolverImpl::Job.
std::unique_ptr<base::Value> NetLogJobCreationCallback(
const NetLogSource& source,
const std::string* host,
NetLogCaptureMode /* capture_mode */) {
auto dict = std::make_unique<base::DictionaryValue>();
source.AddToEventParameters(dict.get());
dict->SetString("host", *host);
return std::move(dict);
}
// Creates NetLog parameters for HOST_RESOLVER_IMPL_JOB_ATTACH/DETACH events.
std::unique_ptr<base::Value> NetLogJobAttachCallback(
const NetLogSource& source,
RequestPriority priority,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
source.AddToEventParameters(dict.get());
dict->SetString("priority", RequestPriorityToString(priority));
return std::move(dict);
}
// Creates NetLog parameters for the DNS_CONFIG_CHANGED event.
std::unique_ptr<base::Value> NetLogDnsConfigCallback(
const DnsConfig* config,
NetLogCaptureMode /* capture_mode */) {
return config->ToValue();
}
std::unique_ptr<base::Value> NetLogIPv6AvailableCallback(
bool ipv6_available,
bool cached,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetBoolean("ipv6_available", ipv6_available);
dict->SetBoolean("cached", cached);
return std::move(dict);
}
// The logging routines are defined here because some requests are resolved
// without a Request object.
// Logs when a request has just been started. Overloads for whether or not the
// request information is specified via a RequestInfo object.
void LogStartRequest(const NetLogWithSource& source_net_log,
const HostResolver::RequestInfo& info) {
source_net_log.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_REQUEST,
base::Bind(&NetLogRequestInfoCallback, &info));
}
void LogStartRequest(const NetLogWithSource& source_net_log,
const HostPortPair& host) {
source_net_log.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_REQUEST,
base::BindRepeating(&NetLogRequestCallback, host));
}
// Logs when a request has just completed (before its callback is run).
void LogFinishRequest(const NetLogWithSource& source_net_log, int net_error) {
source_net_log.EndEventWithNetErrorCode(
NetLogEventType::HOST_RESOLVER_IMPL_REQUEST, net_error);
}
// Logs when a request has been cancelled.
void LogCancelRequest(const NetLogWithSource& source_net_log) {
source_net_log.AddEvent(NetLogEventType::CANCELLED);
source_net_log.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_REQUEST);
}
//-----------------------------------------------------------------------------
// Keeps track of the highest priority.
class PriorityTracker {
public:
explicit PriorityTracker(RequestPriority initial_priority)
: highest_priority_(initial_priority), total_count_(0) {
memset(counts_, 0, sizeof(counts_));
}
RequestPriority highest_priority() const {
return highest_priority_;
}
size_t total_count() const {
return total_count_;
}
void Add(RequestPriority req_priority) {
++total_count_;
++counts_[req_priority];
if (highest_priority_ < req_priority)
highest_priority_ = req_priority;
}
void Remove(RequestPriority req_priority) {
DCHECK_GT(total_count_, 0u);
DCHECK_GT(counts_[req_priority], 0u);
--total_count_;
--counts_[req_priority];
size_t i;
for (i = highest_priority_; i > MINIMUM_PRIORITY && !counts_[i]; --i) {
}
highest_priority_ = static_cast<RequestPriority>(i);
// In absence of requests, default to MINIMUM_PRIORITY.
if (total_count_ == 0)
DCHECK_EQ(MINIMUM_PRIORITY, highest_priority_);
}
private:
RequestPriority highest_priority_;
size_t total_count_;
size_t counts_[NUM_PRIORITIES];
};
void MakeNotStale(HostCache::EntryStaleness* stale_info) {
if (!stale_info)
return;
stale_info->expired_by = base::TimeDelta::FromSeconds(-1);
stale_info->network_changes = 0;
stale_info->stale_hits = 0;
}
} // namespace
//-----------------------------------------------------------------------------
bool ResolveLocalHostname(base::StringPiece host,
uint16_t port,
AddressList* address_list) {
address_list->clear();
bool is_local6;
if (!IsLocalHostname(host, &is_local6))
return false;
address_list->push_back(IPEndPoint(IPAddress::IPv6Localhost(), port));
if (!is_local6) {
address_list->push_back(IPEndPoint(IPAddress::IPv4Localhost(), port));
}
return true;
}
const unsigned HostResolverImpl::kMaximumDnsFailures = 16;
// Holds the callback and request parameters for an outstanding request.
//
// The RequestImpl is owned by the end user of host resolution. Deletion prior
// to the request having completed means the request was cancelled by the
// caller.
//
// Both the RequestImpl and its associated Job hold non-owning pointers to each
// other. Care must be taken to clear the corresponding pointer when
// cancellation is initiated by the Job (OnJobCancelled) vs by the end user
// (~RequestImpl).
class HostResolverImpl::RequestImpl
: public HostResolver::ResolveHostRequest,
public base::LinkNode<HostResolverImpl::RequestImpl> {
public:
RequestImpl(const NetLogWithSource& source_net_log,
const HostPortPair& request_host,
const base::Optional<ResolveHostParameters>& optional_parameters,
base::WeakPtr<HostResolverImpl> resolver)
: source_net_log_(source_net_log),
request_host_(request_host),
parameters_(optional_parameters ? optional_parameters.value()
: ResolveHostParameters()),
host_resolver_flags_(ParametersToHostResolverFlags(parameters_)),
priority_(parameters_.initial_priority),
job_(nullptr),
resolver_(resolver),
complete_(false) {}
~RequestImpl() override;
int Start(CompletionOnceCallback callback) override {
DCHECK(callback);
// Start() may only be called once per request.
DCHECK(!job_);
DCHECK(!complete_);
DCHECK(!callback_);
// Parent HostResolver must still be alive to call Start().
DCHECK(resolver_);
int rv = resolver_->Resolve(this);
DCHECK(!complete_);
if (rv == ERR_IO_PENDING) {
DCHECK(job_);
callback_ = std::move(callback);
} else {
DCHECK(!job_);
complete_ = true;
}
resolver_ = nullptr;
return rv;
}
const base::Optional<AddressList>& GetAddressResults() const override {
DCHECK(complete_);
return address_results_;
}
void set_address_results(const AddressList& address_results) {
// Should only be called at most once and before request is marked
// completed.
DCHECK(!complete_);
DCHECK(!address_results_);
DCHECK(!parameters_.is_speculative);
address_results_ = address_results;
}
void ChangeRequestPriority(RequestPriority priority);
void AssignJob(Job* job) {
DCHECK(job);
DCHECK(!job_);
job_ = job;
}
// Unassigns the Job without calling completion callback.
void OnJobCancelled(Job* job) {
DCHECK_EQ(job_, job);
job_ = nullptr;
DCHECK(!complete_);
DCHECK(callback_);
callback_.Reset();
// No results should be set.
DCHECK(!address_results_);
}
// Cleans up Job assignment, marks request completed, and calls the completion
// callback.
void OnJobCompleted(Job* job, int error) {
DCHECK_EQ(job_, job);
job_ = nullptr;
DCHECK(!complete_);
complete_ = true;
DCHECK(callback_);
std::move(callback_).Run(error);
}
Job* job() const { return job_; }
// NetLog for the source, passed in HostResolver::Resolve.
const NetLogWithSource& source_net_log() { return source_net_log_; }
const HostPortPair& request_host() const { return request_host_; }
const ResolveHostParameters& parameters() const { return parameters_; }
HostResolverFlags host_resolver_flags() const { return host_resolver_flags_; }
RequestPriority priority() const { return priority_; }
void set_priority(RequestPriority priority) { priority_ = priority; }
bool complete() const { return complete_; }
base::TimeTicks request_time() const {
DCHECK(!request_time_.is_null());
return request_time_;
}
void set_request_time(base::TimeTicks request_time) {
DCHECK(request_time_.is_null());
DCHECK(!request_time.is_null());
request_time_ = request_time;
}
private:
const NetLogWithSource source_net_log_;
const HostPortPair request_host_;
const ResolveHostParameters parameters_;
const HostResolverFlags host_resolver_flags_;
RequestPriority priority_;
// The resolve job that this request is dependent on.
Job* job_;
base::WeakPtr<HostResolverImpl> resolver_;
// The user's callback to invoke when the request completes.
CompletionOnceCallback callback_;
bool complete_;
base::Optional<AddressList> address_results_;
base::TimeTicks request_time_;
DISALLOW_COPY_AND_ASSIGN(RequestImpl);
};
// Wraps a RequestImpl to implement Request objects from the legacy Resolve()
// API. The wrapped request must not yet have been started.
//
// TODO(crbug.com/821021): Delete this class once all usage has been
// converted to the new CreateRequest() API.
class HostResolverImpl::LegacyRequestImpl : public HostResolver::Request {
public:
explicit LegacyRequestImpl(std::unique_ptr<RequestImpl> inner_request)
: inner_request_(std::move(inner_request)) {
DCHECK(!inner_request_->job());
DCHECK(!inner_request_->complete());
}
~LegacyRequestImpl() override {}
void ChangeRequestPriority(RequestPriority priority) override {
inner_request_->ChangeRequestPriority(priority);
}
int Start() {
return inner_request_->Start(base::BindOnce(
&LegacyRequestImpl::LegacyApiCallback, base::Unretained(this)));
}
// Do not call to assign the callback until we are running an async job (after
// Start() returns ERR_IO_PENDING) and before completion. Until then, the
// legacy HostResolverImpl::Resolve() needs to hang onto |callback| to ensure
// it stays alive for the duration of the method call, as some callers may be
// binding objects, eg the AddressList, with the callback.
void AssignCallback(CompletionOnceCallback callback,
AddressList* addresses_result_ptr) {
DCHECK(callback);
DCHECK(addresses_result_ptr);
DCHECK(inner_request_->job());
DCHECK(!inner_request_->complete());
callback_ = std::move(callback);
addresses_result_ptr_ = addresses_result_ptr;
}
const RequestImpl& inner_request() const { return *inner_request_; }
private:
// Result callback to bridge results handled entirely via ResolveHostRequest
// to legacy API styles where AddressList was a separate method out parameter.
void LegacyApiCallback(int error) {
// Must call AssignCallback() before async results.
DCHECK(callback_);
if (error == OK && !inner_request_->parameters().is_speculative) {
// Legacy API does not allow non-address results (eg TXT), so AddressList
// is always expected to be present on OK.
DCHECK(inner_request_->GetAddressResults());
*addresses_result_ptr_ = inner_request_->GetAddressResults().value();
}
addresses_result_ptr_ = nullptr;
std::move(callback_).Run(error);
}
const std::unique_ptr<RequestImpl> inner_request_;
CompletionOnceCallback callback_;
// This is a caller-provided pointer and should not be used once |callback_|
// is invoked.
AddressList* addresses_result_ptr_;
DISALLOW_COPY_AND_ASSIGN(LegacyRequestImpl);
};
//------------------------------------------------------------------------------
// Calls HostResolverProc in TaskScheduler. Performs retries if necessary.
//
// In non-test code, the HostResolverProc is always SystemHostResolverProc,
// which calls a platform API that implements host resolution.
//
// Whenever we try to resolve the host, we post a delayed task to check if host
// resolution (OnLookupComplete) is completed or not. If the original attempt
// hasn't completed, then we start another attempt for host resolution. We take
// the results from the first attempt that finishes and ignore the results from
// all other attempts.
//
// TODO(szym): Move to separate source file for testing and mocking.
//
class HostResolverImpl::ProcTask {
public:
typedef base::OnceCallback<void(int net_error, const AddressList& addr_list)>
Callback;
ProcTask(const Key& key,
const ProcTaskParams& params,
Callback callback,
scoped_refptr<base::TaskRunner> proc_task_runner,
const NetLogWithSource& job_net_log,
const base::TickClock* tick_clock)
: key_(key),
params_(params),
callback_(std::move(callback)),
network_task_runner_(base::ThreadTaskRunnerHandle::Get()),
proc_task_runner_(std::move(proc_task_runner)),
attempt_number_(0),
net_log_(job_net_log),
tick_clock_(tick_clock),
weak_ptr_factory_(this) {
DCHECK(callback_);
if (!params_.resolver_proc.get())
params_.resolver_proc = HostResolverProc::GetDefault();
// If default is unset, use the system proc.
if (!params_.resolver_proc.get())
params_.resolver_proc = new SystemHostResolverProc();
}
// Cancels this ProcTask. Any outstanding resolve attempts running on worker
// thread will continue running, but they will post back to the network thread
// before checking their WeakPtrs to find that this task is cancelled.
~ProcTask() {
DCHECK(network_task_runner_->BelongsToCurrentThread());
// If this is cancellation, log the EndEvent (otherwise this was logged in
// OnLookupComplete()).
if (!was_completed())
net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK);
}
void Start() {
DCHECK(network_task_runner_->BelongsToCurrentThread());
DCHECK(!was_completed());
net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK);
StartLookupAttempt();
}
bool was_completed() const {
DCHECK(network_task_runner_->BelongsToCurrentThread());
return callback_.is_null();
}
private:
using AttemptCompletionCallback = base::OnceCallback<
void(const AddressList& results, int error, const int os_error)>;
void StartLookupAttempt() {
DCHECK(network_task_runner_->BelongsToCurrentThread());
DCHECK(!was_completed());
base::TimeTicks start_time = tick_clock_->NowTicks();
++attempt_number_;
// Dispatch the lookup attempt to a worker thread.
AttemptCompletionCallback completion_callback = base::BindOnce(
&ProcTask::OnLookupAttemptComplete, weak_ptr_factory_.GetWeakPtr(),
start_time, attempt_number_, tick_clock_);
proc_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&ProcTask::DoLookup, key_, params_.resolver_proc,
network_task_runner_, std::move(completion_callback)));
net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_ATTEMPT_STARTED,
NetLog::IntCallback("attempt_number", attempt_number_));
// If the results aren't received within a given time, RetryIfNotComplete
// will start a new attempt if none of the outstanding attempts have
// completed yet.
// Use a WeakPtr to avoid keeping the ProcTask alive after completion or
// cancellation.
if (attempt_number_ <= params_.max_retry_attempts) {
network_task_runner_->PostDelayedTask(
FROM_HERE,
base::BindOnce(&ProcTask::StartLookupAttempt,
weak_ptr_factory_.GetWeakPtr()),
params_.unresponsive_delay *
std::pow(params_.retry_factor, attempt_number_ - 1));
}
}
// WARNING: This code runs in TaskScheduler with CONTINUE_ON_SHUTDOWN. The
// shutdown code cannot wait for it to finish, so this code must be very
// careful about using other objects (like MessageLoops, Singletons, etc).
// During shutdown these objects may no longer exist.
static void DoLookup(
Key key,
scoped_refptr<HostResolverProc> resolver_proc,
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
AttemptCompletionCallback completion_callback) {
AddressList results;
int os_error = 0;
int error =
resolver_proc->Resolve(key.hostname, key.address_family,
key.host_resolver_flags, &results, &os_error);
network_task_runner->PostTask(
FROM_HERE, base::BindOnce(std::move(completion_callback), results,
error, os_error));
}
// Callback for when DoLookup() completes (runs on task runner thread). Now
// that we're back in the network thread, checks that |proc_task| is still
// valid, and if so, passes back to the object.
static void OnLookupAttemptComplete(base::WeakPtr<ProcTask> proc_task,
const base::TimeTicks& start_time,
const uint32_t attempt_number,
const base::TickClock* tick_clock,
const AddressList& results,
int error,
const int os_error) {
TRACE_EVENT0(kNetTracingCategory, "ProcTask::OnLookupComplete");
// If results are empty, we should return an error.
bool empty_list_on_ok = (error == OK && results.empty());
if (empty_list_on_ok)
error = ERR_NAME_NOT_RESOLVED;
// Ideally the following code would be part of host_resolver_proc.cc,
// however it isn't safe to call NetworkChangeNotifier from worker threads.
// So do it here on the IO thread instead.
if (error != OK && NetworkChangeNotifier::IsOffline())
error = ERR_INTERNET_DISCONNECTED;
RecordAttemptHistograms(start_time, attempt_number, error, os_error,
tick_clock);
if (!proc_task) {
RecordDiscardedAttemptHistograms(attempt_number);
return;
}
proc_task->OnLookupComplete(results, start_time, attempt_number, error,
os_error);
}
void OnLookupComplete(const AddressList& results,
const base::TimeTicks& start_time,
const uint32_t attempt_number,
int error,
const int os_error) {
DCHECK(network_task_runner_->BelongsToCurrentThread());
DCHECK(!was_completed());
// Invalidate WeakPtrs to cancel handling of all outstanding lookup attempts
// and retries.
weak_ptr_factory_.InvalidateWeakPtrs();
RecordTaskHistograms(start_time, error, os_error, attempt_number);
NetLogParametersCallback net_log_callback;
NetLogParametersCallback attempt_net_log_callback;
if (error != OK) {
net_log_callback = base::BindRepeating(&NetLogProcTaskFailedCallback, 0,
error, os_error);
attempt_net_log_callback = base::BindRepeating(
&NetLogProcTaskFailedCallback, attempt_number, error, os_error);
} else {
net_log_callback = results.CreateNetLogCallback();
attempt_net_log_callback =
NetLog::IntCallback("attempt_number", attempt_number);
}
net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_PROC_TASK,
net_log_callback);
net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_ATTEMPT_FINISHED,
attempt_net_log_callback);
std::move(callback_).Run(error, results);
}
void RecordTaskHistograms(const base::TimeTicks& start_time,
const int error,
const int os_error,
const uint32_t attempt_number) const {
DCHECK(network_task_runner_->BelongsToCurrentThread());
base::TimeDelta duration = tick_clock_->NowTicks() - start_time;
if (error == OK) {
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ProcTask.SuccessTime", duration);
UMA_HISTOGRAM_ENUMERATION("DNS.AttemptFirstSuccess", attempt_number, 100);
} else {
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ProcTask.FailureTime", duration);
UMA_HISTOGRAM_ENUMERATION("DNS.AttemptFirstFailure", attempt_number, 100);
}
UMA_HISTOGRAM_CUSTOM_ENUMERATION(kOSErrorsForGetAddrinfoHistogramName,
std::abs(os_error),
GetAllGetAddrinfoOSErrors());
}
static void RecordAttemptHistograms(const base::TimeTicks& start_time,
const uint32_t attempt_number,
const int error,
const int os_error,
const base::TickClock* tick_clock) {
base::TimeDelta duration = tick_clock->NowTicks() - start_time;
if (error == OK) {
UMA_HISTOGRAM_ENUMERATION("DNS.AttemptSuccess", attempt_number, 100);
UMA_HISTOGRAM_LONG_TIMES_100("DNS.AttemptSuccessDuration", duration);
} else {
UMA_HISTOGRAM_ENUMERATION("DNS.AttemptFailure", attempt_number, 100);
UMA_HISTOGRAM_LONG_TIMES_100("DNS.AttemptFailDuration", duration);
}
}
static void RecordDiscardedAttemptHistograms(const uint32_t attempt_number) {
// Count those attempts which completed after the job was already canceled
// OR after the job was already completed by an earlier attempt (so
// cancelled in effect).
UMA_HISTOGRAM_ENUMERATION("DNS.AttemptDiscarded", attempt_number, 100);
}
Key key_;
// Holds an owning reference to the HostResolverProc that we are going to use.
// This may not be the current resolver procedure by the time we call
// ResolveAddrInfo, but that's OK... we'll use it anyways, and the owning
// reference ensures that it remains valid until we are done.
ProcTaskParams params_;
// The listener to the results of this ProcTask.
Callback callback_;
// Used to post events onto the network thread.
scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
// Used to post blocking HostResolverProc tasks.
scoped_refptr<base::TaskRunner> proc_task_runner_;
// Keeps track of the number of attempts we have made so far to resolve the
// host. Whenever we start an attempt to resolve the host, we increase this
// number.
uint32_t attempt_number_;
NetLogWithSource net_log_;
const base::TickClock* tick_clock_;
// Used to loop back from the blocking lookup attempt tasks as well as from
// delayed retry tasks. Invalidate WeakPtrs on completion and cancellation to
// cancel handling of such posted tasks.
base::WeakPtrFactory<ProcTask> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ProcTask);
};
//-----------------------------------------------------------------------------
// Resolves the hostname using DnsTransaction, which is a full implementation of
// a DNS stub resolver. One DnsTransaction is created for each resolution
// needed, which for AF_UNSPEC resolutions includes both A and AAAA. The
// transactions are scheduled separately and started separately.
//
// TODO(szym): This could be moved to separate source file as well.
class HostResolverImpl::DnsTask : public base::SupportsWeakPtr<DnsTask> {
public:
class Delegate {
public:
virtual void OnDnsTaskComplete(base::TimeTicks start_time,
int net_error,
const AddressList& addr_list,
base::TimeDelta ttl) = 0;
// Called when the first of two jobs succeeds. If the first completed
// transaction fails, this is not called. Also not called when the DnsTask
// only needs to run one transaction.
virtual void OnFirstDnsTransactionComplete() = 0;
virtual URLRequestContext* url_request_context() = 0;
virtual RequestPriority priority() const = 0;
protected:
Delegate() = default;
virtual ~Delegate() = default;
};
DnsTask(DnsClient* client,
const Key& key,
Delegate* delegate,
const NetLogWithSource& job_net_log,
const base::TickClock* tick_clock)
: client_(client),
key_(key),
delegate_(delegate),
net_log_(job_net_log),
num_completed_transactions_(0),
tick_clock_(tick_clock),
task_start_time_(tick_clock_->NowTicks()) {
DCHECK(client);
DCHECK(delegate_);
}
bool needs_two_transactions() const {
return key_.address_family == ADDRESS_FAMILY_UNSPECIFIED;
}
bool needs_another_transaction() const {
return needs_two_transactions() && !transaction_aaaa_;
}
void StartFirstTransaction() {
DCHECK_EQ(0u, num_completed_transactions_);
net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK);
if (key_.address_family == ADDRESS_FAMILY_IPV6) {
StartAAAA();
} else {
StartA();
}
}
void StartSecondTransaction() {
DCHECK(needs_two_transactions());
StartAAAA();
}
base::TimeDelta ttl() { return ttl_; }
private:
void StartA() {
DCHECK(!transaction_a_);
DCHECK_NE(ADDRESS_FAMILY_IPV6, key_.address_family);
transaction_a_ = CreateTransaction(ADDRESS_FAMILY_IPV4);
transaction_a_->Start();
}
void StartAAAA() {
DCHECK(!transaction_aaaa_);
DCHECK_NE(ADDRESS_FAMILY_IPV4, key_.address_family);
transaction_aaaa_ = CreateTransaction(ADDRESS_FAMILY_IPV6);
transaction_aaaa_->Start();
}
std::unique_ptr<DnsTransaction> CreateTransaction(AddressFamily family) {
DCHECK_NE(ADDRESS_FAMILY_UNSPECIFIED, family);
std::unique_ptr<DnsTransaction> trans =
client_->GetTransactionFactory()->CreateTransaction(
key_.hostname,
family == ADDRESS_FAMILY_IPV6 ? dns_protocol::kTypeAAAA
: dns_protocol::kTypeA,
base::BindOnce(&DnsTask::OnTransactionComplete,
base::Unretained(this), tick_clock_->NowTicks()),
net_log_);
trans->SetRequestContext(delegate_->url_request_context());
trans->SetRequestPriority(delegate_->priority());
return trans;
}
void OnTransactionComplete(const base::TimeTicks& start_time,
DnsTransaction* transaction,
int net_error,
const DnsResponse* response) {
DCHECK(transaction);
base::TimeDelta duration = tick_clock_->NowTicks() - start_time;
if (net_error != OK && !(net_error == ERR_NAME_NOT_RESOLVED && response &&
response->IsValid())) {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TransactionFailure", duration);
OnFailure(net_error, DnsResponse::DNS_PARSE_OK);
return;
}
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TransactionSuccess", duration);
switch (transaction->GetType()) {
case dns_protocol::kTypeA:
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TransactionSuccess_A", duration);
break;
case dns_protocol::kTypeAAAA:
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TransactionSuccess_AAAA",
duration);
break;
}
AddressList addr_list;
base::TimeDelta ttl;
DnsResponse::Result result = response->ParseToAddressList(&addr_list, &ttl);
UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ParseToAddressList",
result,
DnsResponse::DNS_PARSE_RESULT_MAX);
if (result != DnsResponse::DNS_PARSE_OK) {
// Fail even if the other query succeeds.
OnFailure(ERR_DNS_MALFORMED_RESPONSE, result);
return;
}
++num_completed_transactions_;
if (num_completed_transactions_ == 1) {
ttl_ = ttl;
} else {
ttl_ = std::min(ttl_, ttl);
}
if (transaction->GetType() == dns_protocol::kTypeA) {
DCHECK_EQ(transaction_a_.get(), transaction);
// Place IPv4 addresses after IPv6.
addr_list_.insert(addr_list_.end(), addr_list.begin(), addr_list.end());
} else {
DCHECK_EQ(transaction_aaaa_.get(), transaction);
// Place IPv6 addresses before IPv4.
addr_list_.insert(addr_list_.begin(), addr_list.begin(), addr_list.end());
}
if (needs_two_transactions() && num_completed_transactions_ == 1) {
// No need to repeat the suffix search.
key_.hostname = transaction->GetHostname();
delegate_->OnFirstDnsTransactionComplete();
return;
}
if (addr_list_.empty()) {
// TODO(szym): Don't fallback to ProcTask in this case.
OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
return;
}
// If there are multiple addresses, and at least one is IPv6, need to sort
// them. Note that IPv6 addresses are always put before IPv4 ones, so it's
// sufficient to just check the family of the first address.
if (addr_list_.size() > 1 &&
addr_list_[0].GetFamily() == ADDRESS_FAMILY_IPV6) {
// Sort addresses if needed. Sort could complete synchronously.
client_->GetAddressSorter()->Sort(
addr_list_, base::BindOnce(&DnsTask::OnSortComplete, AsWeakPtr(),
tick_clock_->NowTicks()));
} else {
OnSuccess(addr_list_);
}
}
void OnSortComplete(base::TimeTicks start_time,
bool success,
const AddressList& addr_list) {
if (!success) {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.SortFailure",
tick_clock_->NowTicks() - start_time);
OnFailure(ERR_DNS_SORT_ERROR, DnsResponse::DNS_PARSE_OK);
return;
}
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.SortSuccess",
tick_clock_->NowTicks() - start_time);
// AddressSorter prunes unusable destinations.
if (addr_list.empty()) {
LOG(WARNING) << "Address list empty after RFC3484 sort";
OnFailure(ERR_NAME_NOT_RESOLVED, DnsResponse::DNS_PARSE_OK);
return;
}
OnSuccess(addr_list);
}
void OnFailure(int net_error, DnsResponse::Result result) {
DCHECK_NE(OK, net_error);
net_log_.EndEvent(
NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK,
base::Bind(&NetLogDnsTaskFailedCallback, net_error, result));
base::TimeDelta ttl = ttl_ < base::TimeDelta::FromSeconds(
std::numeric_limits<uint32_t>::max()) &&
num_completed_transactions_ > 0
? ttl_
: base::TimeDelta::FromSeconds(0);
delegate_->OnDnsTaskComplete(task_start_time_, net_error, AddressList(),
ttl);
}
void OnSuccess(const AddressList& addr_list) {
net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_DNS_TASK,
addr_list.CreateNetLogCallback());
delegate_->OnDnsTaskComplete(task_start_time_, OK, addr_list, ttl_);
}
DnsClient* client_;
Key key_;
// The listener to the results of this DnsTask.
Delegate* delegate_;
const NetLogWithSource net_log_;
std::unique_ptr<DnsTransaction> transaction_a_;
std::unique_ptr<DnsTransaction> transaction_aaaa_;
unsigned num_completed_transactions_;
// These are updated as each transaction completes.
base::TimeDelta ttl_;
// IPv6 addresses must appear first in the list.
AddressList addr_list_;
const base::TickClock* tick_clock_;
base::TimeTicks task_start_time_;
DISALLOW_COPY_AND_ASSIGN(DnsTask);
};
//-----------------------------------------------------------------------------
// Aggregates all Requests for the same Key. Dispatched via PriorityDispatch.
class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
public HostResolverImpl::DnsTask::Delegate {
public:
// Creates new job for |key| where |request_net_log| is bound to the
// request that spawned it.
Job(const base::WeakPtr<HostResolverImpl>& resolver,
const Key& key,
RequestPriority priority,
scoped_refptr<base::TaskRunner> proc_task_runner,
const NetLogWithSource& source_net_log,
const base::TickClock* tick_clock)
: resolver_(resolver),
key_(key),
priority_tracker_(priority),
proc_task_runner_(std::move(proc_task_runner)),
had_non_speculative_request_(false),
num_occupied_job_slots_(0),
dns_task_error_(OK),
tick_clock_(tick_clock),
creation_time_(tick_clock_->NowTicks()),
priority_change_time_(creation_time_),
net_log_(
NetLogWithSource::Make(source_net_log.net_log(),
NetLogSourceType::HOST_RESOLVER_IMPL_JOB)) {
source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_CREATE_JOB);
net_log_.BeginEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB,
base::Bind(&NetLogJobCreationCallback,
source_net_log.source(), &key_.hostname));
}
~Job() override {
if (is_running()) {
// |resolver_| was destroyed with this Job still in flight.
// Clean-up, record in the log, but don't run any callbacks.
proc_task_ = nullptr;
// Clean up now for nice NetLog.
KillDnsTask();
net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,
ERR_ABORTED);
} else if (is_queued()) {
// |resolver_| was destroyed without running this Job.
// TODO(szym): is there any benefit in having this distinction?
net_log_.AddEvent(NetLogEventType::CANCELLED);
net_log_.EndEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB);
}
// else CompleteRequests logged EndEvent.
while (!requests_.empty()) {
// Log any remaining Requests as cancelled.
RequestImpl* req = requests_.head()->value();
req->RemoveFromList();
DCHECK_EQ(this, req->job());
LogCancelRequest(req->source_net_log());
req->OnJobCancelled(this);
}
}
// Add this job to the dispatcher. If "at_head" is true, adds at the front
// of the queue.
void Schedule(bool at_head) {
DCHECK(!is_queued());
PrioritizedDispatcher::Handle handle;
if (!at_head) {
handle = resolver_->dispatcher_->Add(this, priority());
} else {
handle = resolver_->dispatcher_->AddAtHead(this, priority());
}
// The dispatcher could have started |this| in the above call to Add, which
// could have called Schedule again. In that case |handle| will be null,
// but |handle_| may have been set by the other nested call to Schedule.
if (!handle.is_null()) {
DCHECK(handle_.is_null());
handle_ = handle;
}
}
void AddRequest(RequestImpl* request) {
DCHECK_EQ(key_.hostname, request->request_host().host());
request->AssignJob(this);
priority_tracker_.Add(request->priority());
request->source_net_log().AddEvent(
NetLogEventType::HOST_RESOLVER_IMPL_JOB_ATTACH,
net_log_.source().ToEventParametersCallback());
net_log_.AddEvent(
NetLogEventType::HOST_RESOLVER_IMPL_JOB_REQUEST_ATTACH,
base::Bind(&NetLogJobAttachCallback, request->source_net_log().source(),
priority()));
if (!request->parameters().is_speculative)
had_non_speculative_request_ = true;
requests_.Append(request);
UpdatePriority();
}
void ChangeRequestPriority(RequestImpl* req, RequestPriority priority) {
DCHECK_EQ(key_.hostname, req->request_host().host());
priority_tracker_.Remove(req->priority());
req->set_priority(priority);
priority_tracker_.Add(req->priority());
UpdatePriority();
}
// Detach cancelled request. If it was the last active Request, also finishes
// this Job.
void CancelRequest(RequestImpl* request) {
DCHECK_EQ(key_.hostname, request->request_host().host());
DCHECK(!requests_.empty());
LogCancelRequest(request->source_net_log());
priority_tracker_.Remove(request->priority());
net_log_.AddEvent(
NetLogEventType::HOST_RESOLVER_IMPL_JOB_REQUEST_DETACH,
base::Bind(&NetLogJobAttachCallback, request->source_net_log().source(),
priority()));
if (num_active_requests() > 0) {
UpdatePriority();
request->RemoveFromList();
} else {
// If we were called from a Request's callback within CompleteRequests,
// that Request could not have been cancelled, so num_active_requests()
// could not be 0. Therefore, we are not in CompleteRequests().
CompleteRequestsWithError(OK /* cancelled */);
}
}
// Called from AbortAllInProgressJobs. Completes all requests and destroys
// the job. This currently assumes the abort is due to a network change.
// TODO This should not delete |this|.
void Abort() {
DCHECK(is_running());
CompleteRequestsWithError(ERR_NETWORK_CHANGED);
}
// If DnsTask present, abort it and fall back to ProcTask.
void AbortDnsTask() {
if (dns_task_) {
KillDnsTask();
dns_task_error_ = OK;
StartProcTask();
}
}
// Called by HostResolverImpl when this job is evicted due to queue overflow.
// Completes all requests and destroys the job.
void OnEvicted() {
DCHECK(!is_running());
DCHECK(is_queued());
handle_.Reset();
net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB_EVICTED);
// This signals to CompleteRequests that this job never ran.
CompleteRequestsWithError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
}
// Attempts to serve the job from HOSTS. Returns true if succeeded and
// this Job was destroyed.
bool ServeFromHosts() {
DCHECK_GT(num_active_requests(), 0u);
AddressList addr_list;
if (resolver_->ServeFromHosts(
key(), requests_.head()->value()->request_host().port(),
&addr_list)) {
// This will destroy the Job.
CompleteRequests(
MakeCacheEntry(OK, addr_list, HostCache::Entry::SOURCE_HOSTS),
base::TimeDelta(), true /* allow_cache */);
return true;
}
return false;
}
const Key& key() const { return key_; }
bool is_queued() const {
return !handle_.is_null();
}
bool is_running() const {
return is_dns_running() || is_mdns_running() || is_proc_running();
}
private:
void KillDnsTask() {
if (dns_task_) {
ReduceToOneJobSlot();
dns_task_.reset();
}
}
// Reduce the number of job slots occupied and queued in the dispatcher
// to one. If the second Job slot is queued in the dispatcher, cancels the
// queued job. Otherwise, the second Job has been started by the
// PrioritizedDispatcher, so signals it is complete.
void ReduceToOneJobSlot() {
DCHECK_GE(num_occupied_job_slots_, 1u);
if (is_queued()) {
resolver_->dispatcher_->Cancel(handle_);
handle_.Reset();
} else if (num_occupied_job_slots_ > 1) {
resolver_->dispatcher_->OnJobFinished();
--num_occupied_job_slots_;
}
DCHECK_EQ(1u, num_occupied_job_slots_);
}
// MakeCacheEntry() and MakeCacheEntryWithTTL() are helpers to build a
// HostCache::Entry(). The address list is omited from the cache entry
// for errors.
HostCache::Entry MakeCacheEntry(int net_error,
const AddressList& addr_list,
HostCache::Entry::Source source) const {
return HostCache::Entry(
net_error,
net_error == OK ? MakeAddressListForRequest(addr_list) : AddressList(),
source);
}
HostCache::Entry MakeCacheEntryWithTTL(int net_error,
const AddressList& addr_list,
HostCache::Entry::Source source,
base::TimeDelta ttl) const {
return HostCache::Entry(
net_error,
net_error == OK ? MakeAddressListForRequest(addr_list) : AddressList(),
source, ttl);
}
AddressList MakeAddressListForRequest(const AddressList& list) const {
if (requests_.empty())
return list;
return AddressList::CopyWithPort(
list, requests_.head()->value()->request_host().port());
}
void UpdatePriority() {
if (is_queued()) {
if (priority() != static_cast<RequestPriority>(handle_.priority()))
priority_change_time_ = tick_clock_->NowTicks();
handle_ = resolver_->dispatcher_->ChangePriority(handle_, priority());
}
}
// PriorityDispatch::Job:
void Start() override {
DCHECK_LE(num_occupied_job_slots_, 1u);
handle_.Reset();
++num_occupied_job_slots_;
if (num_occupied_job_slots_ == 2) {
StartSecondDnsTransaction();
return;
}
DCHECK(!is_running());
net_log_.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_JOB_STARTED);
start_time_ = tick_clock_->NowTicks();
base::TimeDelta queue_time = start_time_ - creation_time_;
base::TimeDelta queue_time_after_change =
start_time_ - priority_change_time_;
DNS_HISTOGRAM_BY_PRIORITY("Net.DNS.JobQueueTime", priority(), queue_time);
DNS_HISTOGRAM_BY_PRIORITY("Net.DNS.JobQueueTimeAfterChange", priority(),
queue_time_after_change);
switch (key_.host_resolver_source) {
case HostResolverSource::ANY:
if (resolver_->HaveDnsConfig() &&
!ResemblesMulticastDNSName(key_.hostname) &&
!(key_.host_resolver_flags & HOST_RESOLVER_CANONNAME)) {
StartDnsTask();
} else {
StartProcTask();
}
break;
case HostResolverSource::SYSTEM:
StartProcTask();
break;
case HostResolverSource::DNS:
// DNS source should not be requested unless the resolver is configured
// to handle it.
DCHECK(resolver_->HaveDnsConfig());
StartDnsTask();
break;
case HostResolverSource::MULTICAST_DNS:
StartMdnsTask();
break;
}
// Caution: Job::Start must not complete synchronously.
}
// TODO(szym): Since DnsTransaction does not consume threads, we can increase
// the limits on |dispatcher_|. But in order to keep the number of
// TaskScheduler threads low, we will need to use an "inner"
// PrioritizedDispatcher with tighter limits.
void StartProcTask() {
DCHECK(!is_running());
proc_task_ = std::make_unique<ProcTask>(
key_, resolver_->proc_params_,
base::BindOnce(&Job::OnProcTaskComplete, base::Unretained(this),
tick_clock_->NowTicks()),
proc_task_runner_, net_log_, tick_clock_);
// Start() could be called from within Resolve(), hence it must NOT directly
// call OnProcTaskComplete, for example, on synchronous failure.
proc_task_->Start();
}
// Called by ProcTask when it completes.
void OnProcTaskComplete(base::TimeTicks start_time,
int net_error,
const AddressList& addr_list) {
DCHECK(is_proc_running());
if (dns_task_error_ != OK) {
base::TimeDelta duration = tick_clock_->NowTicks() - start_time;
if (net_error == OK) {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackSuccess", duration);
if ((dns_task_error_ == ERR_NAME_NOT_RESOLVED) &&
ResemblesNetBIOSName(key_.hostname)) {
UmaAsyncDnsResolveStatus(RESOLVE_STATUS_SUSPECT_NETBIOS);
} else {
UmaAsyncDnsResolveStatus(RESOLVE_STATUS_PROC_SUCCESS);
}
base::UmaHistogramSparse("Net.DNS.DnsTask.Errors",
std::abs(dns_task_error_));
resolver_->OnDnsTaskResolve(dns_task_error_);
} else {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.FallbackFail", duration);
UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
}
}
if (ContainsIcannNameCollisionIp(addr_list))
net_error = ERR_ICANN_NAME_COLLISION;
base::TimeDelta ttl =
base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
if (net_error == OK)
ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
// Source unknown because the system resolver could have gotten it from a
// hosts file, its own cache, a DNS lookup or somewhere else.
// Don't store the |ttl| in cache since it's not obtained from the server.
CompleteRequests(
MakeCacheEntry(net_error, addr_list, HostCache::Entry::SOURCE_UNKNOWN),
ttl, true /* allow_cache */);
}
void StartDnsTask() {
DCHECK(resolver_->HaveDnsConfig());
dns_task_.reset(new DnsTask(resolver_->dns_client_.get(), key_, this,
net_log_, tick_clock_));
dns_task_->StartFirstTransaction();
// Schedule a second transaction, if needed.
if (dns_task_->needs_two_transactions())
Schedule(true);
}
void StartSecondDnsTransaction() {
DCHECK(dns_task_->needs_two_transactions());
dns_task_->StartSecondTransaction();
}
// Called if DnsTask fails. It is posted from StartDnsTask, so Job may be
// deleted before this callback. In this case dns_task is deleted as well,
// so we use it as indicator whether Job is still valid.
void OnDnsTaskFailure(const base::WeakPtr<DnsTask>& dns_task,
base::TimeDelta duration,
int net_error) {
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.DnsTask.FailureTime", duration);
if (!dns_task)
return;
if (duration < base::TimeDelta::FromMilliseconds(10)) {
base::UmaHistogramSparse("Net.DNS.DnsTask.ErrorBeforeFallback.Fast",
std::abs(net_error));
} else {
base::UmaHistogramSparse("Net.DNS.DnsTask.ErrorBeforeFallback.Slow",
std::abs(net_error));
}
dns_task_error_ = net_error;
// TODO(szym): Run ServeFromHosts now if nsswitch.conf says so.
// http://crbug.com/117655
// TODO(szym): Some net errors indicate lack of connectivity. Starting
// ProcTask in that case is a waste of time.
if (resolver_->fallback_to_proctask_) {
KillDnsTask();
StartProcTask();
} else {
UmaAsyncDnsResolveStatus(RESOLVE_STATUS_FAIL);
// If the ttl is max, we didn't get one from the record, so set it to 0
base::TimeDelta ttl =
dns_task->ttl() < base::TimeDelta::FromSeconds(
std::numeric_limits<uint32_t>::max())
? dns_task->ttl()
: base::TimeDelta::FromSeconds(0);
CompleteRequests(
HostCache::Entry(net_error, AddressList(),
HostCache::Entry::Source::SOURCE_UNKNOWN, ttl),
ttl, true /* allow_cache */);
}
}
// HostResolverImpl::DnsTask::Delegate implementation:
void OnDnsTaskComplete(base::TimeTicks start_time,
int net_error,
const AddressList& addr_list,
base::TimeDelta ttl) override {
DCHECK(is_dns_running());
base::TimeDelta duration = tick_clock_->NowTicks() - start_time;
if (net_error != OK) {
OnDnsTaskFailure(dns_task_->AsWeakPtr(), duration, net_error);
return;
}
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.DnsTask.SuccessTime", duration);
UmaAsyncDnsResolveStatus(RESOLVE_STATUS_DNS_SUCCESS);
RecordTTL(ttl);
resolver_->OnDnsTaskResolve(OK);
base::TimeDelta bounded_ttl =
std::max(ttl, base::TimeDelta::FromSeconds(kMinimumTTLSeconds));
if (ContainsIcannNameCollisionIp(addr_list)) {
CompleteRequestsWithError(ERR_ICANN_NAME_COLLISION);
} else {
CompleteRequests(MakeCacheEntryWithTTL(net_error, addr_list,
HostCache::Entry::SOURCE_DNS, ttl),
bounded_ttl, true /* allow_cache */);
}
}
void OnFirstDnsTransactionComplete() override {
DCHECK(dns_task_->needs_two_transactions());
DCHECK_EQ(dns_task_->needs_another_transaction(), is_queued());
// No longer need to occupy two dispatcher slots.
ReduceToOneJobSlot();
// We already have a job slot at the dispatcher, so if the second
// transaction hasn't started, reuse it now instead of waiting in the queue
// for the second slot.
if (dns_task_->needs_another_transaction())
dns_task_->StartSecondTransaction();
}
void StartMdnsTask() {
DCHECK(!is_running());
// No flags are supported for MDNS except
// HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6 (which is not actually an
// input flag).
DCHECK_EQ(0, key_.host_resolver_flags &
~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
std::vector<HostResolver::DnsQueryType> query_types;
switch (key_.address_family) {
case ADDRESS_FAMILY_UNSPECIFIED:
query_types.push_back(HostResolver::DnsQueryType::A);
query_types.push_back(HostResolver::DnsQueryType::AAAA);
break;
case ADDRESS_FAMILY_IPV4:
query_types.push_back(HostResolver::DnsQueryType::A);
break;
case ADDRESS_FAMILY_IPV6:
query_types.push_back(HostResolver::DnsQueryType::AAAA);
break;
}
mdns_task_ = std::make_unique<HostResolverMdnsTask>(
resolver_->GetOrCreateMdnsClient(), key_.hostname, query_types);
mdns_task_->Start(
base::BindOnce(&Job::OnMdnsTaskComplete, base::Unretained(this)));
}
void OnMdnsTaskComplete(int error) {
DCHECK(is_mdns_running());
// TODO(crbug.com/846423): Consider adding MDNS-specific logging.
if (error != OK) {
CompleteRequestsWithError(error);
} else if (ContainsIcannNameCollisionIp(mdns_task_->result_addresses())) {
CompleteRequestsWithError(ERR_ICANN_NAME_COLLISION);
} else {
// MDNS uses a separate cache, so skip saving result to cache.
// TODO(crbug.com/846423): Consider merging caches.
CompleteRequestsWithoutCache(error, mdns_task_->result_addresses());
}
}
URLRequestContext* url_request_context() override {
return resolver_->url_request_context_;
}
void RecordJobHistograms(int error) {
// Used in UMA_HISTOGRAM_ENUMERATION. Do not renumber entries or reuse
// deprecated values.
enum Category {
RESOLVE_SUCCESS = 0,
RESOLVE_FAIL = 1,
RESOLVE_SPECULATIVE_SUCCESS = 2,
RESOLVE_SPECULATIVE_FAIL = 3,
RESOLVE_ABORT = 4,
RESOLVE_SPECULATIVE_ABORT = 5,
RESOLVE_MAX, // Bounding value.
};
Category category = RESOLVE_MAX; // Illegal value for later DCHECK only.
base::TimeDelta duration = tick_clock_->NowTicks() - start_time_;
if (error == OK) {
if (had_non_speculative_request_) {
category = RESOLVE_SUCCESS;
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime", duration);
switch (key_.address_family) {
case ADDRESS_FAMILY_IPV4:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime.IPV4",
duration);
break;
case ADDRESS_FAMILY_IPV6:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime.IPV6",
duration);
break;
case ADDRESS_FAMILY_UNSPECIFIED:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveSuccessTime.UNSPEC",
duration);
break;
}
} else {
category = RESOLVE_SPECULATIVE_SUCCESS;
}
} else if (error == ERR_NETWORK_CHANGED ||
error == ERR_HOST_RESOLVER_QUEUE_TOO_LARGE) {
category = had_non_speculative_request_ ? RESOLVE_ABORT
: RESOLVE_SPECULATIVE_ABORT;
} else {
if (had_non_speculative_request_) {
category = RESOLVE_FAIL;
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime", duration);
switch (key_.address_family) {
case ADDRESS_FAMILY_IPV4:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime.IPV4",
duration);
break;
case ADDRESS_FAMILY_IPV6:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime.IPV6",
duration);
break;
case ADDRESS_FAMILY_UNSPECIFIED:
UMA_HISTOGRAM_LONG_TIMES_100("Net.DNS.ResolveFailureTime.UNSPEC",
duration);
break;
}
} else {
category = RESOLVE_SPECULATIVE_FAIL;
}
}
DCHECK_LT(static_cast<int>(category),
static_cast<int>(RESOLVE_MAX)); // Be sure it was set.
UMA_HISTOGRAM_ENUMERATION("Net.DNS.ResolveCategory", category, RESOLVE_MAX);
if (category == RESOLVE_FAIL || category == RESOLVE_ABORT) {
if (duration < base::TimeDelta::FromMilliseconds(10))
base::UmaHistogramSparse("Net.DNS.ResolveError.Fast", std::abs(error));
else
base::UmaHistogramSparse("Net.DNS.ResolveError.Slow", std::abs(error));
}
}
// Performs Job's last rites. Completes all Requests. Deletes this.
//
// If not |allow_cache|, result will not be stored in the host cache, even if
// result would otherwise allow doing so.
void CompleteRequests(const HostCache::Entry& entry,
base::TimeDelta ttl,
bool allow_cache) {
CHECK(resolver_.get());
// This job must be removed from resolver's |jobs_| now to make room for a
// new job with the same key in case one of the OnComplete callbacks decides
// to spawn one. Consequently, if the job was owned by |jobs_|, the job
// deletes itself when CompleteRequests is done.
std::unique_ptr<Job> self_deleter = resolver_->RemoveJob(this);
if (is_running()) {
proc_task_ = nullptr;
KillDnsTask();
mdns_task_ = nullptr;
// Signal dispatcher that a slot has opened.
resolver_->dispatcher_->OnJobFinished();
} else if (is_queued()) {
resolver_->dispatcher_->Cancel(handle_);
handle_.Reset();
}
if (num_active_requests() == 0) {
net_log_.AddEvent(NetLogEventType::CANCELLED);
net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,
OK);
return;
}
net_log_.EndEventWithNetErrorCode(NetLogEventType::HOST_RESOLVER_IMPL_JOB,
entry.error());
DCHECK(!requests_.empty());
if (entry.error() == OK || entry.error() == ERR_ICANN_NAME_COLLISION) {
// Record this histogram here, when we know the system has a valid DNS
// configuration.
UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HaveDnsConfig",
resolver_->received_dns_config_);
}
bool did_complete = (entry.error() != ERR_NETWORK_CHANGED) &&
(entry.error() != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
if (did_complete && allow_cache)
resolver_->CacheResult(key_, entry, ttl);
RecordJobHistograms(entry.error());
// Complete all of the requests that were attached to the job and
// detach them.
while (!requests_.empty()) {
RequestImpl* req = requests_.head()->value();
req->RemoveFromList();
DCHECK_EQ(this, req->job());
// Update the net log and notify registered observers.
LogFinishRequest(req->source_net_log(), entry.error());
if (did_complete) {
// Record effective total time from creation to completion.
RecordTotalTime(req->parameters().is_speculative,
false /* from_cache */,
tick_clock_->NowTicks() - req->request_time());
}
if (entry.error() == OK && !req->parameters().is_speculative) {
req->set_address_results(EnsurePortOnAddressList(
entry.addresses(), req->request_host().port()));
}
req->OnJobCompleted(this, entry.error());
// Check if the resolver was destroyed as a result of running the
// callback. If it was, we could continue, but we choose to bail.
if (!resolver_.get())
return;
}
}
void CompleteRequestsWithoutCache(int error, const AddressList& addresses) {
CompleteRequests(
MakeCacheEntry(error, addresses, HostCache::Entry::SOURCE_UNKNOWN),
base::TimeDelta(), false /* allow_cache */);
}
// Convenience wrapper for CompleteRequests in case of failure.
void CompleteRequestsWithError(int net_error) {
CompleteRequests(HostCache::Entry(net_error, AddressList(),
HostCache::Entry::SOURCE_UNKNOWN),
base::TimeDelta(), true /* allow_cache */);
}
RequestPriority priority() const override {
return priority_tracker_.highest_priority();
}
// Number of non-canceled requests in |requests_|.
size_t num_active_requests() const {
return priority_tracker_.total_count();
}
bool is_dns_running() const { return !!dns_task_; }
bool is_mdns_running() const { return !!mdns_task_; }
bool is_proc_running() const { return !!proc_task_; }
base::WeakPtr<HostResolverImpl> resolver_;
Key key_;
// Tracks the highest priority across |requests_|.
PriorityTracker priority_tracker_;
// Task runner used for HostResolverProc.
scoped_refptr<base::TaskRunner> proc_task_runner_;
bool had_non_speculative_request_;
// Number of slots occupied by this Job in resolver's PrioritizedDispatcher.
unsigned num_occupied_job_slots_;
// Result of DnsTask.
int dns_task_error_;
const base::TickClock* tick_clock_;
const base::TimeTicks creation_time_;
base::TimeTicks priority_change_time_;
base::TimeTicks start_time_;
NetLogWithSource net_log_;
// Resolves the host using a HostResolverProc.
std::unique_ptr<ProcTask> proc_task_;
// Resolves the host using a DnsTransaction.
std::unique_ptr<DnsTask> dns_task_;
// Resolves the host using MDnsClient.
std::unique_ptr<HostResolverMdnsTask> mdns_task_;
// All Requests waiting for the result of this Job. Some can be canceled.
base::LinkedList<RequestImpl> requests_;
// A handle used in |HostResolverImpl::dispatcher_|.
PrioritizedDispatcher::Handle handle_;
};
//-----------------------------------------------------------------------------
HostResolverImpl::ProcTaskParams::ProcTaskParams(
HostResolverProc* resolver_proc,
size_t max_retry_attempts)
: resolver_proc(resolver_proc),
max_retry_attempts(max_retry_attempts),
unresponsive_delay(
base::TimeDelta::FromMilliseconds(kDnsDefaultUnresponsiveDelayMs)),
retry_factor(2) {
// Maximum of 4 retry attempts for host resolution.
static const size_t kDefaultMaxRetryAttempts = 4u;
if (max_retry_attempts == HostResolver::kDefaultRetryAttempts)
max_retry_attempts = kDefaultMaxRetryAttempts;
}
HostResolverImpl::ProcTaskParams::ProcTaskParams(const ProcTaskParams& other) =
default;
HostResolverImpl::ProcTaskParams::~ProcTaskParams() = default;
HostResolverImpl::HostResolverImpl(const Options& options, NetLog* net_log)
: max_queued_jobs_(0),
proc_params_(NULL, options.max_retry_attempts),
net_log_(net_log),
received_dns_config_(false),
num_dns_failures_(0),
assume_ipv6_failure_on_wifi_(false),
use_local_ipv6_(false),
last_ipv6_probe_result_(true),
additional_resolver_flags_(0),
fallback_to_proctask_(true),
url_request_context_(nullptr),
tick_clock_(base::DefaultTickClock::GetInstance()),
weak_ptr_factory_(this),
probe_weak_ptr_factory_(this) {
if (options.enable_caching)
cache_ = HostCache::CreateDefaultCache();
PrioritizedDispatcher::Limits job_limits = options.GetDispatcherLimits();
dispatcher_.reset(new PrioritizedDispatcher(job_limits));
max_queued_jobs_ = job_limits.total_jobs * 100u;
DCHECK_GE(dispatcher_->num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
proc_task_runner_ = base::CreateTaskRunnerWithTraits(
{base::MayBlock(), priority_mode.Get(),
base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN});
#if defined(OS_WIN)
EnsureWinsockInit();
#endif
#if (defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)) || \
defined(OS_FUCHSIA)
RunLoopbackProbeJob();
#endif
NetworkChangeNotifier::AddIPAddressObserver(this);
NetworkChangeNotifier::AddConnectionTypeObserver(this);
NetworkChangeNotifier::AddDNSObserver(this);
#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \
!defined(OS_ANDROID)
EnsureDnsReloaderInit();
#endif
OnConnectionTypeChanged(NetworkChangeNotifier::GetConnectionType());
{
DnsConfig dns_config;
NetworkChangeNotifier::GetDnsConfig(&dns_config);
received_dns_config_ = dns_config.IsValid();
// Conservatively assume local IPv6 is needed when DnsConfig is not valid.
use_local_ipv6_ = !dns_config.IsValid() || dns_config.use_local_ipv6;
}
fallback_to_proctask_ = !ConfigureAsyncDnsNoFallbackFieldTrial();
}
HostResolverImpl::~HostResolverImpl() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Prevent the dispatcher from starting new jobs.
dispatcher_->SetLimitsToZero();
// It's now safe for Jobs to call KillDnsTask on destruction, because
// OnJobComplete will not start any new jobs.
jobs_.clear();
NetworkChangeNotifier::RemoveIPAddressObserver(this);
NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
NetworkChangeNotifier::RemoveDNSObserver(this);
}
void HostResolverImpl::SetDnsClient(std::unique_ptr<DnsClient> dns_client) {
// DnsClient and config must be updated before aborting DnsTasks, since doing
// so may start new jobs.
dns_client_ = std::move(dns_client);
if (dns_client_ && !dns_client_->GetConfig() &&
num_dns_failures_ < kMaximumDnsFailures) {
DnsConfig dns_config;
NetworkChangeNotifier::GetDnsConfig(&dns_config);
dns_config.dns_over_https_servers = dns_over_https_servers_;
dns_client_->SetConfig(dns_config);
num_dns_failures_ = 0;
if (dns_client_->GetConfig())
UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
}
AbortDnsTasks();
}
std::unique_ptr<HostResolver::ResolveHostRequest>
HostResolverImpl::CreateRequest(
const HostPortPair& host,
const NetLogWithSource& net_log,
const base::Optional<ResolveHostParameters>& optional_parameters) {
return std::make_unique<RequestImpl>(net_log, host, optional_parameters,
weak_ptr_factory_.GetWeakPtr());
}
int HostResolverImpl::Resolve(const RequestInfo& info,
RequestPriority priority,
AddressList* addresses,
CompletionOnceCallback callback,
std::unique_ptr<Request>* out_req,
const NetLogWithSource& source_net_log) {
DCHECK(addresses);
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(callback);
DCHECK(out_req);
auto request = std::make_unique<RequestImpl>(
source_net_log, info.host_port_pair(),
RequestInfoToResolveHostParameters(info, priority),
weak_ptr_factory_.GetWeakPtr());
auto wrapped_request =
std::make_unique<LegacyRequestImpl>(std::move(request));
int rv = wrapped_request->Start();
if (rv == OK && !info.is_speculative()) {
DCHECK(wrapped_request->inner_request().GetAddressResults());
*addresses = wrapped_request->inner_request().GetAddressResults().value();
} else if (rv == ERR_IO_PENDING) {
wrapped_request->AssignCallback(std::move(callback), addresses);
*out_req = std::move(wrapped_request);
}
return rv;
}
int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
AddressList* addresses,
const NetLogWithSource& source_net_log) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(addresses);
// Update the net log and notify registered observers.
LogStartRequest(source_net_log, info);
Key key;
int rv = ResolveLocally(
info.host_port_pair(), AddressFamilyToDnsQueryType(info.address_family()),
FlagsToSource(info.host_resolver_flags()), info.host_resolver_flags(),
info.allow_cached_response(), false /* allow_stale */,
nullptr /* stale_info */, source_net_log, addresses, &key);
LogFinishRequest(source_net_log, rv);
return rv;
}
int HostResolverImpl::ResolveStaleFromCache(
const RequestInfo& info,
AddressList* addresses,
HostCache::EntryStaleness* stale_info,
const NetLogWithSource& source_net_log) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(addresses);
DCHECK(stale_info);
// Update the net log and notify registered observers.
LogStartRequest(source_net_log, info);
Key key;
int rv = ResolveLocally(
info.host_port_pair(), AddressFamilyToDnsQueryType(info.address_family()),
FlagsToSource(info.host_resolver_flags()), info.host_resolver_flags(),
info.allow_cached_response(), true /* allow_stale */, stale_info,
source_net_log, addresses, &key);
LogFinishRequest(source_net_log, rv);
return rv;
}
void HostResolverImpl::SetDnsClientEnabled(bool enabled) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
#if defined(ENABLE_BUILT_IN_DNS)
if (enabled && !dns_client_) {
SetDnsClient(DnsClient::CreateClient(net_log_));
} else if (!enabled && dns_client_) {
SetDnsClient(std::unique_ptr<DnsClient>());
}
#endif
}
HostCache* HostResolverImpl::GetHostCache() {
return cache_.get();
}
bool HostResolverImpl::HasCached(base::StringPiece hostname,
HostCache::Entry::Source* source_out,
HostCache::EntryStaleness* stale_out) const {
if (!cache_)
return false;
return cache_->HasEntry(hostname, source_out, stale_out);
}
std::unique_ptr<base::Value> HostResolverImpl::GetDnsConfigAsValue() const {
// Check if async DNS is disabled.
if (!dns_client_.get())
return nullptr;
// Check if async DNS is enabled, but we currently have no configuration
// for it.
const DnsConfig* dns_config = dns_client_->GetConfig();
if (!dns_config)
return std::make_unique<base::DictionaryValue>();
return dns_config->ToValue();
}
size_t HostResolverImpl::LastRestoredCacheSize() const {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return cache_ ? cache_->last_restore_size() : 0;
}
size_t HostResolverImpl::CacheSize() const {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return cache_ ? cache_->size() : 0;
}
void HostResolverImpl::SetNoIPv6OnWifi(bool no_ipv6_on_wifi) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
assume_ipv6_failure_on_wifi_ = no_ipv6_on_wifi;
}
bool HostResolverImpl::GetNoIPv6OnWifi() {
return assume_ipv6_failure_on_wifi_;
}
void HostResolverImpl::SetRequestContext(URLRequestContext* context) {
if (context != url_request_context_) {
url_request_context_ = context;
}
}
void HostResolverImpl::AddDnsOverHttpsServer(std::string uri_template,
bool use_post) {
dns_over_https_servers_.emplace_back(uri_template, use_post);
if (dns_client_.get() && dns_client_->GetConfig())
UpdateDNSConfig(true);
}
void HostResolverImpl::ClearDnsOverHttpsServers() {
if (dns_over_https_servers_.size() == 0)
return;
dns_over_https_servers_.clear();
if (dns_client_.get() && dns_client_->GetConfig())
UpdateDNSConfig(true);
}
const std::vector<DnsConfig::DnsOverHttpsServerConfig>*
HostResolverImpl::GetDnsOverHttpsServersForTesting() const {
if (dns_over_https_servers_.empty())
return nullptr;
return &dns_over_https_servers_;
}
void HostResolverImpl::SetTickClockForTesting(
const base::TickClock* tick_clock) {
tick_clock_ = tick_clock;
cache_->set_tick_clock_for_testing(tick_clock);
}
void HostResolverImpl::SetMaxQueuedJobsForTesting(size_t value) {
DCHECK_EQ(0u, dispatcher_->num_queued_jobs());
DCHECK_GE(value, 0u);
max_queued_jobs_ = value;
}
void HostResolverImpl::SetHaveOnlyLoopbackAddresses(bool result) {
if (result) {
additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
} else {
additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
}
}
void HostResolverImpl::SetMdnsSocketFactoryForTesting(
std::unique_ptr<MDnsSocketFactory> socket_factory) {
DCHECK(!mdns_client_);
mdns_socket_factory_ = std::move(socket_factory);
}
void HostResolverImpl::SetMdnsClientForTesting(
std::unique_ptr<MDnsClient> client) {
mdns_client_ = std::move(client);
}
void HostResolverImpl::SetTaskRunnerForTesting(
scoped_refptr<base::TaskRunner> task_runner) {
proc_task_runner_ = std::move(task_runner);
}
int HostResolverImpl::Resolve(RequestImpl* request) {
// Request should not yet have a scheduled Job.
DCHECK(!request->job());
// Request may only be resolved once.
DCHECK(!request->complete());
// MDNS requests do not support skipping cache.
// TODO(crbug.com/846423): Either add support for skipping the MDNS cache, or
// merge to use the normal host cache for MDNS requests.
DCHECK(request->parameters().source != HostResolverSource::MULTICAST_DNS ||
request->parameters().allow_cached_response);
request->set_request_time(tick_clock_->NowTicks());
LogStartRequest(request->source_net_log(), request->request_host());
AddressList addresses;
Key key;
int rv = ResolveLocally(
request->request_host(), request->parameters().dns_query_type,
request->parameters().source, request->host_resolver_flags(),
request->parameters().allow_cached_response, false /* allow_stale */,
nullptr /* stale_info */, request->source_net_log(), &addresses, &key);
if (rv == OK && !request->parameters().is_speculative) {
request->set_address_results(
EnsurePortOnAddressList(addresses, request->request_host().port()));
}
if (rv != ERR_DNS_CACHE_MISS) {
LogFinishRequest(request->source_net_log(), rv);
RecordTotalTime(request->parameters().is_speculative, true /* from_cache */,
base::TimeDelta());
return rv;
}
rv = CreateAndStartJob(key, request);
// At this point, expect only async or errors.
DCHECK_NE(OK, rv);
return rv;
}
int HostResolverImpl::ResolveLocally(const HostPortPair& host,
DnsQueryType dns_query_type,
HostResolverSource source,
HostResolverFlags flags,
bool allow_cache,
bool allow_stale,
HostCache::EntryStaleness* stale_info,
const NetLogWithSource& source_net_log,
AddressList* addresses,
Key* key) {
IPAddress ip_address;
IPAddress* ip_address_ptr = nullptr;
if (ip_address.AssignFromIPLiteral(host.host())) {
ip_address_ptr = &ip_address;
} else {
// Check that the caller supplied a valid hostname to resolve.
if (!IsValidDNSDomain(host.host()))
return ERR_NAME_NOT_RESOLVED;
}
// Build a key that identifies the request in the cache and in the
// outstanding jobs map.
*key = GetEffectiveKeyForRequest(host.host(), dns_query_type, source, flags,
ip_address_ptr, source_net_log);
DCHECK(allow_stale == !!stale_info);
// The result of |getaddrinfo| for empty hosts is inconsistent across systems.
// On Windows it gives the default interface's address, whereas on Linux it
// gives an error. We will make it fail on all platforms for consistency.
if (host.host().empty() || host.host().size() > kMaxHostLength) {
MakeNotStale(stale_info);
return ERR_NAME_NOT_RESOLVED;
}
int net_error = ERR_UNEXPECTED;
if (ResolveAsIP(*key, host.port(), ip_address_ptr, &net_error, addresses)) {
MakeNotStale(stale_info);
return net_error;
}
// Special-case localhost names, as per the recommendations in
// https://tools.ietf.org/html/draft-west-let-localhost-be-localhost.
if (ServeLocalhost(*key, host.port(), addresses)) {
MakeNotStale(stale_info);
return OK;
}
if (allow_cache && ServeFromCache(*key, host.port(), &net_error, addresses,
allow_stale, stale_info)) {
source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_CACHE_HIT,
addresses->CreateNetLogCallback());
// |ServeFromCache()| will set |*stale_info| as needed.
return net_error;
}
// TODO(szym): Do not do this if nsswitch.conf instructs not to.
// http://crbug.com/117655
if (ServeFromHosts(*key, host.port(), addresses)) {
source_net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_HOSTS_HIT,
addresses->CreateNetLogCallback());
MakeNotStale(stale_info);
return OK;
}
return ERR_DNS_CACHE_MISS;
}
int HostResolverImpl::CreateAndStartJob(const Key& key, RequestImpl* request) {
auto jobit = jobs_.find(key);
Job* job;
if (jobit == jobs_.end()) {
auto new_job = std::make_unique<Job>(
weak_ptr_factory_.GetWeakPtr(), key, request->priority(),
proc_task_runner_, request->source_net_log(), tick_clock_);
job = new_job.get();
new_job->Schedule(false);
// Check for queue overflow.
if (dispatcher_->num_queued_jobs() > max_queued_jobs_) {
Job* evicted = static_cast<Job*>(dispatcher_->EvictOldestLowest());
DCHECK(evicted);
evicted->OnEvicted();
if (evicted == new_job.get()) {
LogFinishRequest(request->source_net_log(),
ERR_HOST_RESOLVER_QUEUE_TOO_LARGE);
return ERR_HOST_RESOLVER_QUEUE_TOO_LARGE;
}
}
jobs_[key] = std::move(new_job);
} else {
job = jobit->second.get();
}
// Can't complete synchronously. Attach request and job to each other.
job->AddRequest(request);
return ERR_IO_PENDING;
}
bool HostResolverImpl::ResolveAsIP(const Key& key,
uint16_t host_port,
const IPAddress* ip_address,
int* net_error,
AddressList* addresses) {
DCHECK(addresses);
DCHECK(net_error);
if (ip_address == nullptr)
return false;
*net_error = OK;
AddressFamily family = GetAddressFamily(*ip_address);
if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED &&
key.address_family != family) {
// Don't return IPv6 addresses for IPv4 queries, and vice versa.
*net_error = ERR_NAME_NOT_RESOLVED;
} else {
*addresses = AddressList::CreateFromIPAddress(*ip_address, host_port);
if (key.host_resolver_flags & HOST_RESOLVER_CANONNAME)
addresses->SetDefaultCanonicalName();
}
return true;
}
bool HostResolverImpl::ServeFromCache(const Key& key,
uint16_t host_port,
int* net_error,
AddressList* addresses,
bool allow_stale,
HostCache::EntryStaleness* stale_info) {
DCHECK(addresses);
DCHECK(net_error);
DCHECK(allow_stale == !!stale_info);
if (!cache_.get())
return false;
const HostCache::Entry* cache_entry;
if (allow_stale)
cache_entry = cache_->LookupStale(key, tick_clock_->NowTicks(), stale_info);
else
cache_entry = cache_->Lookup(key, tick_clock_->NowTicks());
if (!cache_entry)
return false;
*net_error = cache_entry->error();
if (*net_error == OK) {
if (cache_entry->has_ttl())
RecordTTL(cache_entry->ttl());
*addresses = EnsurePortOnAddressList(cache_entry->addresses(), host_port);
}
return true;
}
bool HostResolverImpl::ServeFromHosts(const Key& key,
uint16_t host_port,
AddressList* addresses) {
DCHECK(addresses);
if (!HaveDnsConfig())
return false;
addresses->clear();
// HOSTS lookups are case-insensitive.
std::string hostname = base::ToLowerASCII(key.hostname);
const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
// If |address_family| is ADDRESS_FAMILY_UNSPECIFIED other implementations
// (glibc and c-ares) return the first matching line. We have more
// flexibility, but lose implicit ordering.
// We prefer IPv6 because "happy eyeballs" will fall back to IPv4 if
// necessary.
if (key.address_family == ADDRESS_FAMILY_IPV6 ||
key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
DnsHosts::const_iterator it = hosts.find(
DnsHostsKey(hostname, ADDRESS_FAMILY_IPV6));
if (it != hosts.end())
addresses->push_back(IPEndPoint(it->second, host_port));
}
if (key.address_family == ADDRESS_FAMILY_IPV4 ||
key.address_family == ADDRESS_FAMILY_UNSPECIFIED) {
DnsHosts::const_iterator it = hosts.find(
DnsHostsKey(hostname, ADDRESS_FAMILY_IPV4));
if (it != hosts.end())
addresses->push_back(IPEndPoint(it->second, host_port));
}
// If got only loopback addresses and the family was restricted, resolve
// again, without restrictions. See SystemHostResolverCall for rationale.
if ((key.host_resolver_flags &
HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) &&
IsAllIPv4Loopback(*addresses)) {
Key new_key(key);
new_key.address_family = ADDRESS_FAMILY_UNSPECIFIED;
new_key.host_resolver_flags &=
~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
return ServeFromHosts(new_key, host_port, addresses);
}
return !addresses->empty();
}
bool HostResolverImpl::ServeLocalhost(const Key& key,
uint16_t host_port,
AddressList* addresses) {
AddressList resolved_addresses;
if (!ResolveLocalHostname(key.hostname, host_port, &resolved_addresses))
return false;
addresses->clear();
for (const auto& address : resolved_addresses) {
// Include the address if:
// - caller didn't specify an address family, or
// - caller specifically asked for the address family of this address, or
// - this is an IPv6 address and caller specifically asked for IPv4 due
// to lack of detected IPv6 support. (See SystemHostResolverCall for
// rationale).
if (key.address_family == ADDRESS_FAMILY_UNSPECIFIED ||
key.address_family == address.GetFamily() ||
(address.GetFamily() == ADDRESS_FAMILY_IPV6 &&
key.address_family == ADDRESS_FAMILY_IPV4 &&
(key.host_resolver_flags &
HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6))) {
addresses->push_back(address);
}
}
return true;
}
void HostResolverImpl::CacheResult(const Key& key,
const HostCache::Entry& entry,
base::TimeDelta ttl) {
// Don't cache an error unless it has a positive TTL.
if (cache_.get() && (entry.error() == OK || ttl > base::TimeDelta()))
cache_->Set(key, entry, tick_clock_->NowTicks(), ttl);
}
std::unique_ptr<HostResolverImpl::Job> HostResolverImpl::RemoveJob(Job* job) {
DCHECK(job);
std::unique_ptr<Job> retval;
auto it = jobs_.find(job->key());
if (it != jobs_.end() && it->second.get() == job) {
it->second.swap(retval);
jobs_.erase(it);
}
return retval;
}
HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
const std::string& hostname,
DnsQueryType dns_query_type,
HostResolverSource source,
HostResolverFlags flags,
const IPAddress* ip_address,
const NetLogWithSource& net_log) {
HostResolverFlags effective_flags = flags | additional_resolver_flags_;
AddressFamily effective_address_family =
DnsQueryTypeToAddressFamily(dns_query_type);
if (effective_address_family == ADDRESS_FAMILY_UNSPECIFIED &&
// When resolving IPv4 literals, there's no need to probe for IPv6.
// When resolving IPv6 literals, there's no benefit to artificially
// limiting our resolution based on a probe. Prior logic ensures
// that this query is UNSPECIFIED (see effective_address_family
// check above) so the code requesting the resolution should be amenable
// to receiving a IPv6 resolution.
!use_local_ipv6_ && ip_address == nullptr && !IsIPv6Reachable(net_log)) {
effective_address_family = ADDRESS_FAMILY_IPV4;
effective_flags |= HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
}
return Key(hostname, effective_address_family, effective_flags, source);
}