[net/dns] Serve requests from HOSTS file if possible.

net/base/host_resolver_impl.cc

 // 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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
-#include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/address_family.h"
 #include "net/base/address_list.h"
 #include "net/base/address_list_net_log_param.h"
 #include "net/base/dns_reloader.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
+#include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_response.h"
-#include "net/dns/dns_session.h"
 #include "net/dns/dns_transaction.h"
-#include "net/socket/client_socket_factory.h"
 
 #if defined(OS_WIN)
 #include "net/base/winsock_init.h"
 #endif
 
 namespace net {
 
 namespace {
 
 // Limit the size of hostnames that will be resolved to combat issues in
@@ skipping 689 matching lines @@
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
     if (error == OK) {
       if (had_non_speculative_request_) {
         category = RESOLVE_SUCCESS;
         DNS_HISTOGRAM("DNS.ResolveSuccess", duration);
       } else {
         category = RESOLVE_SPECULATIVE_SUCCESS;
         DNS_HISTOGRAM("DNS.ResolveSpeculativeSuccess", duration);
       }
 
-      // Log DNS lookups based on address_family.  This will help us determine
+      // Log DNS lookups based on |address_family|. This will help us determine
       // if IPv4 or IPv4/6 lookups are faster or slower.
       switch(key_.address_family) {
         case ADDRESS_FAMILY_IPV4:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV4", duration);
           break;
         case ADDRESS_FAMILY_IPV6:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_IPV6", duration);
           break;
         case ADDRESS_FAMILY_UNSPECIFIED:
           DNS_HISTOGRAM("DNS.ResolveSuccess_FAMILY_UNSPEC", duration);
           break;
       }
     } else {
       if (had_non_speculative_request_) {
         category = RESOLVE_FAIL;
         DNS_HISTOGRAM("DNS.ResolveFail", duration);
       } else {
         category = RESOLVE_SPECULATIVE_FAIL;
         DNS_HISTOGRAM("DNS.ResolveSpeculativeFail", duration);
       }
-      // Log DNS lookups based on address_family.  This will help us determine
+      // Log DNS lookups based on |address_family|. This will help us determine
       // if IPv4 or IPv4/6 lookups are faster or slower.
       switch(key_.address_family) {
         case ADDRESS_FAMILY_IPV4:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV4", duration);
           break;
         case ADDRESS_FAMILY_IPV6:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_IPV6", duration);
           break;
         case ADDRESS_FAMILY_UNSPECIFIED:
           DNS_HISTOGRAM("DNS.ResolveFail_FAMILY_UNSPEC", duration);
@@ skipping 408 matching lines @@
     handle_.Reset();
 
     net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_EVICTED, NULL);
 
     // This signals to CompleteRequests that this job never ran.
     CompleteRequests(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE,
                      AddressList(),
                      base::TimeDelta());
   }
 
+  // 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_.front()->info(),
+                                  &addr_list)) {
+      // This will destroy the Job.
+      CompleteRequests(OK, addr_list, base::TimeDelta());
+      return true;
+    }
+    return false;
+  }
+
  private:
   RequestPriority priority() const {
     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_.get() != NULL;
   }
 
   bool is_proc_running() const {
     return proc_task_.get() != NULL;
   }
 
   // PriorityDispatch::Job:
   virtual void Start() OVERRIDE {
     DCHECK(!is_running());
     handle_.Reset();
 
     net_log_.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB_STARTED, NULL);
 
     // Job::Start must not complete synchronously.
-    if (resolver_->dns_transaction_factory_.get()) {
+    if (resolver_->HaveDnsConfig()) {
       StartDnsTask();
     } else {
       StartProcTask();
     }
   }
 
   // TODO(szym): Since DnsTransaction does not consume threads, we can increase
   // the limits on |dispatcher_|. But in order to keep the number of WorkerPool
   // threads low, we will need to use an "inner" PrioritizedDispatcher with
   // tighter limits.
@@ skipping 18 matching lines @@
 
     base::TimeDelta ttl = base::TimeDelta::FromSeconds(
         kNegativeCacheEntryTTLSeconds);
     if (net_error == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
 
     CompleteRequests(net_error, addr_list, ttl);
   }
 
   void StartDnsTask() {
+    DCHECK(resolver_->HaveDnsConfig());
     dns_task_.reset(new DnsTask(
-        resolver_->dns_transaction_factory_.get(),
+        resolver_->dns_client_->GetTransactionFactory(),
         key_,
         base::Bind(&Job::OnDnsTaskComplete, base::Unretained(this)),
         net_log_));
 
     int rv = dns_task_->Start();
     if (rv != ERR_IO_PENDING) {
       DCHECK_NE(OK, rv);
       dns_task_.reset();
       StartProcTask();
     }
   }
 
   // Called by DnsTask when it completes.
   void OnDnsTaskComplete(int net_error,
                          const AddressList& addr_list,
                          base::TimeDelta ttl) {
     DCHECK(is_dns_running());
 
     if (net_error != OK) {
       dns_task_.reset();
+
+      // 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.
       StartProcTask();
       return;
     }
 
     CompleteRequests(net_error, addr_list, ttl);
   }
 
   // Performs Job's last rites. Completes all Requests. Deletes this.
