[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>
@@ skipping 1187 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());
   }
 
+  // Attempt to serve the job from hosts.
+  void ServeFromHosts() {

[szym, 2012/03/10 06:48:49]

Add a bool return so that the caller knows if this Job was destroyed or not.

+    DCHECK_GT(num_active_requests(), 0u);
+    AddressList addr_list;
+    if (resolver_->ServeFromHosts(key(),
+                                  requests_.front()->info(),
+                                  &addr_list)) {
+      CompleteRequests(OK, addr_list, base::TimeDelta());
+    }
+  }
+
  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();
   }
 
@@ skipping 67 matching lines @@
   }
 
   // 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 185 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 (!dns_session_)
+    return false;
+
+  const DnsHosts& hosts = dns_session_->config().hosts;
+  DnsHosts::const_iterator it = hosts.find(DnsHostsKey(key.hostname,
+                                                       key.address_family));
+  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 (!dns_session_)
+    return;
+
+  // TODO(szym): Do not do this if nsswitch.conf instructs not to.
+  // http://crbug.com/117655
+
+  for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ) {
+    Job* job = (it++)->second;
+    // This could remove |job| from |jobs_|, but iterators remain valid.
+    job->ServeFromHosts();

[szym, 2012/03/10 06:48:49]

HostResolverImpl could be destroyed in Request callback. Use self health check
as in AbortAllInProgressJobs.

+  }
+}
+
 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 17 matching lines @@
   // 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_));
+    dns_session_ = new DnsSession(dns_config,
+                                  ClientSocketFactory::GetDefaultFactory(),
+                                  base::Bind(&base::RandInt),
+                                  net_log_);
+    dns_transaction_factory_ =
+        DnsTransactionFactory::CreateFactory(dns_session_);
+
+    TryServingAllJobsFromHosts();
   } else {
     dns_transaction_factory_.reset();
+    dns_session_.release();
   }
   // 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);
 }
 
 }  // namespace net