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
IsAllLocalhostOfOneFamily(const struct addrinfo * ai)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
HostResolverProc(HostResolverProc * previous)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
~HostResolverProc()69 HostResolverProc::~HostResolverProc() {
70 }
71
ResolveUsingPrevious(const std::string & host,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error)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
SetPreviousProc(HostResolverProc * proc)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
SetLastProc(HostResolverProc * proc)96 void HostResolverProc::SetLastProc(HostResolverProc* proc) {
97 GetLastProc(this)->SetPreviousProc(proc);
98 }
99
100 // static
GetLastProc(HostResolverProc * proc)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
SetDefault(HostResolverProc * proc)111 HostResolverProc* HostResolverProc::SetDefault(HostResolverProc* proc) {
112 HostResolverProc* old = default_proc_;
113 default_proc_ = proc;
114 return old;
115 }
116
117 // static
GetDefault()118 HostResolverProc* HostResolverProc::GetDefault() {
119 return default_proc_;
120 }
121
SystemHostResolverCall(const std::string & host,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error)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
SystemHostResolverProc()251 SystemHostResolverProc::SystemHostResolverProc() : HostResolverProc(NULL) {}
252
Resolve(const std::string & hostname,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addr_list,int * os_error)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
~SystemHostResolverProc()265 SystemHostResolverProc::~SystemHostResolverProc() {}
266
267 } // namespace net
268