@@ skipping 32 matching lines @@
     if (num_active_requests() == 0) {
       net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                         OK);
       return;
     }
 
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                       net_error);
 
+    DCHECK(!requests_.empty());
+
     // We are the only consumer of |list|, so we can safely change the port
     // without copy-on-write. This pays off, when job has only one request.
-    if (net_error == OK && !requests_.empty())
+    if (net_error == OK)
       MutableSetPort(requests_.front()->info().port(), &list);
 
     if ((net_error != ERR_ABORTED) &&
         (net_error != ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)) {
       resolver_->CacheResult(key_, net_error, list, ttl);
     }
 
     // Complete all of the requests that were attached to the job.
     for (RequestsList::const_iterator it = requests_.begin();
          it != requests_.end(); ++it) {
@@ skipping 57 matching lines @@
     HostCache* cache,
     const PrioritizedDispatcher::Limits& job_limits,
     const ProcTaskParams& proc_params,
     scoped_ptr<DnsConfigService> dns_config_service,
     NetLog* net_log)
     : cache_(cache),
       dispatcher_(job_limits),
       max_queued_jobs_(job_limits.total_jobs * 100u),
       proc_params_(proc_params),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
+      dns_client_(NULL),
       dns_config_service_(dns_config_service.Pass()),
       ipv6_probe_monitoring_(false),
       additional_resolver_flags_(0),
       net_log_(net_log) {
 
   DCHECK_GE(dispatcher_.num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
 
   // Maximum of 4 retry attempts for host resolution.
   static const size_t kDefaultMaxRetryAttempts = 4u;
 
   if (proc_params_.max_retry_attempts == HostResolver::kDefaultRetryAttempts)
     proc_params_.max_retry_attempts = kDefaultMaxRetryAttempts;
 
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   if (HaveOnlyLoopbackAddresses())
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
 #endif
   NetworkChangeNotifier::AddIPAddressObserver(this);
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 #if !defined(OS_ANDROID)
   EnsureDnsReloaderInit();
 #endif
   NetworkChangeNotifier::AddDNSObserver(this);
 #endif
 
-  if (dns_config_service_.get())
+  if (dns_config_service_.get()) {
     dns_config_service_->AddObserver(this);
+    dns_client_ = DnsClient::CreateClient(net_log_);
+  }
 }
 
 HostResolverImpl::~HostResolverImpl() {
   DiscardIPv6ProbeJob();
 
   // This will also cancel all outstanding requests.
   STLDeleteValues(&jobs_);
 
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD)
@@ skipping 78 matching lines @@
                                     const BoundNetLog& request_net_log) {
   // 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 (info.hostname().empty() || info.hostname().size() > kMaxHostLength)
     return ERR_NAME_NOT_RESOLVED;
 
   int net_error = ERR_UNEXPECTED;
   if (ResolveAsIP(key, info, &net_error, addresses))
     return net_error;
-  net_error = ERR_DNS_CACHE_MISS;
-  ServeFromCache(key, info, request_net_log, &net_error, addresses);
-  return net_error;
+  if (ServeFromCache(key, info, &net_error, addresses)) {
+    request_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CACHE_HIT, NULL);
+    return net_error;
+  }
+  // TODO(szym): Do not do this if nsswitch.conf instructs not to.
+  // http://crbug.com/117655
+  if (ServeFromHosts(key, info, addresses)) {
+    request_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_HOSTS_HIT, NULL);
+    return OK;
+  }
+  return ERR_DNS_CACHE_MISS;
 }
 
 int HostResolverImpl::ResolveFromCache(const RequestInfo& info,
                                        AddressList* addresses,
                                        const BoundNetLog& source_net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(addresses);
 
   // Make a log item for the request.
   BoundNetLog request_net_log = BoundNetLog::Make(net_log_,
@@ skipping 62 matching lines @@
   } else {
     *addresses = AddressList::CreateFromIPAddressWithCname(
         ip_number, info.port(),
         (key.host_resolver_flags & HOST_RESOLVER_CANONNAME));
   }
   return true;
 }
 
 bool HostResolverImpl::ServeFromCache(const Key& key,
                                       const RequestInfo& info,
-                                      const BoundNetLog& request_net_log,
                                       int* net_error,
                                       AddressList* addresses) {
   DCHECK(addresses);
   DCHECK(net_error);
   if (!info.allow_cached_response() || !cache_.get())
     return false;
 
   const HostCache::Entry* cache_entry = cache_->Lookup(
       key, base::TimeTicks::Now());
   if (!cache_entry)
     return false;
 
-  request_net_log.AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CACHE_HIT, NULL);
+
   *net_error = cache_entry->error;
   if (*net_error == OK)
     *addresses = CreateAddressListUsingPort(cache_entry->addrlist, info.port());
   return true;
 }
 
