Home | History | Annotate | Download | only in dns 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/dns/host_resolver_proc.h"
      6 
      7 #include "build/build_config.h"
      8 
      9 #include "base/logging.h"
     10 #include "base/sys_byteorder.h"
     11 #include "net/base/address_list.h"
     12 #include "net/base/dns_reloader.h"
     13 #include "net/base/net_errors.h"
     14 #include "net/base/sys_addrinfo.h"
     15 
     16 #if defined(OS_OPENBSD)
     17 #define AI_ADDRCONFIG 0
     18 #endif
     19 
     20 namespace net {
     21 
     22 namespace {
     23 
     24 bool IsAllLocalhostOfOneFamily(const struct addrinfo* ai) {
     25   bool saw_v4_localhost = false;
     26   bool saw_v6_localhost = false;
     27   for (; ai != NULL; ai = ai->ai_next) {
     28     switch (ai->ai_family) {
     29       case AF_INET: {
     30         const struct sockaddr_in* addr_in =
     31             reinterpret_cast<struct sockaddr_in*>(ai->ai_addr);
     32         if ((base::NetToHost32(addr_in->sin_addr.s_addr) & 0xff000000) ==
     33             0x7f000000)
     34           saw_v4_localhost = true;
     35         else
     36           return false;
     37         break;
     38       }
     39       case AF_INET6: {
     40         const struct sockaddr_in6* addr_in6 =
     41             reinterpret_cast<struct sockaddr_in6*>(ai->ai_addr);
     42         if (IN6_IS_ADDR_LOOPBACK(&addr_in6->sin6_addr))
     43           saw_v6_localhost = true;
     44         else
     45           return false;
     46         break;
     47       }
     48       default:
     49         NOTREACHED();
     50         return false;
     51     }
     52   }
     53 
     54   return saw_v4_localhost != saw_v6_localhost;
     55 }
     56 
     57 }  // namespace
     58 
     59 HostResolverProc* HostResolverProc::default_proc_ = NULL;
     60 
     61 HostResolverProc::HostResolverProc(HostResolverProc* previous) {
     62   SetPreviousProc(previous);
     63 
     64   // Implicitly fall-back to the global default procedure.
     65   if (!previous)
     66     SetPreviousProc(default_proc_);
     67 }
     68 
     69 HostResolverProc::~HostResolverProc() {
     70 }
     71 
     72 int HostResolverProc::ResolveUsingPrevious(
     73     const std::string& host,
     74     AddressFamily address_family,
     75     HostResolverFlags host_resolver_flags,
     76     AddressList* addrlist,
     77     int* os_error) {
     78   if (previous_proc_.get()) {
     79     return previous_proc_->Resolve(
     80         host, address_family, host_resolver_flags, addrlist, os_error);
     81   }
     82 
     83   // Final fallback is the system resolver.
     84   return SystemHostResolverCall(host, address_family, host_resolver_flags,
     85                                 addrlist, os_error);
     86 }
     87 
     88 void HostResolverProc::SetPreviousProc(HostResolverProc* proc) {
     89   HostResolverProc* current_previous = previous_proc_.get();
     90   previous_proc_ = NULL;
     91   // Now that we've guaranteed |this| is the last proc in a chain, we can
     92   // detect potential cycles using GetLastProc().
     93   previous_proc_ = (GetLastProc(proc) == this) ? current_previous : proc;
     94 }
     95 
     96 void HostResolverProc::SetLastProc(HostResolverProc* proc) {
     97   GetLastProc(this)->SetPreviousProc(proc);
     98 }
     99 
    100 // static
    101 HostResolverProc* HostResolverProc::GetLastProc(HostResolverProc* proc) {
    102   if (proc == NULL)
    103     return NULL;
    104   HostResolverProc* last_proc = proc;
    105   while (last_proc->previous_proc_.get() != NULL)
    106     last_proc = last_proc->previous_proc_.get();
    107   return last_proc;
    108 }
    109 
    110 // static
    111 HostResolverProc* HostResolverProc::SetDefault(HostResolverProc* proc) {
    112   HostResolverProc* old = default_proc_;
    113   default_proc_ = proc;
    114   return old;
    115 }
    116 
    117 // static
    118 HostResolverProc* HostResolverProc::GetDefault() {
    119   return default_proc_;
    120 }
    121 
    122 int SystemHostResolverCall(const std::string& host,
    123                            AddressFamily address_family,
    124                            HostResolverFlags host_resolver_flags,
    125                            AddressList* addrlist,
    126                            int* os_error) {
    127   if (os_error)
    128     *os_error = 0;
    129 
    130   struct addrinfo* ai = NULL;
    131   struct addrinfo hints = {0};
    132 
    133   switch (address_family) {
    134     case ADDRESS_FAMILY_IPV4:
    135       hints.ai_family = AF_INET;
    136       break;
    137     case ADDRESS_FAMILY_IPV6:
    138       hints.ai_family = AF_INET6;
    139       break;
    140     case ADDRESS_FAMILY_UNSPECIFIED:
    141       hints.ai_family = AF_UNSPEC;
    142       break;
    143     default:
    144       NOTREACHED();
    145       hints.ai_family = AF_UNSPEC;
    146   }
    147 
    148 #if defined(OS_WIN)
    149   // DO NOT USE AI_ADDRCONFIG ON WINDOWS.
    150   //
    151   // The following comment in <winsock2.h> is the best documentation I found
    152   // on AI_ADDRCONFIG for Windows:
    153   //   Flags used in "hints" argument to getaddrinfo()
    154   //       - AI_ADDRCONFIG is supported starting with Vista
    155   //       - default is AI_ADDRCONFIG ON whether the flag is set or not
    156   //         because the performance penalty in not having ADDRCONFIG in
    157   //         the multi-protocol stack environment is severe;
    158   //         this defaulting may be disabled by specifying the AI_ALL flag,
    159   //         in that case AI_ADDRCONFIG must be EXPLICITLY specified to
    160   //         enable ADDRCONFIG behavior
    161   //
    162   // Not only is AI_ADDRCONFIG unnecessary, but it can be harmful.  If the
    163   // computer is not connected to a network, AI_ADDRCONFIG causes getaddrinfo
    164   // to fail with WSANO_DATA (11004) for "localhost", probably because of the
    165   // following note on AI_ADDRCONFIG in the MSDN getaddrinfo page:
    166   //   The IPv4 or IPv6 loopback address is not considered a valid global
    167   //   address.
    168   // See http://crbug.com/5234.
    169   //
    170   // OpenBSD does not support it, either.
    171   hints.ai_flags = 0;
    172 #else
    173   hints.ai_flags = AI_ADDRCONFIG;
    174 #endif
    175 
    176   // On Linux AI_ADDRCONFIG doesn't consider loopback addreses, even if only
    177   // loopback addresses are configured. So don't use it when there are only
    178   // loopback addresses.
    179   if (host_resolver_flags & HOST_RESOLVER_LOOPBACK_ONLY)
    180     hints.ai_flags &= ~AI_ADDRCONFIG;
    181 
    182   if (host_resolver_flags & HOST_RESOLVER_CANONNAME)
    183     hints.ai_flags |= AI_CANONNAME;
    184 
    185   // Restrict result set to only this socket type to avoid duplicates.
    186   hints.ai_socktype = SOCK_STREAM;
    187 
    188 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \
    189     !defined(OS_ANDROID)
    190   DnsReloaderMaybeReload();
    191 #endif
    192   int err = getaddrinfo(host.c_str(), NULL, &hints, &ai);
    193   bool should_retry = false;
    194   // If the lookup was restricted (either by address family, or address
    195   // detection), and the results where all localhost of a single family,
    196   // maybe we should retry.  There were several bugs related to these
    197   // issues, for example http://crbug.com/42058 and http://crbug.com/49024
    198   if ((hints.ai_family != AF_UNSPEC || hints.ai_flags & AI_ADDRCONFIG) &&
    199       err == 0 && IsAllLocalhostOfOneFamily(ai)) {
    200     if (host_resolver_flags & HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6) {
    201       hints.ai_family = AF_UNSPEC;
    202       should_retry = true;
    203     }
    204     if (hints.ai_flags & AI_ADDRCONFIG) {
    205       hints.ai_flags &= ~AI_ADDRCONFIG;
    206       should_retry = true;
    207     }
    208   }
    209   if (should_retry) {
    210     if (ai != NULL) {
    211       freeaddrinfo(ai);
    212       ai = NULL;
    213     }
    214     err = getaddrinfo(host.c_str(), NULL, &hints, &ai);
    215   }
    216 
    217   if (err) {
    218 #if defined(OS_WIN)
    219     err = WSAGetLastError();
    220 #endif
    221 
    222     // Return the OS error to the caller.
    223     if (os_error)
    224       *os_error = err;
    225 
    226     // If the call to getaddrinfo() failed because of a system error, report
    227     // it separately from ERR_NAME_NOT_RESOLVED.
    228 #if defined(OS_WIN)
    229     if (err != WSAHOST_NOT_FOUND && err != WSANO_DATA)
    230       return ERR_NAME_RESOLUTION_FAILED;
    231 #elif defined(OS_POSIX) && !defined(OS_FREEBSD)
    232     if (err != EAI_NONAME && err != EAI_NODATA)
    233       return ERR_NAME_RESOLUTION_FAILED;
    234 #endif
    235 
    236     return ERR_NAME_NOT_RESOLVED;
    237   }
    238 
    239 #if defined(OS_ANDROID)
    240   // Workaround for Android's getaddrinfo leaving ai==NULL without an error.
    241   // http://crbug.com/134142
    242   if (ai == NULL)
    243     return ERR_NAME_NOT_RESOLVED;
    244 #endif
    245 
    246   *addrlist = AddressList::CreateFromAddrinfo(ai);
    247   freeaddrinfo(ai);
    248   return OK;
    249 }
    250 
    251 SystemHostResolverProc::SystemHostResolverProc() : HostResolverProc(NULL) {}
    252 
    253 int SystemHostResolverProc::Resolve(const std::string& hostname,
    254                                     AddressFamily address_family,
    255                                     HostResolverFlags host_resolver_flags,
    256                                     AddressList* addr_list,
    257                                     int* os_error) {
    258   return SystemHostResolverCall(hostname,
    259                                 address_family,
    260                                 host_resolver_flags,
    261                                 addr_list,
    262                                 os_error);
    263 }
    264 
    265 SystemHostResolverProc::~SystemHostResolverProc() {}
    266 
    267 }  // namespace net
    268