+bool HostResolverImpl::ServeFromHosts(const Key& key,
+                                      const RequestInfo& info,
+                                      AddressList* addresses) {
+  DCHECK(addresses);
+  if (!HaveDnsConfig())
+    return false;
+
+  // 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.
+  // TODO(szym) http://crbug.com/117850
+  const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
+  DnsHosts::const_iterator it = hosts.find(
+      DnsHostsKey(key.hostname,
+                  key.address_family == ADDRESS_FAMILY_UNSPECIFIED ?
+                      ADDRESS_FAMILY_IPV4 : key.address_family));
+
+  if (it == hosts.end()) {
+    if (key.address_family != ADDRESS_FAMILY_UNSPECIFIED)
+      return false;
+
+    it = hosts.find(DnsHostsKey(key.hostname, ADDRESS_FAMILY_IPV6));
+    if (it == hosts.end())
+      return false;
+  }
+
+  *addresses = AddressList::CreateFromIPAddress(it->second, info.port());
+  return true;
+}
+
 void HostResolverImpl::CacheResult(const Key& key,
                                    int net_error,
                                    const AddressList& addr_list,
                                    base::TimeDelta ttl) {
   if (cache_.get())
     cache_->Set(key, net_error, addr_list, base::TimeTicks::Now(), ttl);
 }
 
 void HostResolverImpl::RemoveJob(Job* job) {
   DCHECK(job);
@@ skipping 57 matching lines @@
 
   // Life check to bail once |this| is deleted.
   base::WeakPtr<HostResolverImpl> self = AsWeakPtr();
 
   // Then Abort them.
   for (size_t i = 0; self && i < jobs_to_abort.size(); ++i) {
     jobs_to_abort[i]->Abort();
   }
 }
 
+void HostResolverImpl::TryServingAllJobsFromHosts() {
+  if (!HaveDnsConfig())
+    return;
+
+  // TODO(szym): Do not do this if nsswitch.conf instructs not to.
+  // http://crbug.com/117655
+
+  // Life check to bail once |this| is deleted.
+  base::WeakPtr<HostResolverImpl> self = AsWeakPtr();
+
+  for (JobMap::iterator it = jobs_.begin(); self && it != jobs_.end(); ) {
+    Job* job = it->second;
+    ++it;
+    // This could remove |job| from |jobs_|, but iterator will remain valid.
+    job->ServeFromHosts();
+  }
+}
+
 void HostResolverImpl::OnIPAddressChanged() {
   if (cache_.get())
     cache_->clear();
   if (ipv6_probe_monitoring_) {
     DiscardIPv6ProbeJob();
     ipv6_probe_job_ = new IPv6ProbeJob(this);
     ipv6_probe_job_->Start();
   }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   if (HaveOnlyLoopbackAddresses()) {
@@ skipping 15 matching lines @@
     cache_->clear();
   // Existing jobs will have been sent to the original server so they need to
   // be aborted. TODO(Craig): Should these jobs be restarted?
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 void HostResolverImpl::OnConfigChanged(const DnsConfig& dns_config) {
   // We want a new factory in place, before we Abort running Jobs, so that the
   // newly started jobs use the new factory.
-  bool had_factory = (dns_transaction_factory_.get() != NULL);
-  if (dns_config.IsValid()) {
-    dns_transaction_factory_ = DnsTransactionFactory::CreateFactory(
-        new DnsSession(dns_config,
-                       ClientSocketFactory::GetDefaultFactory(),
-                       base::Bind(&base::RandInt),
-                       net_log_));
-  } else {
-    dns_transaction_factory_.reset();
-  }
+  DCHECK(dns_client_.get());
+
+  // Life check to bail once |this| is deleted.
+  base::WeakPtr<HostResolverImpl> self = AsWeakPtr();
+
+  bool had_factory = (dns_client_->GetConfig() != NULL);
+  dns_client_->SetConfig(dns_config);
+
   // Don't Abort running Jobs unless they were running on DnsTransaction.
   // TODO(szym): This will change once http://crbug.com/114827 is fixed.
   if (had_factory)
     OnDNSChanged(NetworkChangeNotifier::CHANGE_DNS_SETTINGS);
+
+  if (self && dns_config.IsValid())
+    TryServingAllJobsFromHosts();
+}
+
+bool HostResolverImpl::HaveDnsConfig() const {
+  return (dns_client_.get() != NULL) && (dns_client_->GetConfig() != NULL);
 }
 
 }  // namespace net