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_manager.h"
6
7 #include <algorithm>
8 #include <limits>
9 #include <string>
10 #include <tuple>
11 #include <utility>
12 #include <vector>
13
14 #include "base/auto_reset.h"
15 #include "base/bind.h"
16 #include "base/bind_helpers.h"
17 #include "base/location.h"
18 #include "base/macros.h"
19 #include "base/memory/ref_counted.h"
20 #include "base/numerics/safe_conversions.h"
21 #include "base/rand_util.h"
22 #include "base/run_loop.h"
23 #include "base/sequenced_task_runner.h"
24 #include "base/single_thread_task_runner.h"
25 #include "base/stl_util.h"
26 #include "base/strings/string_util.h"
27 #include "base/strings/stringprintf.h"
28 #include "base/synchronization/condition_variable.h"
29 #include "base/synchronization/lock.h"
30 #include "base/task/post_task.h"
31 #include "base/task/thread_pool/thread_pool_instance.h"
32 #include "base/test/bind_test_util.h"
33 #include "base/test/metrics/histogram_tester.h"
34 #include "base/test/scoped_feature_list.h"
35 #include "base/test/simple_test_clock.h"
36 #include "base/test/test_mock_time_task_runner.h"
37 #include "base/test/test_timeouts.h"
38 #include "base/threading/thread_restrictions.h"
39 #include "base/threading/thread_task_runner_handle.h"
40 #include "base/time/time.h"
41 #include "base/timer/mock_timer.h"
42 #include "base/values.h"
43 #include "build/build_config.h"
44 #include "net/base/address_list.h"
45 #include "net/base/features.h"
46 #include "net/base/host_port_pair.h"
47 #include "net/base/ip_address.h"
48 #include "net/base/ip_endpoint.h"
49 #include "net/base/mock_network_change_notifier.h"
50 #include "net/base/net_errors.h"
51 #include "net/base/network_isolation_key.h"
52 #include "net/dns/dns_client.h"
53 #include "net/dns/dns_config.h"
54 #include "net/dns/dns_test_util.h"
55 #include "net/dns/dns_util.h"
56 #include "net/dns/mock_host_resolver.h"
57 #include "net/dns/mock_mdns_client.h"
58 #include "net/dns/mock_mdns_socket_factory.h"
59 #include "net/dns/public/dns_over_https_server_config.h"
60 #include "net/dns/public/resolve_error_info.h"
61 #include "net/dns/resolve_context.h"
62 #include "net/dns/test_dns_config_service.h"
63 #include "net/log/net_log_event_type.h"
64 #include "net/log/net_log_source_type.h"
65 #include "net/log/net_log_with_source.h"
66 #include "net/log/test_net_log.h"
67 #include "net/log/test_net_log_util.h"
68 #include "net/socket/socket_test_util.h"
69 #include "net/test/gtest_util.h"
70 #include "net/test/test_with_task_environment.h"
71 #include "net/url_request/url_request_context.h"
72 #include "net/url_request/url_request_test_util.h"
73 #include "testing/gmock/include/gmock/gmock.h"
74 #include "testing/gtest/include/gtest/gtest.h"
75 #include "url/gurl.h"
76 #include "url/origin.h"
77
78 #if BUILDFLAG(ENABLE_MDNS)
79 #include "net/dns/mdns_client_impl.h"
80 #endif // BUILDFLAG(ENABLE_MDNS)
81
82 using net::test::IsError;
83 using net::test::IsOk;
84 using ::testing::_;
85 using ::testing::AllOf;
86 using ::testing::Between;
87 using ::testing::ByMove;
88 using ::testing::Eq;
89 using ::testing::Optional;
90 using ::testing::Pair;
91 using ::testing::Property;
92 using ::testing::Return;
93 using ::testing::UnorderedElementsAre;
94
95 namespace net {
96
97 namespace {
98
99 const size_t kMaxJobs = 10u;
100 const size_t kMaxRetryAttempts = 4u;
101
DefaultParams(HostResolverProc * resolver_proc)102 ProcTaskParams DefaultParams(HostResolverProc* resolver_proc) {
103 return ProcTaskParams(resolver_proc, kMaxRetryAttempts);
104 }
105
106 // A HostResolverProc that pushes each host mapped into a list and allows
107 // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc
108 // it never calls SystemHostResolverCall. By default resolves all hostnames to
109 // "127.0.0.1". After AddRule(), it resolves only names explicitly specified.
110 class MockHostResolverProc : public HostResolverProc {
111 public:
112 struct ResolveKey {
ResolveKeynet::__anon547890060111::MockHostResolverProc::ResolveKey113 ResolveKey(const std::string& hostname,
114 AddressFamily address_family,
115 HostResolverFlags flags)
116 : hostname(hostname), address_family(address_family), flags(flags) {}
operator <net::__anon547890060111::MockHostResolverProc::ResolveKey117 bool operator<(const ResolveKey& other) const {
118 return std::tie(address_family, hostname, flags) <
119 std::tie(other.address_family, other.hostname, other.flags);
120 }
121 std::string hostname;
122 AddressFamily address_family;
123 HostResolverFlags flags;
124 };
125
126 typedef std::vector<ResolveKey> CaptureList;
127
MockHostResolverProc()128 MockHostResolverProc()
129 : HostResolverProc(nullptr),
130 num_requests_waiting_(0),
131 num_slots_available_(0),
132 requests_waiting_(&lock_),
133 slots_available_(&lock_) {}
134
135 // Waits until |count| calls to |Resolve| are blocked. Returns false when
136 // timed out.
WaitFor(unsigned count)137 bool WaitFor(unsigned count) {
138 base::AutoLock lock(lock_);
139 base::Time start_time = base::Time::Now();
140 while (num_requests_waiting_ < count) {
141 requests_waiting_.TimedWait(TestTimeouts::action_timeout());
142 if (base::Time::Now() > start_time + TestTimeouts::action_timeout())
143 return false;
144 }
145 return true;
146 }
147
148 // Signals |count| waiting calls to |Resolve|. First come first served.
SignalMultiple(unsigned count)149 void SignalMultiple(unsigned count) {
150 base::AutoLock lock(lock_);
151 num_slots_available_ += count;
152 slots_available_.Broadcast();
153 }
154
155 // Signals all waiting calls to |Resolve|. Beware of races.
SignalAll()156 void SignalAll() {
157 base::AutoLock lock(lock_);
158 num_slots_available_ = num_requests_waiting_;
159 slots_available_.Broadcast();
160 }
161
AddRule(const std::string & hostname,AddressFamily family,const AddressList & result,HostResolverFlags flags=0)162 void AddRule(const std::string& hostname,
163 AddressFamily family,
164 const AddressList& result,
165 HostResolverFlags flags = 0) {
166 base::AutoLock lock(lock_);
167 rules_[ResolveKey(hostname, family, flags)] = result;
168 }
169
AddRule(const std::string & hostname,AddressFamily family,const std::string & ip_list,HostResolverFlags flags=0,const std::string & canonical_name="")170 void AddRule(const std::string& hostname,
171 AddressFamily family,
172 const std::string& ip_list,
173 HostResolverFlags flags = 0,
174 const std::string& canonical_name = "") {
175 AddressList result;
176 int rv = ParseAddressList(ip_list, canonical_name, &result);
177 DCHECK_EQ(OK, rv);
178 AddRule(hostname, family, result, flags);
179 }
180
AddRuleForAllFamilies(const std::string & hostname,const std::string & ip_list,HostResolverFlags flags=0,const std::string & canonical_name="")181 void AddRuleForAllFamilies(const std::string& hostname,
182 const std::string& ip_list,
183 HostResolverFlags flags = 0,
184 const std::string& canonical_name = "") {
185 AddressList result;
186 int rv = ParseAddressList(ip_list, canonical_name, &result);
187 DCHECK_EQ(OK, rv);
188 AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result, flags);
189 AddRule(hostname, ADDRESS_FAMILY_IPV4, result, flags);
190 AddRule(hostname, ADDRESS_FAMILY_IPV6, result, flags);
191 }
192
Resolve(const std::string & hostname,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error)193 int Resolve(const std::string& hostname,
194 AddressFamily address_family,
195 HostResolverFlags host_resolver_flags,
196 AddressList* addrlist,
197 int* os_error) override {
198 base::AutoLock lock(lock_);
199 capture_list_.push_back(
200 ResolveKey(hostname, address_family, host_resolver_flags));
201 ++num_requests_waiting_;
202 requests_waiting_.Broadcast();
203 {
204 base::ScopedAllowBaseSyncPrimitivesForTesting
205 scoped_allow_base_sync_primitives;
206 while (!num_slots_available_)
207 slots_available_.Wait();
208 }
209 DCHECK_GT(num_requests_waiting_, 0u);
210 --num_slots_available_;
211 --num_requests_waiting_;
212 if (rules_.empty()) {
213 int rv = ParseAddressList("127.0.0.1", std::string(), addrlist);
214 DCHECK_EQ(OK, rv);
215 return OK;
216 }
217 // Ignore HOST_RESOLVER_SYSTEM_ONLY, since it should have no impact on
218 // whether a rule matches. It should only affect cache lookups.
219 ResolveKey key(hostname, address_family,
220 host_resolver_flags & ~HOST_RESOLVER_SYSTEM_ONLY);
221 if (rules_.count(key) == 0)
222 return ERR_NAME_NOT_RESOLVED;
223 *addrlist = rules_[key];
224 return OK;
225 }
226
GetCaptureList() const227 CaptureList GetCaptureList() const {
228 CaptureList copy;
229 {
230 base::AutoLock lock(lock_);
231 copy = capture_list_;
232 }
233 return copy;
234 }
235
ClearCaptureList()236 void ClearCaptureList() {
237 base::AutoLock lock(lock_);
238 capture_list_.clear();
239 }
240
HasBlockedRequests() const241 bool HasBlockedRequests() const {
242 base::AutoLock lock(lock_);
243 return num_requests_waiting_ > num_slots_available_;
244 }
245
246 protected:
247 ~MockHostResolverProc() override = default;
248
249 private:
250 mutable base::Lock lock_;
251 std::map<ResolveKey, AddressList> rules_;
252 CaptureList capture_list_;
253 unsigned num_requests_waiting_;
254 unsigned num_slots_available_;
255 base::ConditionVariable requests_waiting_;
256 base::ConditionVariable slots_available_;
257
258 DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc);
259 };
260
261 class ResolveHostResponseHelper {
262 public:
263 using Callback =
264 base::OnceCallback<void(CompletionOnceCallback completion_callback,
265 int error)>;
266
267 ResolveHostResponseHelper() = default;
ResolveHostResponseHelper(std::unique_ptr<HostResolverManager::CancellableResolveHostRequest> request)268 explicit ResolveHostResponseHelper(
269 std::unique_ptr<HostResolverManager::CancellableResolveHostRequest>
270 request)
271 : request_(std::move(request)) {
272 top_level_result_error_ = request_->Start(base::BindOnce(
273 &ResolveHostResponseHelper::OnComplete, base::Unretained(this)));
274 }
ResolveHostResponseHelper(std::unique_ptr<HostResolverManager::CancellableResolveHostRequest> request,Callback custom_callback)275 ResolveHostResponseHelper(
276 std::unique_ptr<HostResolverManager::CancellableResolveHostRequest>
277 request,
278 Callback custom_callback)
279 : request_(std::move(request)) {
280 top_level_result_error_ = request_->Start(
281 base::BindOnce(std::move(custom_callback),
282 base::BindOnce(&ResolveHostResponseHelper::OnComplete,
283 base::Unretained(this))));
284 }
285
complete() const286 bool complete() const { return top_level_result_error_ != ERR_IO_PENDING; }
287
top_level_result_error()288 int top_level_result_error() {
289 WaitForCompletion();
290 return top_level_result_error_;
291 }
292
result_error()293 int result_error() {
294 WaitForCompletion();
295 return request_->GetResolveErrorInfo().error;
296 }
297
request()298 HostResolverManager::CancellableResolveHostRequest* request() {
299 return request_.get();
300 }
301
CancelRequest()302 void CancelRequest() {
303 DCHECK(request_);
304 DCHECK(!complete());
305
306 request_ = nullptr;
307 }
308
OnComplete(int error)309 void OnComplete(int error) {
310 DCHECK(!complete());
311 top_level_result_error_ = error;
312
313 run_loop_.Quit();
314 }
315
316 private:
WaitForCompletion()317 void WaitForCompletion() {
318 DCHECK(request_);
319 if (complete()) {
320 return;
321 }
322 run_loop_.Run();
323 DCHECK(complete());
324 }
325
326 std::unique_ptr<HostResolverManager::CancellableResolveHostRequest> request_;
327 int top_level_result_error_ = ERR_IO_PENDING;
328 base::RunLoop run_loop_;
329
330 DISALLOW_COPY_AND_ASSIGN(ResolveHostResponseHelper);
331 };
332
333 // Using LookupAttemptHostResolverProc simulate very long lookups, and control
334 // which attempt resolves the host.
335 class LookupAttemptHostResolverProc : public HostResolverProc {
336 public:
LookupAttemptHostResolverProc(HostResolverProc * previous,int attempt_number_to_resolve,int total_attempts)337 LookupAttemptHostResolverProc(HostResolverProc* previous,
338 int attempt_number_to_resolve,
339 int total_attempts)
340 : HostResolverProc(previous),
341 attempt_number_to_resolve_(attempt_number_to_resolve),
342 current_attempt_number_(0),
343 total_attempts_(total_attempts),
344 total_attempts_resolved_(0),
345 resolved_attempt_number_(0),
346 num_attempts_waiting_(0),
347 all_done_(&lock_),
348 blocked_attempt_signal_(&lock_) {}
349
350 // Test harness will wait for all attempts to finish before checking the
351 // results.
WaitForAllAttemptsToFinish()352 void WaitForAllAttemptsToFinish() {
353 base::AutoLock auto_lock(lock_);
354 while (total_attempts_resolved_ != total_attempts_) {
355 all_done_.Wait();
356 }
357 }
358
WaitForNAttemptsToBeBlocked(int n)359 void WaitForNAttemptsToBeBlocked(int n) {
360 base::AutoLock auto_lock(lock_);
361 while (num_attempts_waiting_ < n) {
362 blocked_attempt_signal_.Wait();
363 }
364 }
365
366 // All attempts will wait for an attempt to resolve the host.
WaitForAnAttemptToComplete()367 void WaitForAnAttemptToComplete() {
368 {
369 base::AutoLock auto_lock(lock_);
370 base::ScopedAllowBaseSyncPrimitivesForTesting
371 scoped_allow_base_sync_primitives;
372 while (resolved_attempt_number_ == 0)
373 all_done_.Wait();
374 }
375 all_done_.Broadcast(); // Tell all waiting attempts to proceed.
376 }
377
378 // Returns the number of attempts that have finished the Resolve() method.
GetTotalAttemptsResolved()379 int GetTotalAttemptsResolved() {
380 base::AutoLock auto_lock(lock_);
381 return total_attempts_resolved_;
382 }
383
384 // Sets the resolved attempt number and unblocks waiting
385 // attempts.
SetResolvedAttemptNumber(int n)386 void SetResolvedAttemptNumber(int n) {
387 base::AutoLock auto_lock(lock_);
388 EXPECT_EQ(0, resolved_attempt_number_);
389 resolved_attempt_number_ = n;
390 all_done_.Broadcast();
391 }
392
393 // HostResolverProc methods.
Resolve(const std::string & host,AddressFamily address_family,HostResolverFlags host_resolver_flags,AddressList * addrlist,int * os_error)394 int Resolve(const std::string& host,
395 AddressFamily address_family,
396 HostResolverFlags host_resolver_flags,
397 AddressList* addrlist,
398 int* os_error) override {
399 bool wait_for_right_attempt_to_complete = true;
400 {
401 base::AutoLock auto_lock(lock_);
402 ++current_attempt_number_;
403 ++num_attempts_waiting_;
404 if (current_attempt_number_ == attempt_number_to_resolve_) {
405 resolved_attempt_number_ = current_attempt_number_;
406 wait_for_right_attempt_to_complete = false;
407 }
408 }
409
410 blocked_attempt_signal_.Broadcast();
411
412 if (wait_for_right_attempt_to_complete)
413 // Wait for the attempt_number_to_resolve_ attempt to resolve.
414 WaitForAnAttemptToComplete();
415
416 int result = ResolveUsingPrevious(host, address_family, host_resolver_flags,
417 addrlist, os_error);
418
419 {
420 base::AutoLock auto_lock(lock_);
421 ++total_attempts_resolved_;
422 --num_attempts_waiting_;
423 }
424
425 all_done_.Broadcast(); // Tell all attempts to proceed.
426
427 // Since any negative number is considered a network error, with -1 having
428 // special meaning (ERR_IO_PENDING). We could return the attempt that has
429 // resolved the host as a negative number. For example, if attempt number 3
430 // resolves the host, then this method returns -4.
431 if (result == OK)
432 return -1 - resolved_attempt_number_;
433 else
434 return result;
435 }
436
437 protected:
438 ~LookupAttemptHostResolverProc() override = default;
439
440 private:
441 int attempt_number_to_resolve_;
442 int current_attempt_number_; // Incremented whenever Resolve is called.
443 int total_attempts_;
444 int total_attempts_resolved_;
445 int resolved_attempt_number_;
446 int num_attempts_waiting_;
447
448 // All attempts wait for right attempt to be resolve.
449 base::Lock lock_;
450 base::ConditionVariable all_done_;
451 base::ConditionVariable blocked_attempt_signal_;
452 };
453
454 // TestHostResolverManager's sole purpose is to mock the IPv6 reachability test.
455 // By default, this pretends that IPv6 is globally reachable.
456 // This class is necessary so unit tests run the same on dual-stack machines as
457 // well as IPv4 only machines.
458 class TestHostResolverManager : public HostResolverManager {
459 public:
TestHostResolverManager(const HostResolver::ManagerOptions & options,SystemDnsConfigChangeNotifier * notifier,NetLog * net_log,bool ipv6_reachable=true)460 TestHostResolverManager(const HostResolver::ManagerOptions& options,
461 SystemDnsConfigChangeNotifier* notifier,
462 NetLog* net_log,
463 bool ipv6_reachable = true)
464 : HostResolverManager(options, notifier, net_log),
465 ipv6_reachable_(ipv6_reachable) {}
466
467 ~TestHostResolverManager() override = default;
468
469 private:
470 const bool ipv6_reachable_;
471
IsGloballyReachable(const IPAddress & dest,const NetLogWithSource & net_log)472 bool IsGloballyReachable(const IPAddress& dest,
473 const NetLogWithSource& net_log) override {
474 return ipv6_reachable_;
475 }
476 };
477
HasAddress(const IPAddress & search_address,const AddressList & addresses)478 bool HasAddress(const IPAddress& search_address, const AddressList& addresses) {
479 for (const auto& address : addresses) {
480 if (search_address == address.address())
481 return true;
482 }
483 return false;
484 }
485
TestBothLoopbackIPs(const std::string & host)486 void TestBothLoopbackIPs(const std::string& host) {
487 AddressList addresses;
488 EXPECT_TRUE(ResolveLocalHostname(host, &addresses));
489 EXPECT_EQ(2u, addresses.size());
490 EXPECT_TRUE(HasAddress(IPAddress::IPv4Localhost(), addresses));
491 EXPECT_TRUE(HasAddress(IPAddress::IPv6Localhost(), addresses));
492 }
493
TestIPv6LoopbackOnly(const std::string & host)494 void TestIPv6LoopbackOnly(const std::string& host) {
495 AddressList addresses;
496 EXPECT_TRUE(ResolveLocalHostname(host, &addresses));
497 EXPECT_EQ(1u, addresses.size());
498 EXPECT_TRUE(HasAddress(IPAddress::IPv6Localhost(), addresses));
499 }
500
501 } // namespace
502
503 class HostResolverManagerTest : public TestWithTaskEnvironment {
504 public:
505 static const int kDefaultPort = 80;
506
HostResolverManagerTest(base::test::TaskEnvironment::TimeSource time_source=base::test::TaskEnvironment::TimeSource::SYSTEM_TIME)507 explicit HostResolverManagerTest(
508 base::test::TaskEnvironment::TimeSource time_source =
509 base::test::TaskEnvironment::TimeSource::SYSTEM_TIME)
510 : TestWithTaskEnvironment(time_source),
511 proc_(new MockHostResolverProc()) {}
512
CreateResolver(bool check_ipv6_on_wifi=true)513 void CreateResolver(bool check_ipv6_on_wifi = true) {
514 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
515 true /* ipv6_reachable */,
516 check_ipv6_on_wifi);
517 }
518
DestroyResolver()519 void DestroyResolver() {
520 if (!resolver_)
521 return;
522
523 resolver_->DeregisterResolveContext(resolve_context_.get());
524 resolver_ = nullptr;
525 }
526
527 // This HostResolverManager will only allow 1 outstanding resolve at a time
528 // and perform no retries.
CreateSerialResolver(bool check_ipv6_on_wifi=true)529 void CreateSerialResolver(bool check_ipv6_on_wifi = true) {
530 ProcTaskParams params = DefaultParams(proc_.get());
531 params.max_retry_attempts = 0u;
532 CreateResolverWithLimitsAndParams(1u, params, true /* ipv6_reachable */,
533 check_ipv6_on_wifi);
534 }
535
536 protected:
537 // testing::Test implementation:
SetUp()538 void SetUp() override {
539 request_context_ = std::make_unique<TestURLRequestContext>();
540 resolve_context_ = std::make_unique<ResolveContext>(
541 request_context_.get(), true /* enable_caching */);
542 CreateResolver();
543 }
544
TearDown()545 void TearDown() override {
546 if (resolver_) {
547 EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
548 }
549 DestroyResolver();
550 EXPECT_FALSE(proc_->HasBlockedRequests());
551 }
552
CreateResolverWithLimitsAndParams(size_t max_concurrent_resolves,const ProcTaskParams & params,bool ipv6_reachable,bool check_ipv6_on_wifi)553 void CreateResolverWithLimitsAndParams(size_t max_concurrent_resolves,
554 const ProcTaskParams& params,
555 bool ipv6_reachable,
556 bool check_ipv6_on_wifi) {
557 HostResolver::ManagerOptions options = DefaultOptions();
558 options.max_concurrent_resolves = max_concurrent_resolves;
559 options.check_ipv6_on_wifi = check_ipv6_on_wifi;
560
561 CreateResolverWithOptionsAndParams(std::move(options), params,
562 ipv6_reachable);
563 }
564
DefaultOptions()565 virtual HostResolver::ManagerOptions DefaultOptions() {
566 HostResolver::ManagerOptions options;
567 options.max_concurrent_resolves = kMaxJobs;
568 options.max_system_retry_attempts = kMaxRetryAttempts;
569 return options;
570 }
571
CreateResolverWithOptionsAndParams(HostResolver::ManagerOptions options,const ProcTaskParams & params,bool ipv6_reachable)572 virtual void CreateResolverWithOptionsAndParams(
573 HostResolver::ManagerOptions options,
574 const ProcTaskParams& params,
575 bool ipv6_reachable) {
576 // Use HostResolverManagerDnsTest if enabling DNS client.
577 DCHECK(!options.insecure_dns_client_enabled);
578
579 DestroyResolver();
580
581 resolver_ = std::make_unique<TestHostResolverManager>(
582 options, nullptr /* notifier */, nullptr /* net_log */, ipv6_reachable);
583 resolver_->set_proc_params_for_test(params);
584
585 resolver_->RegisterResolveContext(resolve_context_.get());
586 }
587
588 // Friendship is not inherited, so use proxies to access those.
num_running_dispatcher_jobs() const589 size_t num_running_dispatcher_jobs() const {
590 DCHECK(resolver_.get());
591 return resolver_->num_running_dispatcher_jobs_for_tests();
592 }
593
set_allow_fallback_to_proctask(bool allow_fallback_to_proctask)594 void set_allow_fallback_to_proctask(bool allow_fallback_to_proctask) {
595 DCHECK(resolver_.get());
596 resolver_->allow_fallback_to_proctask_ = allow_fallback_to_proctask;
597 }
598
maximum_insecure_dns_task_failures()599 static unsigned maximum_insecure_dns_task_failures() {
600 return DnsClient::kMaxInsecureFallbackFailures;
601 }
602
IsIPv6Reachable(const NetLogWithSource & net_log)603 bool IsIPv6Reachable(const NetLogWithSource& net_log) {
604 return resolver_->IsIPv6Reachable(net_log);
605 }
606
PopulateCache(const HostCache::Key & key,IPEndPoint endpoint)607 void PopulateCache(const HostCache::Key& key, IPEndPoint endpoint) {
608 resolver_->CacheResult(resolve_context_->host_cache(), key,
609 HostCache::Entry(OK, AddressList(endpoint),
610 HostCache::Entry::SOURCE_UNKNOWN),
611 base::TimeDelta::FromSeconds(1));
612 }
613
GetCacheHit(const HostCache::Key & key)614 const std::pair<const HostCache::Key, HostCache::Entry>* GetCacheHit(
615 const HostCache::Key& key) {
616 DCHECK(resolve_context_->host_cache());
617 return resolve_context_->host_cache()->LookupStale(
618 key, base::TimeTicks(), nullptr, false /* ignore_secure */);
619 }
620
MakeCacheStale()621 void MakeCacheStale() {
622 DCHECK(resolve_context_->host_cache());
623 resolve_context_->host_cache()->Invalidate();
624 }
625
CreateExpected(const std::string & ip_literal,uint16_t port)626 IPEndPoint CreateExpected(const std::string& ip_literal, uint16_t port) {
627 IPAddress ip;
628 bool result = ip.AssignFromIPLiteral(ip_literal);
629 DCHECK(result);
630 return IPEndPoint(ip, port);
631 }
632
633 scoped_refptr<MockHostResolverProc> proc_;
634 std::unique_ptr<HostResolverManager> resolver_;
635 std::unique_ptr<URLRequestContext> request_context_;
636 std::unique_ptr<ResolveContext> resolve_context_;
637 };
638
TEST_F(HostResolverManagerTest,AsynchronousLookup)639 TEST_F(HostResolverManagerTest, AsynchronousLookup) {
640 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
641 proc_->SignalMultiple(1u);
642
643 ResolveHostResponseHelper response(resolver_->CreateRequest(
644 HostPortPair("just.testing", 80), NetworkIsolationKey(),
645 NetLogWithSource(), base::nullopt, resolve_context_.get(),
646 resolve_context_->host_cache()));
647
648 EXPECT_THAT(response.result_error(), IsOk());
649 EXPECT_THAT(response.top_level_result_error(), IsOk());
650 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
651 testing::ElementsAre(CreateExpected("192.168.1.42", 80)));
652 EXPECT_FALSE(response.request()->GetStaleInfo());
653
654 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
655
656 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
657 GetCacheHit(HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
658 0 /* host_resolver_flags */,
659 HostResolverSource::ANY,
660 NetworkIsolationKey()));
661 EXPECT_TRUE(cache_result);
662 }
663
TEST_F(HostResolverManagerTest,JobsClearedOnCompletion)664 TEST_F(HostResolverManagerTest, JobsClearedOnCompletion) {
665 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
666 proc_->SignalMultiple(1u);
667
668 ResolveHostResponseHelper response(resolver_->CreateRequest(
669 HostPortPair("just.testing", 80), NetworkIsolationKey(),
670 NetLogWithSource(), base::nullopt, resolve_context_.get(),
671 resolve_context_->host_cache()));
672 EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
673
674 EXPECT_THAT(response.result_error(), IsOk());
675 EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
676 }
677
TEST_F(HostResolverManagerTest,JobsClearedOnCompletion_MultipleRequests)678 TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_MultipleRequests) {
679 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
680 proc_->SignalMultiple(1u);
681
682 ResolveHostResponseHelper response1(resolver_->CreateRequest(
683 HostPortPair("just.testing", 80), NetworkIsolationKey(),
684 NetLogWithSource(), base::nullopt, resolve_context_.get(),
685 resolve_context_->host_cache()));
686 ResolveHostResponseHelper response2(resolver_->CreateRequest(
687 HostPortPair("just.testing", 85), NetworkIsolationKey(),
688 NetLogWithSource(), base::nullopt, resolve_context_.get(),
689 resolve_context_->host_cache()));
690 EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
691
692 EXPECT_THAT(response1.result_error(), IsOk());
693 EXPECT_THAT(response2.result_error(), IsOk());
694 EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
695 }
696
TEST_F(HostResolverManagerTest,JobsClearedOnCompletion_Failure)697 TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_Failure) {
698 proc_->AddRuleForAllFamilies(std::string(),
699 "0.0.0.1"); // Default to failures.
700 proc_->SignalMultiple(1u);
701
702 ResolveHostResponseHelper response(resolver_->CreateRequest(
703 HostPortPair("just.testing", 80), NetworkIsolationKey(),
704 NetLogWithSource(), base::nullopt, resolve_context_.get(),
705 resolve_context_->host_cache()));
706 EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
707
708 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
709 EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
710 }
711
TEST_F(HostResolverManagerTest,JobsClearedOnCompletion_Abort)712 TEST_F(HostResolverManagerTest, JobsClearedOnCompletion_Abort) {
713 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
714
715 ResolveHostResponseHelper response(resolver_->CreateRequest(
716 HostPortPair("just.testing", 80), NetworkIsolationKey(),
717 NetLogWithSource(), base::nullopt, resolve_context_.get(),
718 resolve_context_->host_cache()));
719 EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
720
721 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
722 proc_->SignalMultiple(1u);
723
724 EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
725 EXPECT_EQ(0u, resolver_->num_jobs_for_testing());
726 }
727
TEST_F(HostResolverManagerTest,DnsQueryType)728 TEST_F(HostResolverManagerTest, DnsQueryType) {
729 proc_->AddRule("host", ADDRESS_FAMILY_IPV4, "192.168.1.20");
730 proc_->AddRule("host", ADDRESS_FAMILY_IPV6, "::5");
731
732 HostResolver::ResolveHostParameters parameters;
733
734 parameters.dns_query_type = DnsQueryType::A;
735 ResolveHostResponseHelper v4_response(resolver_->CreateRequest(
736 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
737 parameters, resolve_context_.get(), resolve_context_->host_cache()));
738
739 parameters.dns_query_type = DnsQueryType::AAAA;
740 ResolveHostResponseHelper v6_response(resolver_->CreateRequest(
741 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
742 parameters, resolve_context_.get(), resolve_context_->host_cache()));
743
744 proc_->SignalMultiple(2u);
745
746 EXPECT_THAT(v4_response.result_error(), IsOk());
747 EXPECT_THAT(v4_response.request()->GetAddressResults().value().endpoints(),
748 testing::ElementsAre(CreateExpected("192.168.1.20", 80)));
749
750 EXPECT_THAT(v6_response.result_error(), IsOk());
751 EXPECT_THAT(v6_response.request()->GetAddressResults().value().endpoints(),
752 testing::ElementsAre(CreateExpected("::5", 80)));
753 }
754
TEST_F(HostResolverManagerTest,LocalhostIPV4IPV6Lookup)755 TEST_F(HostResolverManagerTest, LocalhostIPV4IPV6Lookup) {
756 HostResolver::ResolveHostParameters parameters;
757
758 parameters.dns_query_type = DnsQueryType::A;
759 ResolveHostResponseHelper v6_v4_response(resolver_->CreateRequest(
760 HostPortPair("localhost6", 80), NetworkIsolationKey(), NetLogWithSource(),
761 parameters, resolve_context_.get(), resolve_context_->host_cache()));
762 EXPECT_THAT(v6_v4_response.result_error(), IsOk());
763 EXPECT_THAT(v6_v4_response.request()->GetAddressResults().value().endpoints(),
764 testing::IsEmpty());
765
766 parameters.dns_query_type = DnsQueryType::AAAA;
767 ResolveHostResponseHelper v6_v6_response(resolver_->CreateRequest(
768 HostPortPair("localhost6", 80), NetworkIsolationKey(), NetLogWithSource(),
769 parameters, resolve_context_.get(), resolve_context_->host_cache()));
770 EXPECT_THAT(v6_v6_response.result_error(), IsOk());
771 EXPECT_THAT(v6_v6_response.request()->GetAddressResults().value().endpoints(),
772 testing::ElementsAre(CreateExpected("::1", 80)));
773
774 ResolveHostResponseHelper v6_unsp_response(resolver_->CreateRequest(
775 HostPortPair("localhost6", 80), NetworkIsolationKey(), NetLogWithSource(),
776 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
777 EXPECT_THAT(v6_unsp_response.result_error(), IsOk());
778 EXPECT_THAT(
779 v6_unsp_response.request()->GetAddressResults().value().endpoints(),
780 testing::ElementsAre(CreateExpected("::1", 80)));
781
782 parameters.dns_query_type = DnsQueryType::A;
783 ResolveHostResponseHelper v4_v4_response(resolver_->CreateRequest(
784 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
785 parameters, resolve_context_.get(), resolve_context_->host_cache()));
786 EXPECT_THAT(v4_v4_response.result_error(), IsOk());
787 EXPECT_THAT(v4_v4_response.request()->GetAddressResults().value().endpoints(),
788 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
789
790 parameters.dns_query_type = DnsQueryType::AAAA;
791 ResolveHostResponseHelper v4_v6_response(resolver_->CreateRequest(
792 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
793 parameters, resolve_context_.get(), resolve_context_->host_cache()));
794 EXPECT_THAT(v4_v6_response.result_error(), IsOk());
795 EXPECT_THAT(v4_v6_response.request()->GetAddressResults().value().endpoints(),
796 testing::ElementsAre(CreateExpected("::1", 80)));
797
798 ResolveHostResponseHelper v4_unsp_response(resolver_->CreateRequest(
799 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
800 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
801 EXPECT_THAT(v4_unsp_response.result_error(), IsOk());
802 EXPECT_THAT(
803 v4_unsp_response.request()->GetAddressResults().value().endpoints(),
804 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
805 CreateExpected("::1", 80)));
806 }
807
TEST_F(HostResolverManagerTest,ResolveIPLiteralWithHostResolverSystemOnly)808 TEST_F(HostResolverManagerTest, ResolveIPLiteralWithHostResolverSystemOnly) {
809 const char kIpLiteral[] = "178.78.32.1";
810 // Add a mapping to tell if the resolver proc was called (if it was called,
811 // then the result will be the remapped value. Otherwise it will be the IP
812 // literal).
813 proc_->AddRuleForAllFamilies(kIpLiteral, "183.45.32.1");
814
815 HostResolver::ResolveHostParameters parameters;
816 parameters.source = HostResolverSource::SYSTEM;
817 ResolveHostResponseHelper response(resolver_->CreateRequest(
818 HostPortPair(kIpLiteral, 80), NetworkIsolationKey(), NetLogWithSource(),
819 parameters, resolve_context_.get(), resolve_context_->host_cache()));
820
821 // IP literal resolution is expected to take precedence over source, so the
822 // result is expected to be the input IP, not the result IP from the proc rule
823 EXPECT_THAT(response.result_error(), IsOk());
824 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
825 testing::ElementsAre(CreateExpected(kIpLiteral, 80)));
826 EXPECT_FALSE(response.request()->GetStaleInfo());
827 }
828
TEST_F(HostResolverManagerTest,EmptyListMeansNameNotResolved)829 TEST_F(HostResolverManagerTest, EmptyListMeansNameNotResolved) {
830 proc_->AddRuleForAllFamilies("just.testing", "");
831 proc_->SignalMultiple(1u);
832
833 ResolveHostResponseHelper response(resolver_->CreateRequest(
834 HostPortPair("just.testing", 80), NetworkIsolationKey(),
835 NetLogWithSource(), base::nullopt, resolve_context_.get(),
836 resolve_context_->host_cache()));
837
838 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
839 EXPECT_FALSE(response.request()->GetAddressResults());
840 EXPECT_FALSE(response.request()->GetStaleInfo());
841
842 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
843 }
844
TEST_F(HostResolverManagerTest,FailedAsynchronousLookup)845 TEST_F(HostResolverManagerTest, FailedAsynchronousLookup) {
846 proc_->AddRuleForAllFamilies(std::string(),
847 "0.0.0.1"); // Default to failures.
848 proc_->SignalMultiple(1u);
849
850 ResolveHostResponseHelper response(resolver_->CreateRequest(
851 HostPortPair("just.testing", 80), NetworkIsolationKey(),
852 NetLogWithSource(), base::nullopt, resolve_context_.get(),
853 resolve_context_->host_cache()));
854 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
855 EXPECT_THAT(response.top_level_result_error(),
856 IsError(ERR_NAME_NOT_RESOLVED));
857 EXPECT_FALSE(response.request()->GetAddressResults());
858 EXPECT_FALSE(response.request()->GetStaleInfo());
859
860 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
861
862 // Also test that the error is not cached.
863 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
864 GetCacheHit(HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
865 0 /* host_resolver_flags */,
866 HostResolverSource::ANY,
867 NetworkIsolationKey()));
868 EXPECT_FALSE(cache_result);
869 }
870
TEST_F(HostResolverManagerTest,AbortedAsynchronousLookup)871 TEST_F(HostResolverManagerTest, AbortedAsynchronousLookup) {
872 ResolveHostResponseHelper response0(resolver_->CreateRequest(
873 HostPortPair("just.testing", 80), NetworkIsolationKey(),
874 NetLogWithSource(), base::nullopt, resolve_context_.get(),
875 resolve_context_->host_cache()));
876 ASSERT_FALSE(response0.complete());
877 ASSERT_TRUE(proc_->WaitFor(1u));
878
879 // Resolver is destroyed while job is running on WorkerPool.
880 DestroyResolver();
881
882 proc_->SignalAll();
883
884 // To ensure there was no spurious callback, complete with a new resolver.
885 CreateResolver();
886 ResolveHostResponseHelper response1(resolver_->CreateRequest(
887 HostPortPair("just.testing", 80), NetworkIsolationKey(),
888 NetLogWithSource(), base::nullopt, resolve_context_.get(),
889 resolve_context_->host_cache()));
890
891 proc_->SignalMultiple(2u);
892
893 EXPECT_THAT(response1.result_error(), IsOk());
894
895 // This request was canceled.
896 EXPECT_FALSE(response0.complete());
897 }
898
TEST_F(HostResolverManagerTest,NumericIPv4Address)899 TEST_F(HostResolverManagerTest, NumericIPv4Address) {
900 ResolveHostResponseHelper response(resolver_->CreateRequest(
901 HostPortPair("127.1.2.3", 5555), NetworkIsolationKey(),
902 NetLogWithSource(), base::nullopt, resolve_context_.get(),
903 resolve_context_->host_cache()));
904
905 EXPECT_THAT(response.result_error(), IsOk());
906 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
907 testing::ElementsAre(CreateExpected("127.1.2.3", 5555)));
908 }
909
TEST_F(HostResolverManagerTest,NumericIPv6Address)910 TEST_F(HostResolverManagerTest, NumericIPv6Address) {
911 // Resolve a plain IPv6 address. Don't worry about [brackets], because
912 // the caller should have removed them.
913 ResolveHostResponseHelper response(resolver_->CreateRequest(
914 HostPortPair("2001:db8::1", 5555), NetworkIsolationKey(),
915 NetLogWithSource(), base::nullopt, resolve_context_.get(),
916 resolve_context_->host_cache()));
917
918 EXPECT_THAT(response.result_error(), IsOk());
919 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
920 testing::ElementsAre(CreateExpected("2001:db8::1", 5555)));
921 }
922
TEST_F(HostResolverManagerTest,EmptyHost)923 TEST_F(HostResolverManagerTest, EmptyHost) {
924 ResolveHostResponseHelper response(resolver_->CreateRequest(
925 HostPortPair(std::string(), 5555), NetworkIsolationKey(),
926 NetLogWithSource(), base::nullopt, resolve_context_.get(),
927 resolve_context_->host_cache()));
928
929 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
930 EXPECT_FALSE(response.request()->GetAddressResults());
931 }
932
TEST_F(HostResolverManagerTest,EmptyDotsHost)933 TEST_F(HostResolverManagerTest, EmptyDotsHost) {
934 for (int i = 0; i < 16; ++i) {
935 ResolveHostResponseHelper response(resolver_->CreateRequest(
936 HostPortPair(std::string(i, '.'), 5555), NetworkIsolationKey(),
937 NetLogWithSource(), base::nullopt, resolve_context_.get(),
938 resolve_context_->host_cache()));
939
940 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
941 EXPECT_FALSE(response.request()->GetAddressResults());
942 }
943 }
944
TEST_F(HostResolverManagerTest,LongHost)945 TEST_F(HostResolverManagerTest, LongHost) {
946 ResolveHostResponseHelper response(resolver_->CreateRequest(
947 HostPortPair(std::string(4097, 'a'), 5555), NetworkIsolationKey(),
948 NetLogWithSource(), base::nullopt, resolve_context_.get(),
949 resolve_context_->host_cache()));
950
951 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
952 EXPECT_FALSE(response.request()->GetAddressResults());
953 }
954
TEST_F(HostResolverManagerTest,DeDupeRequests)955 TEST_F(HostResolverManagerTest, DeDupeRequests) {
956 // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is
957 // blocked, these should all pile up until we signal it.
958 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
959 responses.emplace_back(
960 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
961 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
962 base::nullopt, resolve_context_.get(),
963 resolve_context_->host_cache())));
964 responses.emplace_back(
965 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
966 HostPortPair("b", 80), NetworkIsolationKey(), NetLogWithSource(),
967 base::nullopt, resolve_context_.get(),
968 resolve_context_->host_cache())));
969 responses.emplace_back(
970 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
971 HostPortPair("b", 81), NetworkIsolationKey(), NetLogWithSource(),
972 base::nullopt, resolve_context_.get(),
973 resolve_context_->host_cache())));
974 responses.emplace_back(
975 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
976 HostPortPair("a", 82), NetworkIsolationKey(), NetLogWithSource(),
977 base::nullopt, resolve_context_.get(),
978 resolve_context_->host_cache())));
979 responses.emplace_back(
980 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
981 HostPortPair("b", 83), NetworkIsolationKey(), NetLogWithSource(),
982 base::nullopt, resolve_context_.get(),
983 resolve_context_->host_cache())));
984
985 for (auto& response : responses) {
986 ASSERT_FALSE(response->complete());
987 }
988
989 proc_->SignalMultiple(2u); // One for "a", one for "b".
990
991 for (auto& response : responses) {
992 EXPECT_THAT(response->result_error(), IsOk());
993 }
994 }
995
TEST_F(HostResolverManagerTest,CancelMultipleRequests)996 TEST_F(HostResolverManagerTest, CancelMultipleRequests) {
997 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
998 responses.emplace_back(
999 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1000 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
1001 base::nullopt, resolve_context_.get(),
1002 resolve_context_->host_cache())));
1003 responses.emplace_back(
1004 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1005 HostPortPair("b", 80), NetworkIsolationKey(), NetLogWithSource(),
1006 base::nullopt, resolve_context_.get(),
1007 resolve_context_->host_cache())));
1008 responses.emplace_back(
1009 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1010 HostPortPair("b", 81), NetworkIsolationKey(), NetLogWithSource(),
1011 base::nullopt, resolve_context_.get(),
1012 resolve_context_->host_cache())));
1013 responses.emplace_back(
1014 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1015 HostPortPair("a", 82), NetworkIsolationKey(), NetLogWithSource(),
1016 base::nullopt, resolve_context_.get(),
1017 resolve_context_->host_cache())));
1018 responses.emplace_back(
1019 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1020 HostPortPair("b", 83), NetworkIsolationKey(), NetLogWithSource(),
1021 base::nullopt, resolve_context_.get(),
1022 resolve_context_->host_cache())));
1023
1024 for (auto& response : responses) {
1025 ASSERT_FALSE(response->complete());
1026 }
1027
1028 // Cancel everything except request for requests[3] ("a", 82).
1029 responses[0]->CancelRequest();
1030 responses[1]->CancelRequest();
1031 responses[2]->CancelRequest();
1032 responses[4]->CancelRequest();
1033
1034 proc_->SignalMultiple(2u); // One for "a", one for "b".
1035
1036 EXPECT_THAT(responses[3]->result_error(), IsOk());
1037
1038 EXPECT_FALSE(responses[0]->complete());
1039 EXPECT_FALSE(responses[1]->complete());
1040 EXPECT_FALSE(responses[2]->complete());
1041 EXPECT_FALSE(responses[4]->complete());
1042 }
1043
TEST_F(HostResolverManagerTest,CanceledRequestsReleaseJobSlots)1044 TEST_F(HostResolverManagerTest, CanceledRequestsReleaseJobSlots) {
1045 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1046
1047 // Fill up the dispatcher and queue.
1048 for (unsigned i = 0; i < kMaxJobs + 1; ++i) {
1049 std::string hostname = "a_";
1050 hostname[1] = 'a' + i;
1051
1052 responses.emplace_back(
1053 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1054 HostPortPair(hostname, 80), NetworkIsolationKey(),
1055 NetLogWithSource(), base::nullopt, resolve_context_.get(),
1056 resolve_context_->host_cache())));
1057 ASSERT_FALSE(responses.back()->complete());
1058
1059 responses.emplace_back(
1060 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1061 HostPortPair(hostname, 81), NetworkIsolationKey(),
1062 NetLogWithSource(), base::nullopt, resolve_context_.get(),
1063 resolve_context_->host_cache())));
1064 ASSERT_FALSE(responses.back()->complete());
1065 }
1066
1067 ASSERT_TRUE(proc_->WaitFor(kMaxJobs));
1068
1069 // Cancel all but last two.
1070 for (unsigned i = 0; i < responses.size() - 2; ++i) {
1071 responses[i]->CancelRequest();
1072 }
1073
1074 ASSERT_TRUE(proc_->WaitFor(kMaxJobs + 1));
1075
1076 proc_->SignalAll();
1077
1078 size_t num_requests = responses.size();
1079 EXPECT_THAT(responses[num_requests - 1]->result_error(), IsOk());
1080 EXPECT_THAT(responses[num_requests - 2]->result_error(), IsOk());
1081 for (unsigned i = 0; i < num_requests - 2; ++i) {
1082 EXPECT_FALSE(responses[i]->complete());
1083 }
1084 }
1085
TEST_F(HostResolverManagerTest,CancelWithinCallback)1086 TEST_F(HostResolverManagerTest, CancelWithinCallback) {
1087 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1088 auto custom_callback = base::BindLambdaForTesting(
1089 [&](CompletionOnceCallback completion_callback, int error) {
1090 for (auto& response : responses) {
1091 // Cancelling request is required to complete first, so that it can
1092 // attempt to cancel the others. This test assumes all jobs are
1093 // completed in order.
1094 DCHECK(!response->complete());
1095
1096 response->CancelRequest();
1097 }
1098 std::move(completion_callback).Run(error);
1099 });
1100
1101 ResolveHostResponseHelper cancelling_response(
1102 resolver_->CreateRequest(HostPortPair("a", 80), NetworkIsolationKey(),
1103 NetLogWithSource(), base::nullopt,
1104 resolve_context_.get(),
1105 resolve_context_->host_cache()),
1106 std::move(custom_callback));
1107
1108 responses.emplace_back(
1109 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1110 HostPortPair("a", 81), NetworkIsolationKey(), NetLogWithSource(),
1111 base::nullopt, resolve_context_.get(),
1112 resolve_context_->host_cache())));
1113 responses.emplace_back(
1114 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1115 HostPortPair("a", 82), NetworkIsolationKey(), NetLogWithSource(),
1116 base::nullopt, resolve_context_.get(),
1117 resolve_context_->host_cache())));
1118
1119 proc_->SignalMultiple(2u); // One for "a". One for "finalrequest".
1120
1121 EXPECT_THAT(cancelling_response.result_error(), IsOk());
1122
1123 ResolveHostResponseHelper final_response(resolver_->CreateRequest(
1124 HostPortPair("finalrequest", 70), NetworkIsolationKey(),
1125 NetLogWithSource(), base::nullopt, resolve_context_.get(),
1126 resolve_context_->host_cache()));
1127 EXPECT_THAT(final_response.result_error(), IsOk());
1128
1129 for (auto& response : responses) {
1130 EXPECT_FALSE(response->complete());
1131 }
1132 }
1133
TEST_F(HostResolverManagerTest,DeleteWithinCallback)1134 TEST_F(HostResolverManagerTest, DeleteWithinCallback) {
1135 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1136 auto custom_callback = base::BindLambdaForTesting(
1137 [&](CompletionOnceCallback completion_callback, int error) {
1138 for (auto& response : responses) {
1139 // Deleting request is required to be first, so the other requests
1140 // will still be running to be deleted. This test assumes that the
1141 // Jobs will be Aborted in order and the requests in order within the
1142 // jobs.
1143 DCHECK(!response->complete());
1144 }
1145
1146 DestroyResolver();
1147 std::move(completion_callback).Run(error);
1148 });
1149
1150 ResolveHostResponseHelper deleting_response(
1151 resolver_->CreateRequest(HostPortPair("a", 80), NetworkIsolationKey(),
1152 NetLogWithSource(), base::nullopt,
1153 resolve_context_.get(),
1154 resolve_context_->host_cache()),
1155 std::move(custom_callback));
1156
1157 // Start additional requests to be cancelled as part of the first's deletion.
1158 // Assumes all requests for a job are handled in order so that the deleting
1159 // request will run first and cancel the rest.
1160 responses.emplace_back(
1161 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1162 HostPortPair("a", 81), NetworkIsolationKey(), NetLogWithSource(),
1163 base::nullopt, resolve_context_.get(),
1164 resolve_context_->host_cache())));
1165 responses.emplace_back(
1166 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1167 HostPortPair("a", 82), NetworkIsolationKey(), NetLogWithSource(),
1168 base::nullopt, resolve_context_.get(),
1169 resolve_context_->host_cache())));
1170
1171 proc_->SignalMultiple(3u);
1172
1173 EXPECT_THAT(deleting_response.result_error(), IsOk());
1174
1175 base::RunLoop().RunUntilIdle();
1176 for (auto& response : responses) {
1177 EXPECT_FALSE(response->complete());
1178 }
1179 }
1180
TEST_F(HostResolverManagerTest,DeleteWithinAbortedCallback)1181 TEST_F(HostResolverManagerTest, DeleteWithinAbortedCallback) {
1182 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1183 ResolveHostResponseHelper::Callback custom_callback =
1184 base::BindLambdaForTesting(
1185 [&](CompletionOnceCallback completion_callback, int error) {
1186 for (auto& response : responses) {
1187 // Deleting request is required to be first, so the other requests
1188 // will still be running to be deleted. This test assumes that the
1189 // Jobs will be Aborted in order and the requests in order within
1190 // the jobs.
1191 DCHECK(!response->complete());
1192 }
1193 DestroyResolver();
1194 std::move(completion_callback).Run(error);
1195 });
1196
1197 ResolveHostResponseHelper deleting_response(
1198 resolver_->CreateRequest(HostPortPair("a", 80), NetworkIsolationKey(),
1199 NetLogWithSource(), base::nullopt,
1200 resolve_context_.get(),
1201 resolve_context_->host_cache()),
1202 std::move(custom_callback));
1203
1204 responses.emplace_back(
1205 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1206 HostPortPair("a", 81), NetworkIsolationKey(), NetLogWithSource(),
1207 base::nullopt, resolve_context_.get(),
1208 resolve_context_->host_cache())));
1209 responses.emplace_back(
1210 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1211 HostPortPair("b", 82), NetworkIsolationKey(), NetLogWithSource(),
1212 base::nullopt, resolve_context_.get(),
1213 resolve_context_->host_cache())));
1214 responses.emplace_back(
1215 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1216 HostPortPair("b", 83), NetworkIsolationKey(), NetLogWithSource(),
1217 base::nullopt, resolve_context_.get(),
1218 resolve_context_->host_cache())));
1219
1220 // Wait for all calls to queue up, trigger abort via IP address change, then
1221 // signal all the queued requests to let them all try to finish.
1222 EXPECT_TRUE(proc_->WaitFor(2u));
1223 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1224 proc_->SignalAll();
1225
1226 EXPECT_THAT(deleting_response.result_error(), IsError(ERR_NETWORK_CHANGED));
1227 base::RunLoop().RunUntilIdle();
1228 for (auto& response : responses) {
1229 EXPECT_FALSE(response->complete());
1230 }
1231 }
1232
TEST_F(HostResolverManagerTest,StartWithinCallback)1233 TEST_F(HostResolverManagerTest, StartWithinCallback) {
1234 std::unique_ptr<ResolveHostResponseHelper> new_response;
1235 auto custom_callback = base::BindLambdaForTesting(
1236 [&](CompletionOnceCallback completion_callback, int error) {
1237 new_response = std::make_unique<ResolveHostResponseHelper>(
1238 resolver_->CreateRequest(HostPortPair("new", 70),
1239 NetworkIsolationKey(), NetLogWithSource(),
1240 base::nullopt, resolve_context_.get(),
1241 resolve_context_->host_cache()));
1242 std::move(completion_callback).Run(error);
1243 });
1244
1245 ResolveHostResponseHelper starting_response(
1246 resolver_->CreateRequest(HostPortPair("a", 80), NetworkIsolationKey(),
1247 NetLogWithSource(), base::nullopt,
1248 resolve_context_.get(),
1249 resolve_context_->host_cache()),
1250 std::move(custom_callback));
1251
1252 proc_->SignalMultiple(2u); // One for "a". One for "new".
1253
1254 EXPECT_THAT(starting_response.result_error(), IsOk());
1255 EXPECT_THAT(new_response->result_error(), IsOk());
1256 }
1257
TEST_F(HostResolverManagerTest,StartWithinEvictionCallback)1258 TEST_F(HostResolverManagerTest, StartWithinEvictionCallback) {
1259 CreateSerialResolver();
1260 resolver_->SetMaxQueuedJobsForTesting(2);
1261
1262 std::unique_ptr<ResolveHostResponseHelper> new_response;
1263 auto custom_callback = base::BindLambdaForTesting(
1264 [&](CompletionOnceCallback completion_callback, int error) {
1265 new_response = std::make_unique<ResolveHostResponseHelper>(
1266 resolver_->CreateRequest(HostPortPair("new", 70),
1267 NetworkIsolationKey(), NetLogWithSource(),
1268 base::nullopt, resolve_context_.get(),
1269 resolve_context_->host_cache()));
1270 std::move(completion_callback).Run(error);
1271 });
1272
1273 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
1274 HostPortPair("initial", 80), NetworkIsolationKey(), NetLogWithSource(),
1275 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1276 ResolveHostResponseHelper evictee1_response(
1277 resolver_->CreateRequest(HostPortPair("evictee1", 80),
1278 NetworkIsolationKey(), NetLogWithSource(),
1279 base::nullopt, resolve_context_.get(),
1280 resolve_context_->host_cache()),
1281 std::move(custom_callback));
1282 ResolveHostResponseHelper evictee2_response(resolver_->CreateRequest(
1283 HostPortPair("evictee2", 80), NetworkIsolationKey(), NetLogWithSource(),
1284 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1285
1286 // Now one running request ("initial") and two queued requests ("evictee1" and
1287 // "evictee2"). Any further requests will cause evictions.
1288 ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
1289 HostPortPair("evictor", 80), NetworkIsolationKey(), NetLogWithSource(),
1290 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1291 EXPECT_THAT(evictee1_response.result_error(),
1292 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1293
1294 // "new" should evict "evictee2"
1295 EXPECT_THAT(evictee2_response.result_error(),
1296 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1297
1298 proc_->SignalMultiple(3u);
1299
1300 EXPECT_THAT(initial_response.result_error(), IsOk());
1301 EXPECT_THAT(evictor_response.result_error(), IsOk());
1302 EXPECT_THAT(new_response->result_error(), IsOk());
1303 }
1304
1305 // Test where we start a new request within an eviction callback that itself
1306 // evicts the first evictor.
TEST_F(HostResolverManagerTest,StartWithinEvictionCallback_DoubleEviction)1307 TEST_F(HostResolverManagerTest, StartWithinEvictionCallback_DoubleEviction) {
1308 CreateSerialResolver();
1309 resolver_->SetMaxQueuedJobsForTesting(1);
1310
1311 std::unique_ptr<ResolveHostResponseHelper> new_response;
1312 auto custom_callback = base::BindLambdaForTesting(
1313 [&](CompletionOnceCallback completion_callback, int error) {
1314 new_response = std::make_unique<ResolveHostResponseHelper>(
1315 resolver_->CreateRequest(HostPortPair("new", 70),
1316 NetworkIsolationKey(), NetLogWithSource(),
1317 base::nullopt, resolve_context_.get(),
1318 resolve_context_->host_cache()));
1319 std::move(completion_callback).Run(error);
1320 });
1321
1322 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
1323 HostPortPair("initial", 80), NetworkIsolationKey(), NetLogWithSource(),
1324 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1325 ResolveHostResponseHelper evictee_response(
1326 resolver_->CreateRequest(HostPortPair("evictee", 80),
1327 NetworkIsolationKey(), NetLogWithSource(),
1328 base::nullopt, resolve_context_.get(),
1329 resolve_context_->host_cache()),
1330 std::move(custom_callback));
1331
1332 // Now one running request ("initial") and one queued requests ("evictee").
1333 // Any further requests will cause evictions.
1334 ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
1335 HostPortPair("evictor", 80), NetworkIsolationKey(), NetLogWithSource(),
1336 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1337 EXPECT_THAT(evictee_response.result_error(),
1338 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1339
1340 // "new" should evict "evictor"
1341 EXPECT_THAT(evictor_response.result_error(),
1342 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1343
1344 proc_->SignalMultiple(2u);
1345
1346 EXPECT_THAT(initial_response.result_error(), IsOk());
1347 EXPECT_THAT(new_response->result_error(), IsOk());
1348 }
1349
TEST_F(HostResolverManagerTest,StartWithinEvictionCallback_SameRequest)1350 TEST_F(HostResolverManagerTest, StartWithinEvictionCallback_SameRequest) {
1351 CreateSerialResolver();
1352 resolver_->SetMaxQueuedJobsForTesting(2);
1353
1354 std::unique_ptr<ResolveHostResponseHelper> new_response;
1355 auto custom_callback = base::BindLambdaForTesting(
1356 [&](CompletionOnceCallback completion_callback, int error) {
1357 new_response = std::make_unique<ResolveHostResponseHelper>(
1358 resolver_->CreateRequest(HostPortPair("evictor", 70),
1359 NetworkIsolationKey(), NetLogWithSource(),
1360 base::nullopt, resolve_context_.get(),
1361 resolve_context_->host_cache()));
1362 std::move(completion_callback).Run(error);
1363 });
1364
1365 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
1366 HostPortPair("initial", 80), NetworkIsolationKey(), NetLogWithSource(),
1367 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1368 ResolveHostResponseHelper evictee_response(
1369 resolver_->CreateRequest(HostPortPair("evictee", 80),
1370 NetworkIsolationKey(), NetLogWithSource(),
1371 base::nullopt, resolve_context_.get(),
1372 resolve_context_->host_cache()),
1373 std::move(custom_callback));
1374 ResolveHostResponseHelper additional_response(resolver_->CreateRequest(
1375 HostPortPair("additional", 80), NetworkIsolationKey(), NetLogWithSource(),
1376 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1377
1378 // Now one running request ("initial") and two queued requests ("evictee" and
1379 // "additional"). Any further requests will cause evictions.
1380 ResolveHostResponseHelper evictor_response(resolver_->CreateRequest(
1381 HostPortPair("evictor", 80), NetworkIsolationKey(), NetLogWithSource(),
1382 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1383 EXPECT_THAT(evictee_response.result_error(),
1384 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1385
1386 // Second "evictor" should be joined with the first and not evict "additional"
1387
1388 // Only 3 proc requests because both "evictor" requests are combined.
1389 proc_->SignalMultiple(3u);
1390
1391 EXPECT_THAT(initial_response.result_error(), IsOk());
1392 EXPECT_THAT(additional_response.result_error(), IsOk());
1393 EXPECT_THAT(evictor_response.result_error(), IsOk());
1394 EXPECT_THAT(new_response->result_error(), IsOk());
1395 }
1396
TEST_F(HostResolverManagerTest,BypassCache)1397 TEST_F(HostResolverManagerTest, BypassCache) {
1398 proc_->SignalMultiple(2u);
1399
1400 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
1401 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
1402 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1403 EXPECT_THAT(initial_response.result_error(), IsOk());
1404 EXPECT_EQ(1u, proc_->GetCaptureList().size());
1405
1406 ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
1407 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
1408 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1409 EXPECT_THAT(cached_response.result_error(), IsOk());
1410 // Expect no increase to calls to |proc_| because result was cached.
1411 EXPECT_EQ(1u, proc_->GetCaptureList().size());
1412
1413 HostResolver::ResolveHostParameters parameters;
1414 parameters.cache_usage =
1415 HostResolver::ResolveHostParameters::CacheUsage::DISALLOWED;
1416 ResolveHostResponseHelper cache_bypassed_response(resolver_->CreateRequest(
1417 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
1418 parameters, resolve_context_.get(), resolve_context_->host_cache()));
1419 EXPECT_THAT(cache_bypassed_response.result_error(), IsOk());
1420 // Expect call to |proc_| because cache was bypassed.
1421 EXPECT_EQ(2u, proc_->GetCaptureList().size());
1422 }
1423
1424 // Test that IP address changes flush the cache but initial DNS config reads
1425 // do not.
TEST_F(HostResolverManagerTest,FlushCacheOnIPAddressChange)1426 TEST_F(HostResolverManagerTest, FlushCacheOnIPAddressChange) {
1427 proc_->SignalMultiple(2u); // One before the flush, one after.
1428
1429 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
1430 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
1431 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1432 EXPECT_THAT(initial_response.result_error(), IsOk());
1433 EXPECT_EQ(1u, proc_->GetCaptureList().size());
1434
1435 ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
1436 HostPortPair("host1", 75), NetworkIsolationKey(), NetLogWithSource(),
1437 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1438 EXPECT_THAT(cached_response.result_error(), IsOk());
1439 EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No expected increase.
1440
1441 // Flush cache by triggering an IP address change.
1442 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1443 base::RunLoop().RunUntilIdle(); // Notification happens async.
1444
1445 // Resolve "host1" again -- this time it won't be served from cache, so it
1446 // will complete asynchronously.
1447 ResolveHostResponseHelper flushed_response(resolver_->CreateRequest(
1448 HostPortPair("host1", 80), NetworkIsolationKey(), NetLogWithSource(),
1449 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1450 EXPECT_THAT(flushed_response.result_error(), IsOk());
1451 EXPECT_EQ(2u, proc_->GetCaptureList().size()); // Expected increase.
1452 }
1453
1454 // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests.
TEST_F(HostResolverManagerTest,AbortOnIPAddressChanged)1455 TEST_F(HostResolverManagerTest, AbortOnIPAddressChanged) {
1456 ResolveHostResponseHelper response(resolver_->CreateRequest(
1457 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
1458 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1459
1460 ASSERT_FALSE(response.complete());
1461 ASSERT_TRUE(proc_->WaitFor(1u));
1462
1463 // Triggering an IP address change.
1464 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1465 base::RunLoop().RunUntilIdle(); // Notification happens async.
1466 proc_->SignalAll();
1467
1468 EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
1469 EXPECT_FALSE(response.request()->GetAddressResults());
1470 EXPECT_EQ(0u, resolve_context_->host_cache()->size());
1471 }
1472
1473 // Obey pool constraints after IP address has changed.
TEST_F(HostResolverManagerTest,ObeyPoolConstraintsAfterIPAddressChange)1474 TEST_F(HostResolverManagerTest, ObeyPoolConstraintsAfterIPAddressChange) {
1475 // Runs at most one job at a time.
1476 CreateSerialResolver();
1477
1478 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1479 responses.emplace_back(
1480 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1481 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
1482 base::nullopt, resolve_context_.get(),
1483 resolve_context_->host_cache())));
1484 responses.emplace_back(
1485 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1486 HostPortPair("b", 80), NetworkIsolationKey(), NetLogWithSource(),
1487 base::nullopt, resolve_context_.get(),
1488 resolve_context_->host_cache())));
1489 responses.emplace_back(
1490 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1491 HostPortPair("c", 80), NetworkIsolationKey(), NetLogWithSource(),
1492 base::nullopt, resolve_context_.get(),
1493 resolve_context_->host_cache())));
1494
1495 for (auto& response : responses) {
1496 ASSERT_FALSE(response->complete());
1497 }
1498 ASSERT_TRUE(proc_->WaitFor(1u));
1499
1500 // Triggering an IP address change.
1501 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1502 base::RunLoop().RunUntilIdle(); // Notification happens async.
1503 proc_->SignalMultiple(3u); // Let the false-start go so that we can catch it.
1504
1505 // Requests should complete one at a time, with the first failing.
1506 EXPECT_THAT(responses[0]->result_error(), IsError(ERR_NETWORK_CHANGED));
1507 EXPECT_EQ(1u, num_running_dispatcher_jobs());
1508 EXPECT_FALSE(responses[1]->complete());
1509 EXPECT_FALSE(responses[2]->complete());
1510
1511 EXPECT_THAT(responses[1]->result_error(), IsOk());
1512 EXPECT_EQ(1u, num_running_dispatcher_jobs());
1513 EXPECT_FALSE(responses[2]->complete());
1514
1515 EXPECT_THAT(responses[2]->result_error(), IsOk());
1516 }
1517
1518 // Tests that a new Request made from the callback of a previously aborted one
1519 // will not be aborted.
TEST_F(HostResolverManagerTest,AbortOnlyExistingRequestsOnIPAddressChange)1520 TEST_F(HostResolverManagerTest, AbortOnlyExistingRequestsOnIPAddressChange) {
1521 auto custom_callback_template = base::BindLambdaForTesting(
1522 [&](const HostPortPair& next_host,
1523 std::unique_ptr<ResolveHostResponseHelper>* next_response,
1524 CompletionOnceCallback completion_callback, int error) {
1525 *next_response = std::make_unique<ResolveHostResponseHelper>(
1526 resolver_->CreateRequest(next_host, NetworkIsolationKey(),
1527 NetLogWithSource(), base::nullopt,
1528 resolve_context_.get(),
1529 resolve_context_->host_cache()));
1530 std::move(completion_callback).Run(error);
1531 });
1532
1533 std::vector<std::unique_ptr<ResolveHostResponseHelper>> next_responses(3);
1534
1535 ResolveHostResponseHelper response0(
1536 resolver_->CreateRequest(HostPortPair("bbb", 80), NetworkIsolationKey(),
1537 NetLogWithSource(), base::nullopt,
1538 resolve_context_.get(),
1539 resolve_context_->host_cache()),
1540 base::BindOnce(custom_callback_template, HostPortPair("zzz", 80),
1541 &next_responses[0]));
1542
1543 ResolveHostResponseHelper response1(
1544 resolver_->CreateRequest(HostPortPair("eee", 80), NetworkIsolationKey(),
1545 NetLogWithSource(), base::nullopt,
1546 resolve_context_.get(),
1547 resolve_context_->host_cache()),
1548 base::BindOnce(custom_callback_template, HostPortPair("aaa", 80),
1549 &next_responses[1]));
1550
1551 ResolveHostResponseHelper response2(
1552 resolver_->CreateRequest(HostPortPair("ccc", 80), NetworkIsolationKey(),
1553 NetLogWithSource(), base::nullopt,
1554 resolve_context_.get(),
1555 resolve_context_->host_cache()),
1556 base::BindOnce(custom_callback_template, HostPortPair("eee", 80),
1557 &next_responses[2]));
1558
1559 // Wait until all are blocked;
1560 ASSERT_TRUE(proc_->WaitFor(3u));
1561 // Trigger an IP address change.
1562 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
1563 // This should abort all running jobs.
1564 base::RunLoop().RunUntilIdle();
1565
1566 EXPECT_THAT(response0.result_error(), IsError(ERR_NETWORK_CHANGED));
1567 EXPECT_THAT(response1.result_error(), IsError(ERR_NETWORK_CHANGED));
1568 EXPECT_THAT(response2.result_error(), IsError(ERR_NETWORK_CHANGED));
1569
1570 EXPECT_FALSE(next_responses[0]->complete());
1571 EXPECT_FALSE(next_responses[1]->complete());
1572 EXPECT_FALSE(next_responses[2]->complete());
1573
1574 // Unblock all calls to proc.
1575 proc_->SignalMultiple(6u);
1576
1577 // Run until the re-started requests finish.
1578 EXPECT_THAT(next_responses[0]->result_error(), IsOk());
1579 EXPECT_THAT(next_responses[1]->result_error(), IsOk());
1580 EXPECT_THAT(next_responses[2]->result_error(), IsOk());
1581
1582 // Verify that results of aborted Jobs were not cached.
1583 EXPECT_EQ(6u, proc_->GetCaptureList().size());
1584 EXPECT_EQ(3u, resolve_context_->host_cache()->size());
1585 }
1586
1587 // Tests that when the maximum threads is set to 1, requests are dequeued
1588 // in order of priority.
TEST_F(HostResolverManagerTest,HigherPriorityRequestsStartedFirst)1589 TEST_F(HostResolverManagerTest, HigherPriorityRequestsStartedFirst) {
1590 CreateSerialResolver();
1591
1592 HostResolver::ResolveHostParameters low_priority;
1593 low_priority.initial_priority = LOW;
1594 HostResolver::ResolveHostParameters medium_priority;
1595 medium_priority.initial_priority = MEDIUM;
1596 HostResolver::ResolveHostParameters highest_priority;
1597 highest_priority.initial_priority = HIGHEST;
1598
1599 // Note that at this point the MockHostResolverProc is blocked, so any
1600 // requests we make will not complete.
1601
1602 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1603 responses.emplace_back(
1604 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1605 HostPortPair("req0", 80), NetworkIsolationKey(), NetLogWithSource(),
1606 low_priority, resolve_context_.get(),
1607 resolve_context_->host_cache())));
1608 responses.emplace_back(
1609 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1610 HostPortPair("req1", 80), NetworkIsolationKey(), NetLogWithSource(),
1611 medium_priority, resolve_context_.get(),
1612 resolve_context_->host_cache())));
1613 responses.emplace_back(
1614 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1615 HostPortPair("req2", 80), NetworkIsolationKey(), NetLogWithSource(),
1616 medium_priority, resolve_context_.get(),
1617 resolve_context_->host_cache())));
1618 responses.emplace_back(
1619 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1620 HostPortPair("req3", 80), NetworkIsolationKey(), NetLogWithSource(),
1621 low_priority, resolve_context_.get(),
1622 resolve_context_->host_cache())));
1623 responses.emplace_back(
1624 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1625 HostPortPair("req4", 80), NetworkIsolationKey(), NetLogWithSource(),
1626 highest_priority, resolve_context_.get(),
1627 resolve_context_->host_cache())));
1628 responses.emplace_back(
1629 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1630 HostPortPair("req5", 80), NetworkIsolationKey(), NetLogWithSource(),
1631 low_priority, resolve_context_.get(),
1632 resolve_context_->host_cache())));
1633 responses.emplace_back(
1634 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1635 HostPortPair("req6", 80), NetworkIsolationKey(), NetLogWithSource(),
1636 low_priority, resolve_context_.get(),
1637 resolve_context_->host_cache())));
1638 responses.emplace_back(
1639 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1640 HostPortPair("req5", 80), NetworkIsolationKey(), NetLogWithSource(),
1641 highest_priority, resolve_context_.get(),
1642 resolve_context_->host_cache())));
1643
1644 for (const auto& response : responses) {
1645 ASSERT_FALSE(response->complete());
1646 }
1647
1648 // Unblock the resolver thread so the requests can run.
1649 proc_->SignalMultiple(responses.size()); // More than needed.
1650
1651 // Wait for all the requests to complete successfully.
1652 for (auto& response : responses) {
1653 EXPECT_THAT(response->result_error(), IsOk());
1654 }
1655
1656 // Since we have restricted to a single concurrent thread in the jobpool,
1657 // the requests should complete in order of priority (with the exception
1658 // of the first request, which gets started right away, since there is
1659 // nothing outstanding).
1660 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1661 ASSERT_EQ(7u, capture_list.size());
1662
1663 EXPECT_EQ("req0", capture_list[0].hostname);
1664 EXPECT_EQ("req4", capture_list[1].hostname);
1665 EXPECT_EQ("req5", capture_list[2].hostname);
1666 EXPECT_EQ("req1", capture_list[3].hostname);
1667 EXPECT_EQ("req2", capture_list[4].hostname);
1668 EXPECT_EQ("req3", capture_list[5].hostname);
1669 EXPECT_EQ("req6", capture_list[6].hostname);
1670 }
1671
1672 // Test that changing a job's priority affects the dequeueing order.
TEST_F(HostResolverManagerTest,ChangePriority)1673 TEST_F(HostResolverManagerTest, ChangePriority) {
1674 CreateSerialResolver();
1675
1676 HostResolver::ResolveHostParameters lowest_priority;
1677 lowest_priority.initial_priority = LOWEST;
1678 HostResolver::ResolveHostParameters low_priority;
1679 low_priority.initial_priority = LOW;
1680 HostResolver::ResolveHostParameters medium_priority;
1681 medium_priority.initial_priority = MEDIUM;
1682
1683 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1684 responses.emplace_back(
1685 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1686 HostPortPair("req0", 80), NetworkIsolationKey(), NetLogWithSource(),
1687 medium_priority, resolve_context_.get(),
1688 resolve_context_->host_cache())));
1689 responses.emplace_back(
1690 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1691 HostPortPair("req1", 80), NetworkIsolationKey(), NetLogWithSource(),
1692 low_priority, resolve_context_.get(),
1693 resolve_context_->host_cache())));
1694 responses.emplace_back(
1695 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1696 HostPortPair("req2", 80), NetworkIsolationKey(), NetLogWithSource(),
1697 lowest_priority, resolve_context_.get(),
1698 resolve_context_->host_cache())));
1699
1700 // req0 starts immediately; without ChangePriority, req1 and then req2 should
1701 // run.
1702 for (const auto& response : responses) {
1703 ASSERT_FALSE(response->complete());
1704 }
1705
1706 // Changing req2 to HIGHEST should make it run before req1.
1707 // (It can't run before req0, since req0 started immediately.)
1708 responses[2]->request()->ChangeRequestPriority(HIGHEST);
1709
1710 // Let all 3 requests finish.
1711 proc_->SignalMultiple(3u);
1712
1713 for (auto& response : responses) {
1714 EXPECT_THAT(response->result_error(), IsOk());
1715 }
1716
1717 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1718 ASSERT_EQ(3u, capture_list.size());
1719
1720 EXPECT_EQ("req0", capture_list[0].hostname);
1721 EXPECT_EQ("req2", capture_list[1].hostname);
1722 EXPECT_EQ("req1", capture_list[2].hostname);
1723 }
1724
1725 // Try cancelling a job which has not started yet.
TEST_F(HostResolverManagerTest,CancelPendingRequest)1726 TEST_F(HostResolverManagerTest, CancelPendingRequest) {
1727 CreateSerialResolver();
1728
1729 HostResolver::ResolveHostParameters lowest_priority;
1730 lowest_priority.initial_priority = LOWEST;
1731 HostResolver::ResolveHostParameters low_priority;
1732 low_priority.initial_priority = LOW;
1733 HostResolver::ResolveHostParameters medium_priority;
1734 medium_priority.initial_priority = MEDIUM;
1735 HostResolver::ResolveHostParameters highest_priority;
1736 highest_priority.initial_priority = HIGHEST;
1737
1738 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1739 responses.emplace_back(
1740 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1741 HostPortPair("req0", 80), NetworkIsolationKey(), NetLogWithSource(),
1742 lowest_priority, resolve_context_.get(),
1743 resolve_context_->host_cache())));
1744 responses.emplace_back(
1745 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1746 HostPortPair("req1", 80), NetworkIsolationKey(), NetLogWithSource(),
1747 highest_priority, resolve_context_.get(),
1748 resolve_context_->host_cache())));
1749 responses.emplace_back(
1750 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1751 HostPortPair("req2", 80), NetworkIsolationKey(), NetLogWithSource(),
1752 medium_priority, resolve_context_.get(),
1753 resolve_context_->host_cache())));
1754 responses.emplace_back(
1755 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1756 HostPortPair("req3", 80), NetworkIsolationKey(), NetLogWithSource(),
1757 low_priority, resolve_context_.get(),
1758 resolve_context_->host_cache())));
1759 responses.emplace_back(
1760 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1761 HostPortPair("req4", 80), NetworkIsolationKey(), NetLogWithSource(),
1762 highest_priority, resolve_context_.get(),
1763 resolve_context_->host_cache())));
1764 responses.emplace_back(
1765 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1766 HostPortPair("req5", 80), NetworkIsolationKey(), NetLogWithSource(),
1767 lowest_priority, resolve_context_.get(),
1768 resolve_context_->host_cache())));
1769 responses.emplace_back(
1770 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1771 HostPortPair("req6", 80), NetworkIsolationKey(), NetLogWithSource(),
1772 medium_priority, resolve_context_.get(),
1773 resolve_context_->host_cache())));
1774
1775 // Cancel some requests
1776 responses[1]->CancelRequest();
1777 responses[4]->CancelRequest();
1778 responses[5]->CancelRequest();
1779
1780 // Unblock the resolver thread so the requests can run.
1781 proc_->SignalMultiple(responses.size()); // More than needed.
1782
1783 // Let everything try to finish.
1784 base::RunLoop().RunUntilIdle();
1785
1786 // Wait for all the requests to complete succesfully.
1787 EXPECT_THAT(responses[0]->result_error(), IsOk());
1788 EXPECT_THAT(responses[2]->result_error(), IsOk());
1789 EXPECT_THAT(responses[3]->result_error(), IsOk());
1790 EXPECT_THAT(responses[6]->result_error(), IsOk());
1791
1792 // Cancelled requests shouldn't complete.
1793 EXPECT_FALSE(responses[1]->complete());
1794 EXPECT_FALSE(responses[4]->complete());
1795 EXPECT_FALSE(responses[5]->complete());
1796
1797 // Verify that they called out the the resolver proc (which runs on the
1798 // resolver thread) in the expected order.
1799 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1800 ASSERT_EQ(4u, capture_list.size());
1801
1802 EXPECT_EQ("req0", capture_list[0].hostname);
1803 EXPECT_EQ("req2", capture_list[1].hostname);
1804 EXPECT_EQ("req6", capture_list[2].hostname);
1805 EXPECT_EQ("req3", capture_list[3].hostname);
1806 }
1807
1808 // Test that when too many requests are enqueued, old ones start to be aborted.
TEST_F(HostResolverManagerTest,QueueOverflow)1809 TEST_F(HostResolverManagerTest, QueueOverflow) {
1810 CreateSerialResolver();
1811
1812 // Allow only 3 queued jobs.
1813 const size_t kMaxPendingJobs = 3u;
1814 resolver_->SetMaxQueuedJobsForTesting(kMaxPendingJobs);
1815
1816 HostResolver::ResolveHostParameters lowest_priority;
1817 lowest_priority.initial_priority = LOWEST;
1818 HostResolver::ResolveHostParameters low_priority;
1819 low_priority.initial_priority = LOW;
1820 HostResolver::ResolveHostParameters medium_priority;
1821 medium_priority.initial_priority = MEDIUM;
1822 HostResolver::ResolveHostParameters highest_priority;
1823 highest_priority.initial_priority = HIGHEST;
1824
1825 // Note that at this point the MockHostResolverProc is blocked, so any
1826 // requests we make will not complete.
1827
1828 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
1829 responses.emplace_back(
1830 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1831 HostPortPair("req0", 80), NetworkIsolationKey(), NetLogWithSource(),
1832 lowest_priority, resolve_context_.get(),
1833 resolve_context_->host_cache())));
1834 responses.emplace_back(
1835 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1836 HostPortPair("req1", 80), NetworkIsolationKey(), NetLogWithSource(),
1837 highest_priority, resolve_context_.get(),
1838 resolve_context_->host_cache())));
1839 responses.emplace_back(
1840 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1841 HostPortPair("req2", 80), NetworkIsolationKey(), NetLogWithSource(),
1842 medium_priority, resolve_context_.get(),
1843 resolve_context_->host_cache())));
1844 responses.emplace_back(
1845 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1846 HostPortPair("req3", 80), NetworkIsolationKey(), NetLogWithSource(),
1847 medium_priority, resolve_context_.get(),
1848 resolve_context_->host_cache())));
1849
1850 // At this point, there are 3 enqueued jobs (and one "running" job).
1851 // Insertion of subsequent requests will cause evictions.
1852
1853 responses.emplace_back(
1854 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1855 HostPortPair("req4", 80), NetworkIsolationKey(), NetLogWithSource(),
1856 low_priority, resolve_context_.get(),
1857 resolve_context_->host_cache())));
1858 EXPECT_THAT(responses[4]->result_error(),
1859 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE)); // Evicts self.
1860 EXPECT_FALSE(responses[4]->request()->GetAddressResults());
1861
1862 responses.emplace_back(
1863 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1864 HostPortPair("req5", 80), NetworkIsolationKey(), NetLogWithSource(),
1865 medium_priority, resolve_context_.get(),
1866 resolve_context_->host_cache())));
1867 EXPECT_THAT(responses[2]->result_error(),
1868 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1869 EXPECT_FALSE(responses[2]->request()->GetAddressResults());
1870
1871 responses.emplace_back(
1872 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1873 HostPortPair("req6", 80), NetworkIsolationKey(), NetLogWithSource(),
1874 highest_priority, resolve_context_.get(),
1875 resolve_context_->host_cache())));
1876 EXPECT_THAT(responses[3]->result_error(),
1877 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1878 EXPECT_FALSE(responses[3]->request()->GetAddressResults());
1879
1880 responses.emplace_back(
1881 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
1882 HostPortPair("req7", 80), NetworkIsolationKey(), NetLogWithSource(),
1883 medium_priority, resolve_context_.get(),
1884 resolve_context_->host_cache())));
1885 EXPECT_THAT(responses[5]->result_error(),
1886 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1887 EXPECT_FALSE(responses[5]->request()->GetAddressResults());
1888
1889 // Unblock the resolver thread so the requests can run.
1890 proc_->SignalMultiple(4u);
1891
1892 // The rest should succeed.
1893 EXPECT_THAT(responses[0]->result_error(), IsOk());
1894 EXPECT_TRUE(responses[0]->request()->GetAddressResults());
1895 EXPECT_THAT(responses[1]->result_error(), IsOk());
1896 EXPECT_TRUE(responses[1]->request()->GetAddressResults());
1897 EXPECT_THAT(responses[6]->result_error(), IsOk());
1898 EXPECT_TRUE(responses[6]->request()->GetAddressResults());
1899 EXPECT_THAT(responses[7]->result_error(), IsOk());
1900 EXPECT_TRUE(responses[7]->request()->GetAddressResults());
1901
1902 // Verify that they called out the the resolver proc (which runs on the
1903 // resolver thread) in the expected order.
1904 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList();
1905 ASSERT_EQ(4u, capture_list.size());
1906
1907 EXPECT_EQ("req0", capture_list[0].hostname);
1908 EXPECT_EQ("req1", capture_list[1].hostname);
1909 EXPECT_EQ("req6", capture_list[2].hostname);
1910 EXPECT_EQ("req7", capture_list[3].hostname);
1911
1912 // Verify that the evicted (incomplete) requests were not cached.
1913 EXPECT_EQ(4u, resolve_context_->host_cache()->size());
1914
1915 for (size_t i = 0; i < responses.size(); ++i) {
1916 EXPECT_TRUE(responses[i]->complete()) << i;
1917 }
1918 }
1919
1920 // Tests that jobs can self-evict by setting the max queue to 0.
TEST_F(HostResolverManagerTest,QueueOverflow_SelfEvict)1921 TEST_F(HostResolverManagerTest, QueueOverflow_SelfEvict) {
1922 CreateSerialResolver();
1923 resolver_->SetMaxQueuedJobsForTesting(0);
1924
1925 // Note that at this point the MockHostResolverProc is blocked, so any
1926 // requests we make will not complete.
1927
1928 ResolveHostResponseHelper run_response(resolver_->CreateRequest(
1929 HostPortPair("run", 80), NetworkIsolationKey(), NetLogWithSource(),
1930 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1931
1932 ResolveHostResponseHelper evict_response(resolver_->CreateRequest(
1933 HostPortPair("req1", 80), NetworkIsolationKey(), NetLogWithSource(),
1934 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1935 EXPECT_THAT(evict_response.result_error(),
1936 IsError(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE));
1937 EXPECT_FALSE(evict_response.request()->GetAddressResults());
1938
1939 proc_->SignalMultiple(1u);
1940
1941 EXPECT_THAT(run_response.result_error(), IsOk());
1942 EXPECT_TRUE(run_response.request()->GetAddressResults());
1943 }
1944
1945 // Make sure that the dns query type parameter is respected when raw IPs are
1946 // passed in.
TEST_F(HostResolverManagerTest,AddressFamilyWithRawIPs)1947 TEST_F(HostResolverManagerTest, AddressFamilyWithRawIPs) {
1948 HostResolver::ResolveHostParameters v4_parameters;
1949 v4_parameters.dns_query_type = DnsQueryType::A;
1950
1951 HostResolver::ResolveHostParameters v6_parameters;
1952 v6_parameters.dns_query_type = DnsQueryType::AAAA;
1953
1954 ResolveHostResponseHelper v4_v4_request(resolver_->CreateRequest(
1955 HostPortPair("127.0.0.1", 80), NetworkIsolationKey(), NetLogWithSource(),
1956 v4_parameters, resolve_context_.get(), resolve_context_->host_cache()));
1957 EXPECT_THAT(v4_v4_request.result_error(), IsOk());
1958 EXPECT_THAT(v4_v4_request.request()->GetAddressResults().value().endpoints(),
1959 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
1960
1961 ResolveHostResponseHelper v4_v6_request(resolver_->CreateRequest(
1962 HostPortPair("127.0.0.1", 80), NetworkIsolationKey(), NetLogWithSource(),
1963 v6_parameters, resolve_context_.get(), resolve_context_->host_cache()));
1964 EXPECT_THAT(v4_v6_request.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
1965
1966 ResolveHostResponseHelper v4_unsp_request(resolver_->CreateRequest(
1967 HostPortPair("127.0.0.1", 80), NetworkIsolationKey(), NetLogWithSource(),
1968 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1969 EXPECT_THAT(v4_unsp_request.result_error(), IsOk());
1970 EXPECT_THAT(
1971 v4_unsp_request.request()->GetAddressResults().value().endpoints(),
1972 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
1973
1974 ResolveHostResponseHelper v6_v4_request(resolver_->CreateRequest(
1975 HostPortPair("::1", 80), NetworkIsolationKey(), NetLogWithSource(),
1976 v4_parameters, resolve_context_.get(), resolve_context_->host_cache()));
1977 EXPECT_THAT(v6_v4_request.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
1978
1979 ResolveHostResponseHelper v6_v6_request(resolver_->CreateRequest(
1980 HostPortPair("::1", 80), NetworkIsolationKey(), NetLogWithSource(),
1981 v6_parameters, resolve_context_.get(), resolve_context_->host_cache()));
1982 EXPECT_THAT(v6_v6_request.result_error(), IsOk());
1983 EXPECT_THAT(v6_v6_request.request()->GetAddressResults().value().endpoints(),
1984 testing::ElementsAre(CreateExpected("::1", 80)));
1985
1986 ResolveHostResponseHelper v6_unsp_request(resolver_->CreateRequest(
1987 HostPortPair("::1", 80), NetworkIsolationKey(), NetLogWithSource(),
1988 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
1989 EXPECT_THAT(v6_unsp_request.result_error(), IsOk());
1990 EXPECT_THAT(
1991 v6_unsp_request.request()->GetAddressResults().value().endpoints(),
1992 testing::ElementsAre(CreateExpected("::1", 80)));
1993 }
1994
TEST_F(HostResolverManagerTest,LocalOnly_FromCache)1995 TEST_F(HostResolverManagerTest, LocalOnly_FromCache) {
1996 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
1997 proc_->SignalMultiple(1u); // Need only one.
1998
1999 HostResolver::ResolveHostParameters source_none_parameters;
2000 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
2001
2002 // First NONE query expected to complete synchronously with a cache miss.
2003 ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
2004 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2005 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2006 resolve_context_->host_cache()));
2007 EXPECT_TRUE(cache_miss_request.complete());
2008 EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
2009 EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
2010 EXPECT_FALSE(cache_miss_request.request()->GetStaleInfo());
2011
2012 // Normal query to populate the cache.
2013 ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
2014 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2015 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2016 resolve_context_->host_cache()));
2017 EXPECT_THAT(normal_request.result_error(), IsOk());
2018 EXPECT_FALSE(normal_request.request()->GetStaleInfo());
2019
2020 // Second NONE query expected to complete synchronously with cache hit.
2021 ResolveHostResponseHelper cache_hit_request(resolver_->CreateRequest(
2022 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2023 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2024 resolve_context_->host_cache()));
2025 EXPECT_TRUE(cache_hit_request.complete());
2026 EXPECT_THAT(cache_hit_request.result_error(), IsOk());
2027 EXPECT_THAT(
2028 cache_hit_request.request()->GetAddressResults().value().endpoints(),
2029 testing::ElementsAre(CreateExpected("192.168.1.42", 80)));
2030 EXPECT_FALSE(cache_hit_request.request()->GetStaleInfo().value().is_stale());
2031 }
2032
TEST_F(HostResolverManagerTest,LocalOnly_StaleEntry)2033 TEST_F(HostResolverManagerTest, LocalOnly_StaleEntry) {
2034 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
2035 proc_->SignalMultiple(1u); // Need only one.
2036
2037 HostResolver::ResolveHostParameters source_none_parameters;
2038 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
2039
2040 // First NONE query expected to complete synchronously with a cache miss.
2041 ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
2042 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2043 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2044 resolve_context_->host_cache()));
2045 EXPECT_TRUE(cache_miss_request.complete());
2046 EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
2047 EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
2048 EXPECT_FALSE(cache_miss_request.request()->GetStaleInfo());
2049
2050 // Normal query to populate the cache.
2051 ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
2052 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2053 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2054 resolve_context_->host_cache()));
2055 EXPECT_THAT(normal_request.result_error(), IsOk());
2056 EXPECT_FALSE(normal_request.request()->GetStaleInfo());
2057
2058 MakeCacheStale();
2059
2060 // Second NONE query still expected to complete synchronously with cache miss.
2061 ResolveHostResponseHelper stale_request(resolver_->CreateRequest(
2062 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2063 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2064 resolve_context_->host_cache()));
2065 EXPECT_TRUE(stale_request.complete());
2066 EXPECT_THAT(stale_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
2067 EXPECT_FALSE(stale_request.request()->GetAddressResults());
2068 EXPECT_FALSE(stale_request.request()->GetStaleInfo());
2069 }
2070
TEST_F(HostResolverManagerTest,LocalOnly_FromIp)2071 TEST_F(HostResolverManagerTest, LocalOnly_FromIp) {
2072 HostResolver::ResolveHostParameters source_none_parameters;
2073 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
2074
2075 ResolveHostResponseHelper response(resolver_->CreateRequest(
2076 HostPortPair("1.2.3.4", 56), NetworkIsolationKey(), NetLogWithSource(),
2077 source_none_parameters, resolve_context_.get(),
2078 resolve_context_->host_cache()));
2079
2080 // Expected to resolve synchronously.
2081 EXPECT_TRUE(response.complete());
2082 EXPECT_THAT(response.result_error(), IsOk());
2083 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2084 testing::ElementsAre(CreateExpected("1.2.3.4", 56)));
2085 EXPECT_FALSE(response.request()->GetStaleInfo());
2086 }
2087
TEST_F(HostResolverManagerTest,LocalOnly_InvalidName)2088 TEST_F(HostResolverManagerTest, LocalOnly_InvalidName) {
2089 proc_->AddRuleForAllFamilies("foo,bar.com", "192.168.1.42");
2090
2091 HostResolver::ResolveHostParameters source_none_parameters;
2092 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
2093
2094 ResolveHostResponseHelper response(resolver_->CreateRequest(
2095 HostPortPair("foo,bar.com", 57), NetworkIsolationKey(),
2096 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2097 resolve_context_->host_cache()));
2098
2099 // Expected to fail synchronously.
2100 EXPECT_TRUE(response.complete());
2101 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
2102 EXPECT_FALSE(response.request()->GetAddressResults());
2103 EXPECT_FALSE(response.request()->GetStaleInfo());
2104 }
2105
TEST_F(HostResolverManagerTest,LocalOnly_InvalidLocalhost)2106 TEST_F(HostResolverManagerTest, LocalOnly_InvalidLocalhost) {
2107 HostResolver::ResolveHostParameters source_none_parameters;
2108 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
2109
2110 ResolveHostResponseHelper response(resolver_->CreateRequest(
2111 HostPortPair("foo,bar.localhost", 58), NetworkIsolationKey(),
2112 NetLogWithSource(), source_none_parameters, resolve_context_.get(),
2113 resolve_context_->host_cache()));
2114
2115 // Expected to fail synchronously.
2116 EXPECT_TRUE(response.complete());
2117 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
2118 EXPECT_FALSE(response.request()->GetAddressResults());
2119 EXPECT_FALSE(response.request()->GetStaleInfo());
2120 }
2121
TEST_F(HostResolverManagerTest,StaleAllowed)2122 TEST_F(HostResolverManagerTest, StaleAllowed) {
2123 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
2124 proc_->SignalMultiple(1u); // Need only one.
2125
2126 HostResolver::ResolveHostParameters stale_allowed_parameters;
2127 stale_allowed_parameters.source = HostResolverSource::LOCAL_ONLY;
2128 stale_allowed_parameters.cache_usage =
2129 HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
2130
2131 // First query expected to complete synchronously as a cache miss.
2132 ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
2133 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2134 NetLogWithSource(), stale_allowed_parameters, resolve_context_.get(),
2135 resolve_context_->host_cache()));
2136 EXPECT_TRUE(cache_miss_request.complete());
2137 EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
2138 EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
2139 EXPECT_FALSE(cache_miss_request.request()->GetStaleInfo());
2140
2141 // Normal query to populate cache
2142 ResolveHostResponseHelper normal_request(resolver_->CreateRequest(
2143 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2144 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2145 resolve_context_->host_cache()));
2146 EXPECT_THAT(normal_request.result_error(), IsOk());
2147 EXPECT_FALSE(normal_request.request()->GetStaleInfo());
2148
2149 MakeCacheStale();
2150
2151 // Second NONE query expected to get a stale cache hit.
2152 ResolveHostResponseHelper stale_request(resolver_->CreateRequest(
2153 HostPortPair("just.testing", 84), NetworkIsolationKey(),
2154 NetLogWithSource(), stale_allowed_parameters, resolve_context_.get(),
2155 resolve_context_->host_cache()));
2156 EXPECT_TRUE(stale_request.complete());
2157 EXPECT_THAT(stale_request.result_error(), IsOk());
2158 EXPECT_THAT(stale_request.request()->GetAddressResults().value().endpoints(),
2159 testing::ElementsAre(CreateExpected("192.168.1.42", 84)));
2160 EXPECT_TRUE(stale_request.request()->GetStaleInfo().value().is_stale());
2161 }
2162
TEST_F(HostResolverManagerTest,StaleAllowed_NonLocal)2163 TEST_F(HostResolverManagerTest, StaleAllowed_NonLocal) {
2164 proc_->AddRuleForAllFamilies("just.testing", "192.168.2.42");
2165 proc_->SignalMultiple(1u); // Need only one.
2166
2167 HostResolver::ResolveHostParameters stale_allowed_parameters;
2168 stale_allowed_parameters.cache_usage =
2169 HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
2170
2171 // Normal non-local resolves should still work normally with the STALE_ALLOWED
2172 // parameter, and there should be no stale info.
2173 ResolveHostResponseHelper response(resolver_->CreateRequest(
2174 HostPortPair("just.testing", 85), NetworkIsolationKey(),
2175 NetLogWithSource(), stale_allowed_parameters, resolve_context_.get(),
2176 resolve_context_->host_cache()));
2177 EXPECT_THAT(response.result_error(), IsOk());
2178 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2179 testing::ElementsAre(CreateExpected("192.168.2.42", 85)));
2180 EXPECT_FALSE(response.request()->GetStaleInfo());
2181 }
2182
TEST_F(HostResolverManagerTest,StaleAllowed_FromIp)2183 TEST_F(HostResolverManagerTest, StaleAllowed_FromIp) {
2184 HostResolver::ResolveHostParameters stale_allowed_parameters;
2185 stale_allowed_parameters.cache_usage =
2186 HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
2187
2188 ResolveHostResponseHelper response(resolver_->CreateRequest(
2189 HostPortPair("1.2.3.4", 57), NetworkIsolationKey(), NetLogWithSource(),
2190 stale_allowed_parameters, resolve_context_.get(),
2191 resolve_context_->host_cache()));
2192
2193 // Expected to resolve synchronously without stale info.
2194 EXPECT_TRUE(response.complete());
2195 EXPECT_THAT(response.result_error(), IsOk());
2196 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2197 testing::ElementsAre(CreateExpected("1.2.3.4", 57)));
2198 EXPECT_FALSE(response.request()->GetStaleInfo());
2199 }
2200
2201 // TODO(mgersh): add a test case for errors with positive TTL after
2202 // https://crbug.com/115051 is fixed.
2203
2204 // Test the retry attempts simulating host resolver proc that takes too long.
TEST_F(HostResolverManagerTest,MultipleAttempts)2205 TEST_F(HostResolverManagerTest, MultipleAttempts) {
2206 // Total number of attempts would be 3 and we want the 3rd attempt to resolve
2207 // the host. First and second attempt will be forced to wait until they get
2208 // word that a resolution has completed. The 3rd resolution attempt will try
2209 // to get done ASAP, and won't wait.
2210 int kAttemptNumberToResolve = 3;
2211 int kTotalAttempts = 3;
2212
2213 // Add a little bit of extra fudge to the delay to allow reasonable
2214 // flexibility for time > vs >= etc. We don't need to fail the test if we
2215 // retry at t=6001 instead of t=6000.
2216 base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1);
2217
2218 scoped_refptr<LookupAttemptHostResolverProc> resolver_proc(
2219 new LookupAttemptHostResolverProc(nullptr, kAttemptNumberToResolve,
2220 kTotalAttempts));
2221
2222 ProcTaskParams params = DefaultParams(resolver_proc.get());
2223 base::TimeDelta unresponsive_delay = params.unresponsive_delay;
2224 int retry_factor = params.retry_factor;
2225
2226 CreateResolverWithLimitsAndParams(kMaxJobs, params, true /* ipv6_reachable */,
2227 true /* check_ipv6_on_wifi */);
2228
2229 // Override the current thread task runner, so we can simulate the passage of
2230 // time and avoid any actual sleeps.
2231 auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
2232 base::ScopedClosureRunner task_runner_override_scoped_cleanup =
2233 base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
2234
2235 // Resolve "host1".
2236 ResolveHostResponseHelper response(resolver_->CreateRequest(
2237 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
2238 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
2239 EXPECT_FALSE(response.complete());
2240
2241 resolver_proc->WaitForNAttemptsToBeBlocked(1);
2242 EXPECT_FALSE(response.complete());
2243
2244 test_task_runner->FastForwardBy(unresponsive_delay + kSleepFudgeFactor);
2245 resolver_proc->WaitForNAttemptsToBeBlocked(2);
2246 EXPECT_FALSE(response.complete());
2247
2248 test_task_runner->FastForwardBy(unresponsive_delay * retry_factor +
2249 kSleepFudgeFactor);
2250
2251 resolver_proc->WaitForAllAttemptsToFinish();
2252 test_task_runner->RunUntilIdle();
2253
2254 // Resolve returns -4 to indicate that 3rd attempt has resolved the host.
2255 // Since we're using a TestMockTimeTaskRunner, the RunLoop stuff in
2256 // result_error() will fail if it actually has to wait, but unless there's an
2257 // error, the result should be immediately ready by this point.
2258 EXPECT_EQ(-4, response.result_error());
2259
2260 // We should be done with retries, but make sure none erroneously happen.
2261 test_task_runner->FastForwardUntilNoTasksRemain();
2262
2263 EXPECT_EQ(resolver_proc->GetTotalAttemptsResolved(), kTotalAttempts);
2264 }
2265
2266 // Regression test for https://crbug.com/976948.
2267 //
2268 // Tests that when the maximum number of retries is set to
2269 // |HostResolver::ManagerOptions::kDefaultRetryAttempts| the
2270 // number of retries used is 4 rather than something higher.
TEST_F(HostResolverManagerTest,DefaultMaxRetryAttempts)2271 TEST_F(HostResolverManagerTest, DefaultMaxRetryAttempts) {
2272 auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
2273 base::ScopedClosureRunner task_runner_override_scoped_cleanup =
2274 base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
2275
2276 // Instantiate a ResolverProc that will block all incoming requests.
2277 auto resolver_proc = base::MakeRefCounted<LookupAttemptHostResolverProc>(
2278 nullptr, std::numeric_limits<size_t>::max(),
2279 std::numeric_limits<size_t>::max());
2280
2281 // This corresponds to kDefaultMaxRetryAttempts in
2282 // ProcTaskParams::ProcTaskParams(). The correspondence is verified below,
2283 // since that symbol is not exported.
2284 const size_t expected_max_retries = 4;
2285
2286 // Use the special value |ManagerOptions::kDefaultRetryAttempts|, which is
2287 // expected to translate into |expected_num_retries|.
2288 ASSERT_NE(HostResolver::ManagerOptions::kDefaultRetryAttempts,
2289 expected_max_retries);
2290 ProcTaskParams params(resolver_proc.get(),
2291 HostResolver::ManagerOptions::kDefaultRetryAttempts);
2292 ASSERT_EQ(params.max_retry_attempts, expected_max_retries);
2293
2294 CreateResolverWithLimitsAndParams(kMaxJobs, params,
2295 false /* ipv6_reachable */,
2296 false /* check_ipv6_on_wifi */);
2297
2298 // Resolve "host1". The resolver proc will hang all requests so this
2299 // resolution should remain stalled until calling SetResolvedAttemptNumber().
2300 ResolveHostResponseHelper response(resolver_->CreateRequest(
2301 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
2302 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
2303 EXPECT_FALSE(response.complete());
2304
2305 // Simulate running the main thread (network task runner) for a long
2306 // time. Because none of the attempts posted to worker pool can complete, this
2307 // should cause all of the retry attempts to get posted, according to the
2308 // exponential backoff schedule.
2309 test_task_runner->FastForwardBy(base::TimeDelta::FromMinutes(20));
2310
2311 // Unblock the resolver proc, then wait for all the worker pool and main
2312 // thread tasks to complete. Note that the call to SetResolvedAttemptNumber(1)
2313 // will cause all the blocked resolver procs tasks fail with -2.
2314 resolver_proc->SetResolvedAttemptNumber(1);
2315 const int kExpectedError = -2;
2316 base::ThreadPoolInstance::Get()->FlushForTesting();
2317 test_task_runner->RunUntilIdle();
2318
2319 ASSERT_TRUE(response.complete());
2320 EXPECT_EQ(kExpectedError, response.result_error());
2321
2322 // Ensure that the original attempt was executed on the worker pool, as well
2323 // as the maximum number of allowed retries, and no more.
2324 EXPECT_EQ(static_cast<int>(expected_max_retries + 1),
2325 resolver_proc->GetTotalAttemptsResolved());
2326 }
2327
2328 // If a host resolves to a list that includes 127.0.53.53, this is treated as
2329 // an error. 127.0.53.53 is a localhost address, however it has been given a
2330 // special significance by ICANN to help surface name collision resulting from
2331 // the new gTLDs.
TEST_F(HostResolverManagerTest,NameCollisionIcann)2332 TEST_F(HostResolverManagerTest, NameCollisionIcann) {
2333 proc_->AddRuleForAllFamilies("single", "127.0.53.53");
2334 proc_->AddRuleForAllFamilies("multiple", "127.0.0.1,127.0.53.53");
2335 proc_->AddRuleForAllFamilies("ipv6", "::127.0.53.53");
2336 proc_->AddRuleForAllFamilies("not_reserved1", "53.53.0.127");
2337 proc_->AddRuleForAllFamilies("not_reserved2", "127.0.53.54");
2338 proc_->AddRuleForAllFamilies("not_reserved3", "10.0.53.53");
2339 proc_->SignalMultiple(6u);
2340
2341 ResolveHostResponseHelper single_response(resolver_->CreateRequest(
2342 HostPortPair("single", 80), NetworkIsolationKey(), NetLogWithSource(),
2343 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
2344 EXPECT_THAT(single_response.result_error(),
2345 IsError(ERR_ICANN_NAME_COLLISION));
2346 EXPECT_FALSE(single_response.request()->GetAddressResults());
2347
2348 // ERR_ICANN_NAME_COLLISION is cached like any other error, using a fixed TTL
2349 // for failed entries from proc-based resolver. That said, the fixed TTL is 0,
2350 // so it should never be cached.
2351 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
2352 GetCacheHit(HostCache::Key(
2353 "single", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
2354 HostResolverSource::ANY, NetworkIsolationKey()));
2355 EXPECT_FALSE(cache_result);
2356
2357 ResolveHostResponseHelper multiple_response(resolver_->CreateRequest(
2358 HostPortPair("multiple", 80), NetworkIsolationKey(), NetLogWithSource(),
2359 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
2360 EXPECT_THAT(multiple_response.result_error(),
2361 IsError(ERR_ICANN_NAME_COLLISION));
2362
2363 // Resolving an IP literal of 127.0.53.53 however is allowed.
2364 ResolveHostResponseHelper literal_response(resolver_->CreateRequest(
2365 HostPortPair("127.0.53.53", 80), NetworkIsolationKey(),
2366 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2367 resolve_context_->host_cache()));
2368 EXPECT_THAT(literal_response.result_error(), IsOk());
2369
2370 // Moreover the address should not be recognized when embedded in an IPv6
2371 // address.
2372 ResolveHostResponseHelper ipv6_response(resolver_->CreateRequest(
2373 HostPortPair("127.0.53.53", 80), NetworkIsolationKey(),
2374 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2375 resolve_context_->host_cache()));
2376 EXPECT_THAT(ipv6_response.result_error(), IsOk());
2377
2378 // Try some other IPs which are similar, but NOT an exact match on
2379 // 127.0.53.53.
2380 ResolveHostResponseHelper similar_response1(resolver_->CreateRequest(
2381 HostPortPair("not_reserved1", 80), NetworkIsolationKey(),
2382 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2383 resolve_context_->host_cache()));
2384 EXPECT_THAT(similar_response1.result_error(), IsOk());
2385
2386 ResolveHostResponseHelper similar_response2(resolver_->CreateRequest(
2387 HostPortPair("not_reserved2", 80), NetworkIsolationKey(),
2388 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2389 resolve_context_->host_cache()));
2390 EXPECT_THAT(similar_response2.result_error(), IsOk());
2391
2392 ResolveHostResponseHelper similar_response3(resolver_->CreateRequest(
2393 HostPortPair("not_reserved3", 80), NetworkIsolationKey(),
2394 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2395 resolve_context_->host_cache()));
2396 EXPECT_THAT(similar_response3.result_error(), IsOk());
2397 }
2398
TEST_F(HostResolverManagerTest,IsIPv6Reachable)2399 TEST_F(HostResolverManagerTest, IsIPv6Reachable) {
2400 // The real HostResolverManager is needed since TestHostResolverManager will
2401 // bypass the IPv6 reachability tests.
2402 DestroyResolver();
2403 resolver_ = std::make_unique<HostResolverManager>(
2404 DefaultOptions(), nullptr /* system_dns_config_notifier */,
2405 nullptr /* net_log */);
2406
2407 // Verify that two consecutive calls return the same value.
2408 RecordingTestNetLog test_net_log;
2409 NetLogWithSource net_log =
2410 NetLogWithSource::Make(&test_net_log, NetLogSourceType::NONE);
2411 bool result1 = IsIPv6Reachable(net_log);
2412 bool result2 = IsIPv6Reachable(net_log);
2413 EXPECT_EQ(result1, result2);
2414
2415 // Filter reachability check events and verify that there are two of them.
2416 auto probe_event_list = test_net_log.GetEntriesWithType(
2417 NetLogEventType::HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK);
2418 ASSERT_EQ(2U, probe_event_list.size());
2419
2420 // Verify that the first request was not cached and the second one was.
2421 EXPECT_FALSE(GetBooleanValueFromParams(probe_event_list[0], "cached"));
2422 EXPECT_TRUE(GetBooleanValueFromParams(probe_event_list[1], "cached"));
2423 }
2424
TEST_F(HostResolverManagerTest,IncludeCanonicalName)2425 TEST_F(HostResolverManagerTest, IncludeCanonicalName) {
2426 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42",
2427 HOST_RESOLVER_CANONNAME, "canon.name");
2428 proc_->SignalMultiple(2u);
2429
2430 HostResolver::ResolveHostParameters parameters;
2431 parameters.include_canonical_name = true;
2432 ResolveHostResponseHelper response(resolver_->CreateRequest(
2433 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2434 NetLogWithSource(), parameters, resolve_context_.get(),
2435 resolve_context_->host_cache()));
2436 ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest(
2437 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2438 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2439 resolve_context_->host_cache()));
2440
2441 EXPECT_THAT(response.result_error(), IsOk());
2442 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2443 testing::ElementsAre(CreateExpected("192.168.1.42", 80)));
2444 EXPECT_EQ("canon.name",
2445 response.request()->GetAddressResults().value().canonical_name());
2446
2447 EXPECT_THAT(response_no_flag.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
2448 }
2449
TEST_F(HostResolverManagerTest,LoopbackOnly)2450 TEST_F(HostResolverManagerTest, LoopbackOnly) {
2451 proc_->AddRuleForAllFamilies("otherlocal", "127.0.0.1",
2452 HOST_RESOLVER_LOOPBACK_ONLY);
2453 proc_->SignalMultiple(2u);
2454
2455 HostResolver::ResolveHostParameters parameters;
2456 parameters.loopback_only = true;
2457 ResolveHostResponseHelper response(resolver_->CreateRequest(
2458 HostPortPair("otherlocal", 80), NetworkIsolationKey(), NetLogWithSource(),
2459 parameters, resolve_context_.get(), resolve_context_->host_cache()));
2460 ResolveHostResponseHelper response_no_flag(resolver_->CreateRequest(
2461 HostPortPair("otherlocal", 80), NetworkIsolationKey(), NetLogWithSource(),
2462 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
2463
2464 EXPECT_THAT(response.result_error(), IsOk());
2465 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2466 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
2467
2468 EXPECT_THAT(response_no_flag.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
2469 }
2470
TEST_F(HostResolverManagerTest,IsSpeculative)2471 TEST_F(HostResolverManagerTest, IsSpeculative) {
2472 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
2473 proc_->SignalMultiple(1u);
2474
2475 HostResolver::ResolveHostParameters parameters;
2476 parameters.is_speculative = true;
2477
2478 ResolveHostResponseHelper response(resolver_->CreateRequest(
2479 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2480 NetLogWithSource(), parameters, resolve_context_.get(),
2481 resolve_context_->host_cache()));
2482
2483 EXPECT_THAT(response.result_error(), IsOk());
2484 EXPECT_FALSE(response.request()->GetAddressResults());
2485
2486 ASSERT_EQ(1u, proc_->GetCaptureList().size());
2487 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
2488
2489 // Reresolve without the |is_speculative| flag should immediately return from
2490 // cache.
2491 ResolveHostResponseHelper response2(resolver_->CreateRequest(
2492 HostPortPair("just.testing", 80), NetworkIsolationKey(),
2493 NetLogWithSource(), base::nullopt, resolve_context_.get(),
2494 resolve_context_->host_cache()));
2495
2496 EXPECT_THAT(response2.result_error(), IsOk());
2497 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
2498 testing::ElementsAre(CreateExpected("192.168.1.42", 80)));
2499
2500 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
2501 EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No increase.
2502 }
2503
2504 #if BUILDFLAG(ENABLE_MDNS)
2505 const uint8_t kMdnsResponseA[] = {
2506 // Header
2507 0x00, 0x00, // ID is zeroed out
2508 0x81, 0x80, // Standard query response, RA, no error
2509 0x00, 0x00, // No questions (for simplicity)
2510 0x00, 0x01, // 1 RR (answers)
2511 0x00, 0x00, // 0 authority RRs
2512 0x00, 0x00, // 0 additional RRs
2513
2514 // "myhello.local."
2515 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2516 0x00,
2517
2518 0x00, 0x01, // TYPE is A.
2519 0x00, 0x01, // CLASS is IN.
2520 0x00, 0x00, 0x00, 0x10, // TTL is 16 (seconds)
2521 0x00, 0x04, // RDLENGTH is 4 bytes.
2522 0x01, 0x02, 0x03, 0x04, // 1.2.3.4
2523 };
2524
2525 const uint8_t kMdnsResponseA2[] = {
2526 // Header
2527 0x00, 0x00, // ID is zeroed out
2528 0x81, 0x80, // Standard query response, RA, no error
2529 0x00, 0x00, // No questions (for simplicity)
2530 0x00, 0x01, // 1 RR (answers)
2531 0x00, 0x00, // 0 authority RRs
2532 0x00, 0x00, // 0 additional RRs
2533
2534 // "myhello.local."
2535 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2536 0x00,
2537
2538 0x00, 0x01, // TYPE is A.
2539 0x00, 0x01, // CLASS is IN.
2540 0x00, 0x00, 0x00, 0x10, // TTL is 16 (seconds)
2541 0x00, 0x04, // RDLENGTH is 4 bytes.
2542 0x05, 0x06, 0x07, 0x08, // 5.6.7.8
2543 };
2544
2545 const uint8_t kMdnsResponseA2Goodbye[] = {
2546 // Header
2547 0x00, 0x00, // ID is zeroed out
2548 0x81, 0x80, // Standard query response, RA, no error
2549 0x00, 0x00, // No questions (for simplicity)
2550 0x00, 0x01, // 1 RR (answers)
2551 0x00, 0x00, // 0 authority RRs
2552 0x00, 0x00, // 0 additional RRs
2553
2554 // "myhello.local."
2555 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2556 0x00,
2557
2558 0x00, 0x01, // TYPE is A.
2559 0x00, 0x01, // CLASS is IN.
2560 0x00, 0x00, 0x00, 0x00, // TTL is 0 (signaling "goodbye" removal of result)
2561 0x00, 0x04, // RDLENGTH is 4 bytes.
2562 0x05, 0x06, 0x07, 0x08, // 5.6.7.8
2563 };
2564
2565 const uint8_t kMdnsResponseAAAA[] = {
2566 // Header
2567 0x00, 0x00, // ID is zeroed out
2568 0x81, 0x80, // Standard query response, RA, no error
2569 0x00, 0x00, // No questions (for simplicity)
2570 0x00, 0x01, // 1 RR (answers)
2571 0x00, 0x00, // 0 authority RRs
2572 0x00, 0x00, // 0 additional RRs
2573
2574 // "myhello.local."
2575 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2576 0x00,
2577
2578 0x00, 0x1C, // TYPE is AAAA.
2579 0x00, 0x01, // CLASS is IN.
2580 0x00, 0x00, 0x00, 0x10, // TTL is 16 (seconds)
2581 0x00, 0x10, // RDLENGTH is 16 bytes.
2582
2583 // 000a:0000:0000:0000:0001:0002:0003:0004
2584 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02,
2585 0x00, 0x03, 0x00, 0x04};
2586
2587 // An MDNS response indicating that the responder owns the hostname, but the
2588 // specific requested type (AAAA) does not exist because the responder only has
2589 // A addresses.
2590 const uint8_t kMdnsResponseNsec[] = {
2591 // Header
2592 0x00, 0x00, // ID is zeroed out
2593 0x81, 0x80, // Standard query response, RA, no error
2594 0x00, 0x00, // No questions (for simplicity)
2595 0x00, 0x01, // 1 RR (answers)
2596 0x00, 0x00, // 0 authority RRs
2597 0x00, 0x00, // 0 additional RRs
2598
2599 // "myhello.local."
2600 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2601 0x00,
2602
2603 0x00, 0x2f, // TYPE is NSEC.
2604 0x00, 0x01, // CLASS is IN.
2605 0x00, 0x00, 0x00, 0x10, // TTL is 16 (seconds)
2606 0x00, 0x06, // RDLENGTH is 6 bytes.
2607 0xc0, 0x0c, // Next Domain Name (always pointer back to name in MDNS)
2608 0x00, // Bitmap block number (always 0 in MDNS)
2609 0x02, // Bitmap length is 2
2610 0x00, 0x08 // A type only
2611 };
2612
2613 const uint8_t kMdnsResponseTxt[] = {
2614 // Header
2615 0x00, 0x00, // ID is zeroed out
2616 0x81, 0x80, // Standard query response, RA, no error
2617 0x00, 0x00, // No questions (for simplicity)
2618 0x00, 0x01, // 1 RR (answers)
2619 0x00, 0x00, // 0 authority RRs
2620 0x00, 0x00, // 0 additional RRs
2621
2622 // "myhello.local."
2623 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2624 0x00,
2625
2626 0x00, 0x10, // TYPE is TXT.
2627 0x00, 0x01, // CLASS is IN.
2628 0x00, 0x00, 0x00, 0x11, // TTL is 17 (seconds)
2629 0x00, 0x08, // RDLENGTH is 8 bytes.
2630
2631 // "foo"
2632 0x03, 0x66, 0x6f, 0x6f,
2633 // "bar"
2634 0x03, 0x62, 0x61, 0x72};
2635
2636 const uint8_t kMdnsResponsePtr[] = {
2637 // Header
2638 0x00, 0x00, // ID is zeroed out
2639 0x81, 0x80, // Standard query response, RA, no error
2640 0x00, 0x00, // No questions (for simplicity)
2641 0x00, 0x01, // 1 RR (answers)
2642 0x00, 0x00, // 0 authority RRs
2643 0x00, 0x00, // 0 additional RRs
2644
2645 // "myhello.local."
2646 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2647 0x00,
2648
2649 0x00, 0x0c, // TYPE is PTR.
2650 0x00, 0x01, // CLASS is IN.
2651 0x00, 0x00, 0x00, 0x12, // TTL is 18 (seconds)
2652 0x00, 0x09, // RDLENGTH is 9 bytes.
2653
2654 // "foo.com."
2655 0x03, 'f', 'o', 'o', 0x03, 'c', 'o', 'm', 0x00};
2656
2657 const uint8_t kMdnsResponsePtrRoot[] = {
2658 // Header
2659 0x00, 0x00, // ID is zeroed out
2660 0x81, 0x80, // Standard query response, RA, no error
2661 0x00, 0x00, // No questions (for simplicity)
2662 0x00, 0x01, // 1 RR (answers)
2663 0x00, 0x00, // 0 authority RRs
2664 0x00, 0x00, // 0 additional RRs
2665
2666 // "myhello.local."
2667 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2668 0x00,
2669
2670 0x00, 0x0c, // TYPE is PTR.
2671 0x00, 0x01, // CLASS is IN.
2672 0x00, 0x00, 0x00, 0x13, // TTL is 19 (seconds)
2673 0x00, 0x01, // RDLENGTH is 1 byte.
2674
2675 // "." (the root domain)
2676 0x00};
2677
2678 const uint8_t kMdnsResponseSrv[] = {
2679 // Header
2680 0x00, 0x00, // ID is zeroed out
2681 0x81, 0x80, // Standard query response, RA, no error
2682 0x00, 0x00, // No questions (for simplicity)
2683 0x00, 0x01, // 1 RR (answers)
2684 0x00, 0x00, // 0 authority RRs
2685 0x00, 0x00, // 0 additional RRs
2686
2687 // "myhello.local."
2688 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2689 0x00,
2690
2691 0x00, 0x21, // TYPE is SRV.
2692 0x00, 0x01, // CLASS is IN.
2693 0x00, 0x00, 0x00, 0x13, // TTL is 19 (seconds)
2694 0x00, 0x0f, // RDLENGTH is 15 bytes.
2695
2696 0x00, 0x05, // Priority 5
2697 0x00, 0x01, // Weight 1
2698 0x20, 0x49, // Port 8265
2699
2700 // "foo.com."
2701 0x03, 'f', 'o', 'o', 0x03, 'c', 'o', 'm', 0x00};
2702
2703 const uint8_t kMdnsResponseSrvUnrestricted[] = {
2704 // Header
2705 0x00, 0x00, // ID is zeroed out
2706 0x81, 0x80, // Standard query response, RA, no error
2707 0x00, 0x00, // No questions (for simplicity)
2708 0x00, 0x01, // 1 RR (answers)
2709 0x00, 0x00, // 0 authority RRs
2710 0x00, 0x00, // 0 additional RRs
2711
2712 // "foo bar(A1B2)._ipps._tcp.local"
2713 0x0d, 'f', 'o', 'o', ' ', 'b', 'a', 'r', '(', 'A', '1', 'B', '2', ')', 0x05,
2714 '_', 'i', 'p', 'p', 's', 0x04, '_', 't', 'c', 'p', 0x05, 'l', 'o', 'c', 'a',
2715 'l', 0x00,
2716
2717 0x00, 0x21, // TYPE is SRV.
2718 0x00, 0x01, // CLASS is IN.
2719 0x00, 0x00, 0x00, 0x13, // TTL is 19 (seconds)
2720 0x00, 0x0f, // RDLENGTH is 15 bytes.
2721
2722 0x00, 0x05, // Priority 5
2723 0x00, 0x01, // Weight 1
2724 0x20, 0x49, // Port 8265
2725
2726 // "foo.com."
2727 0x03, 'f', 'o', 'o', 0x03, 'c', 'o', 'm', 0x00};
2728
2729 const uint8_t kMdnsResponseSrvUnrestrictedResult[] = {
2730 // Header
2731 0x00, 0x00, // ID is zeroed out
2732 0x81, 0x80, // Standard query response, RA, no error
2733 0x00, 0x00, // No questions (for simplicity)
2734 0x00, 0x01, // 1 RR (answers)
2735 0x00, 0x00, // 0 authority RRs
2736 0x00, 0x00, // 0 additional RRs
2737
2738 // "myhello.local."
2739 0x07, 'm', 'y', 'h', 'e', 'l', 'l', 'o', 0x05, 'l', 'o', 'c', 'a', 'l',
2740 0x00,
2741
2742 0x00, 0x21, // TYPE is SRV.
2743 0x00, 0x01, // CLASS is IN.
2744 0x00, 0x00, 0x00, 0x13, // TTL is 19 (seconds)
2745 0x00, 0x15, // RDLENGTH is 21 bytes.
2746
2747 0x00, 0x05, // Priority 5
2748 0x00, 0x01, // Weight 1
2749 0x20, 0x49, // Port 8265
2750
2751 // "foo bar.local"
2752 0x07, 'f', 'o', 'o', ' ', 'b', 'a', 'r', 0x05, 'l', 'o', 'c', 'a', 'l',
2753 0x00};
2754
TEST_F(HostResolverManagerTest,Mdns)2755 TEST_F(HostResolverManagerTest, Mdns) {
2756 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2757 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2758 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2759 // 2 socket creations for every transaction.
2760 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(4);
2761
2762 HostResolver::ResolveHostParameters parameters;
2763 parameters.source = HostResolverSource::MULTICAST_DNS;
2764
2765 ResolveHostResponseHelper response(resolver_->CreateRequest(
2766 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
2767 NetLogWithSource(), parameters, resolve_context_.get(),
2768 resolve_context_->host_cache()));
2769
2770 socket_factory_ptr->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
2771 socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
2772 sizeof(kMdnsResponseAAAA));
2773
2774 EXPECT_THAT(response.result_error(), IsOk());
2775 EXPECT_THAT(
2776 response.request()->GetAddressResults().value().endpoints(),
2777 testing::UnorderedElementsAre(
2778 CreateExpected("1.2.3.4", 80),
2779 CreateExpected("000a:0000:0000:0000:0001:0002:0003:0004", 80)));
2780 EXPECT_FALSE(response.request()->GetTextResults());
2781 EXPECT_FALSE(response.request()->GetHostnameResults());
2782 EXPECT_FALSE(response.request()->GetEsniResults());
2783 }
2784
TEST_F(HostResolverManagerTest,Mdns_AaaaOnly)2785 TEST_F(HostResolverManagerTest, Mdns_AaaaOnly) {
2786 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2787 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2788 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2789 // 2 socket creations for every transaction.
2790 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
2791
2792 HostResolver::ResolveHostParameters parameters;
2793 parameters.dns_query_type = DnsQueryType::AAAA;
2794 parameters.source = HostResolverSource::MULTICAST_DNS;
2795
2796 ResolveHostResponseHelper response(resolver_->CreateRequest(
2797 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
2798 NetLogWithSource(), parameters, resolve_context_.get(),
2799 resolve_context_->host_cache()));
2800
2801 socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
2802 sizeof(kMdnsResponseAAAA));
2803
2804 EXPECT_THAT(response.result_error(), IsOk());
2805 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
2806 testing::ElementsAre(CreateExpected(
2807 "000a:0000:0000:0000:0001:0002:0003:0004", 80)));
2808 }
2809
TEST_F(HostResolverManagerTest,Mdns_Txt)2810 TEST_F(HostResolverManagerTest, Mdns_Txt) {
2811 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2812 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2813 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2814 // 2 socket creations for every transaction.
2815 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
2816
2817 HostResolver::ResolveHostParameters parameters;
2818 parameters.dns_query_type = DnsQueryType::TXT;
2819 parameters.source = HostResolverSource::MULTICAST_DNS;
2820
2821 ResolveHostResponseHelper response(resolver_->CreateRequest(
2822 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
2823 NetLogWithSource(), parameters, resolve_context_.get(),
2824 resolve_context_->host_cache()));
2825
2826 socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
2827 sizeof(kMdnsResponseTxt));
2828
2829 EXPECT_THAT(response.result_error(), IsOk());
2830 EXPECT_FALSE(response.request()->GetAddressResults());
2831 EXPECT_THAT(response.request()->GetTextResults(),
2832 testing::Optional(testing::ElementsAre("foo", "bar")));
2833 EXPECT_FALSE(response.request()->GetHostnameResults());
2834 EXPECT_FALSE(response.request()->GetEsniResults());
2835 }
2836
TEST_F(HostResolverManagerTest,Mdns_Ptr)2837 TEST_F(HostResolverManagerTest, Mdns_Ptr) {
2838 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2839 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2840 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2841 // 2 socket creations for every transaction.
2842 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
2843
2844 HostResolver::ResolveHostParameters parameters;
2845 parameters.dns_query_type = DnsQueryType::PTR;
2846 parameters.source = HostResolverSource::MULTICAST_DNS;
2847
2848 ResolveHostResponseHelper response(resolver_->CreateRequest(
2849 HostPortPair("myhello.local", 83), NetworkIsolationKey(),
2850 NetLogWithSource(), parameters, resolve_context_.get(),
2851 resolve_context_->host_cache()));
2852
2853 socket_factory_ptr->SimulateReceive(kMdnsResponsePtr,
2854 sizeof(kMdnsResponsePtr));
2855
2856 EXPECT_THAT(response.result_error(), IsOk());
2857 EXPECT_FALSE(response.request()->GetAddressResults());
2858 EXPECT_FALSE(response.request()->GetTextResults());
2859 EXPECT_FALSE(response.request()->GetEsniResults());
2860 EXPECT_THAT(
2861 response.request()->GetHostnameResults(),
2862 testing::Optional(testing::ElementsAre(HostPortPair("foo.com", 83))));
2863 }
2864
TEST_F(HostResolverManagerTest,Mdns_Srv)2865 TEST_F(HostResolverManagerTest, Mdns_Srv) {
2866 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2867 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2868 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2869 // 2 socket creations for every transaction.
2870 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
2871
2872 HostResolver::ResolveHostParameters parameters;
2873 parameters.dns_query_type = DnsQueryType::SRV;
2874 parameters.source = HostResolverSource::MULTICAST_DNS;
2875
2876 ResolveHostResponseHelper response(resolver_->CreateRequest(
2877 HostPortPair("myhello.local", 83), NetworkIsolationKey(),
2878 NetLogWithSource(), parameters, resolve_context_.get(),
2879 resolve_context_->host_cache()));
2880
2881 socket_factory_ptr->SimulateReceive(kMdnsResponseSrv,
2882 sizeof(kMdnsResponseSrv));
2883
2884 EXPECT_THAT(response.result_error(), IsOk());
2885 EXPECT_FALSE(response.request()->GetAddressResults());
2886 EXPECT_FALSE(response.request()->GetTextResults());
2887 EXPECT_FALSE(response.request()->GetEsniResults());
2888 EXPECT_THAT(
2889 response.request()->GetHostnameResults(),
2890 testing::Optional(testing::ElementsAre(HostPortPair("foo.com", 8265))));
2891 }
2892
2893 // Test that we are able to create multicast DNS requests that contain
2894 // characters not permitted in the DNS spec such as spaces and parenthesis.
TEST_F(HostResolverManagerTest,Mdns_Srv_Unrestricted)2895 TEST_F(HostResolverManagerTest, Mdns_Srv_Unrestricted) {
2896 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2897 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2898 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2899
2900 HostResolver::ResolveHostParameters parameters;
2901 parameters.dns_query_type = DnsQueryType::SRV;
2902 parameters.source = HostResolverSource::MULTICAST_DNS;
2903
2904 ResolveHostResponseHelper response(resolver_->CreateRequest(
2905 HostPortPair("foo bar(A1B2)._ipps._tcp.local", 83), NetworkIsolationKey(),
2906 NetLogWithSource(), parameters, resolve_context_.get(),
2907 resolve_context_->host_cache()));
2908
2909 socket_factory_ptr->SimulateReceive(kMdnsResponseSrvUnrestricted,
2910 sizeof(kMdnsResponseSrvUnrestricted));
2911
2912 EXPECT_THAT(response.result_error(), IsOk());
2913 EXPECT_FALSE(response.request()->GetAddressResults());
2914 EXPECT_FALSE(response.request()->GetTextResults());
2915 EXPECT_FALSE(response.request()->GetEsniResults());
2916 EXPECT_THAT(
2917 response.request()->GetHostnameResults(),
2918 testing::Optional(testing::ElementsAre(HostPortPair("foo.com", 8265))));
2919 }
2920
2921 // Test that we are able to create multicast DNS requests that contain
2922 // characters not permitted in the DNS spec such as spaces and parenthesis.
TEST_F(HostResolverManagerTest,Mdns_Srv_Result_Unrestricted)2923 TEST_F(HostResolverManagerTest, Mdns_Srv_Result_Unrestricted) {
2924 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2925 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2926 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2927
2928 HostResolver::ResolveHostParameters parameters;
2929 parameters.dns_query_type = DnsQueryType::SRV;
2930 parameters.source = HostResolverSource::MULTICAST_DNS;
2931
2932 ResolveHostResponseHelper response(resolver_->CreateRequest(
2933 HostPortPair("myhello.local", 83), NetworkIsolationKey(),
2934 NetLogWithSource(), parameters, resolve_context_.get(),
2935 resolve_context_->host_cache()));
2936
2937 socket_factory_ptr->SimulateReceive(
2938 kMdnsResponseSrvUnrestrictedResult,
2939 sizeof(kMdnsResponseSrvUnrestrictedResult));
2940
2941 EXPECT_THAT(response.result_error(), IsOk());
2942 EXPECT_FALSE(response.request()->GetAddressResults());
2943 EXPECT_FALSE(response.request()->GetTextResults());
2944 EXPECT_FALSE(response.request()->GetEsniResults());
2945 EXPECT_THAT(response.request()->GetHostnameResults(),
2946 testing::Optional(
2947 testing::ElementsAre(HostPortPair("foo bar.local", 8265))));
2948 }
2949
2950 // Test multicast DNS handling of NSEC responses (used for explicit negative
2951 // response).
TEST_F(HostResolverManagerTest,Mdns_Nsec)2952 TEST_F(HostResolverManagerTest, Mdns_Nsec) {
2953 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2954 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2955 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2956 // 2 socket creations for every transaction.
2957 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
2958
2959 HostResolver::ResolveHostParameters parameters;
2960 parameters.dns_query_type = DnsQueryType::AAAA;
2961 parameters.source = HostResolverSource::MULTICAST_DNS;
2962
2963 ResolveHostResponseHelper response(resolver_->CreateRequest(
2964 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
2965 NetLogWithSource(), parameters, resolve_context_.get(),
2966 resolve_context_->host_cache()));
2967
2968 socket_factory_ptr->SimulateReceive(kMdnsResponseNsec,
2969 sizeof(kMdnsResponseNsec));
2970
2971 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
2972 EXPECT_FALSE(response.request()->GetAddressResults());
2973 }
2974
TEST_F(HostResolverManagerTest,Mdns_NoResponse)2975 TEST_F(HostResolverManagerTest, Mdns_NoResponse) {
2976 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
2977 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
2978 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
2979 // 2 socket creations for every transaction.
2980 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(4);
2981
2982 // Add a little bit of extra fudge to the delay to allow reasonable
2983 // flexibility for time > vs >= etc. We don't need to fail the test if we
2984 // timeout at t=6001 instead of t=6000.
2985 base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1);
2986
2987 // Override the current thread task runner, so we can simulate the passage of
2988 // time to trigger the timeout.
2989 auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
2990 base::ScopedClosureRunner task_runner_override_scoped_cleanup =
2991 base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
2992
2993 HostResolver::ResolveHostParameters parameters;
2994 parameters.source = HostResolverSource::MULTICAST_DNS;
2995
2996 ResolveHostResponseHelper response(resolver_->CreateRequest(
2997 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
2998 NetLogWithSource(), parameters, resolve_context_.get(),
2999 resolve_context_->host_cache()));
3000
3001 ASSERT_TRUE(test_task_runner->HasPendingTask());
3002 test_task_runner->FastForwardBy(MDnsTransaction::kTransactionTimeout +
3003 kSleepFudgeFactor);
3004
3005 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
3006 EXPECT_FALSE(response.request()->GetAddressResults());
3007 EXPECT_FALSE(response.request()->GetTextResults());
3008 EXPECT_FALSE(response.request()->GetHostnameResults());
3009 EXPECT_FALSE(response.request()->GetEsniResults());
3010
3011 test_task_runner->FastForwardUntilNoTasksRemain();
3012 }
3013
TEST_F(HostResolverManagerTest,Mdns_WrongType)3014 TEST_F(HostResolverManagerTest, Mdns_WrongType) {
3015 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3016 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3017 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3018 // 2 socket creations for every transaction.
3019 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
3020
3021 // Add a little bit of extra fudge to the delay to allow reasonable
3022 // flexibility for time > vs >= etc. We don't need to fail the test if we
3023 // timeout at t=6001 instead of t=6000.
3024 base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1);
3025
3026 // Override the current thread task runner, so we can simulate the passage of
3027 // time to trigger the timeout.
3028 auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
3029 base::ScopedClosureRunner task_runner_override_scoped_cleanup =
3030 base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
3031
3032 HostResolver::ResolveHostParameters parameters;
3033 parameters.dns_query_type = DnsQueryType::A;
3034 parameters.source = HostResolverSource::MULTICAST_DNS;
3035
3036 ResolveHostResponseHelper response(resolver_->CreateRequest(
3037 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
3038 NetLogWithSource(), parameters, resolve_context_.get(),
3039 resolve_context_->host_cache()));
3040
3041 // Not the requested type. Should be ignored.
3042 socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
3043 sizeof(kMdnsResponseTxt));
3044
3045 ASSERT_TRUE(test_task_runner->HasPendingTask());
3046 test_task_runner->FastForwardBy(MDnsTransaction::kTransactionTimeout +
3047 kSleepFudgeFactor);
3048
3049 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
3050 EXPECT_FALSE(response.request()->GetAddressResults());
3051 EXPECT_FALSE(response.request()->GetTextResults());
3052 EXPECT_FALSE(response.request()->GetHostnameResults());
3053 EXPECT_FALSE(response.request()->GetEsniResults());
3054
3055 test_task_runner->FastForwardUntilNoTasksRemain();
3056 }
3057
3058 // Test for a request for both A and AAAA results where results only exist for
3059 // one type.
TEST_F(HostResolverManagerTest,Mdns_PartialResults)3060 TEST_F(HostResolverManagerTest, Mdns_PartialResults) {
3061 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3062 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3063 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3064 // 2 socket creations for every transaction.
3065 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(4);
3066
3067 // Add a little bit of extra fudge to the delay to allow reasonable
3068 // flexibility for time > vs >= etc. We don't need to fail the test if we
3069 // timeout at t=6001 instead of t=6000.
3070 base::TimeDelta kSleepFudgeFactor = base::TimeDelta::FromMilliseconds(1);
3071
3072 // Override the current thread task runner, so we can simulate the passage of
3073 // time to trigger the timeout.
3074 auto test_task_runner = base::MakeRefCounted<base::TestMockTimeTaskRunner>();
3075 base::ScopedClosureRunner task_runner_override_scoped_cleanup =
3076 base::ThreadTaskRunnerHandle::OverrideForTesting(test_task_runner);
3077
3078 HostResolver::ResolveHostParameters parameters;
3079 parameters.source = HostResolverSource::MULTICAST_DNS;
3080
3081 ResolveHostResponseHelper response(resolver_->CreateRequest(
3082 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
3083 NetLogWithSource(), parameters, resolve_context_.get(),
3084 resolve_context_->host_cache()));
3085
3086 ASSERT_TRUE(test_task_runner->HasPendingTask());
3087
3088 socket_factory_ptr->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
3089 test_task_runner->FastForwardBy(MDnsTransaction::kTransactionTimeout +
3090 kSleepFudgeFactor);
3091
3092 EXPECT_THAT(response.result_error(), IsOk());
3093 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
3094 testing::ElementsAre(CreateExpected("1.2.3.4", 80)));
3095
3096 test_task_runner->FastForwardUntilNoTasksRemain();
3097 }
3098
TEST_F(HostResolverManagerTest,Mdns_Cancel)3099 TEST_F(HostResolverManagerTest, Mdns_Cancel) {
3100 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3101 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3102 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3103 // 2 socket creations for every transaction.
3104 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(4);
3105
3106 HostResolver::ResolveHostParameters parameters;
3107 parameters.source = HostResolverSource::MULTICAST_DNS;
3108
3109 ResolveHostResponseHelper response(resolver_->CreateRequest(
3110 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
3111 NetLogWithSource(), parameters, resolve_context_.get(),
3112 resolve_context_->host_cache()));
3113
3114 response.CancelRequest();
3115
3116 socket_factory_ptr->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
3117 socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
3118 sizeof(kMdnsResponseAAAA));
3119
3120 base::RunLoop().RunUntilIdle();
3121 EXPECT_FALSE(response.complete());
3122 }
3123
3124 // Test for a two-transaction query where the first fails to start. The second
3125 // should be cancelled.
TEST_F(HostResolverManagerTest,Mdns_PartialFailure)3126 TEST_F(HostResolverManagerTest, Mdns_PartialFailure) {
3127 // Setup a mock MDnsClient where the first transaction will always return
3128 // |false| immediately on Start(). Second transaction may or may not be
3129 // created, but if it is, Start() not expected to be called because the
3130 // overall request should immediately fail.
3131 auto transaction1 = std::make_unique<MockMDnsTransaction>();
3132 EXPECT_CALL(*transaction1, Start()).WillOnce(Return(false));
3133 auto transaction2 = std::make_unique<MockMDnsTransaction>();
3134 EXPECT_CALL(*transaction2, Start()).Times(0);
3135
3136 auto client = std::make_unique<MockMDnsClient>();
3137 EXPECT_CALL(*client, CreateTransaction(_, _, _, _))
3138 .Times(Between(1, 2)) // Second transaction optionally created.
3139 .WillOnce(Return(ByMove(std::move(transaction1))))
3140 .WillOnce(Return(ByMove(std::move(transaction2))));
3141 EXPECT_CALL(*client, IsListening()).WillRepeatedly(Return(true));
3142 resolver_->SetMdnsClientForTesting(std::move(client));
3143
3144 HostResolver::ResolveHostParameters parameters;
3145 parameters.source = HostResolverSource::MULTICAST_DNS;
3146
3147 ResolveHostResponseHelper response(resolver_->CreateRequest(
3148 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
3149 NetLogWithSource(), parameters, resolve_context_.get(),
3150 resolve_context_->host_cache()));
3151
3152 EXPECT_THAT(response.result_error(), IsError(ERR_FAILED));
3153 EXPECT_FALSE(response.request()->GetAddressResults());
3154 }
3155
TEST_F(HostResolverManagerTest,Mdns_ListenFailure)3156 TEST_F(HostResolverManagerTest, Mdns_ListenFailure) {
3157 // Inject an MdnsClient mock that will always fail to start listening.
3158 auto client = std::make_unique<MockMDnsClient>();
3159 EXPECT_CALL(*client, StartListening(_)).WillOnce(Return(ERR_FAILED));
3160 EXPECT_CALL(*client, IsListening()).WillRepeatedly(Return(false));
3161 resolver_->SetMdnsClientForTesting(std::move(client));
3162
3163 HostResolver::ResolveHostParameters parameters;
3164 parameters.source = HostResolverSource::MULTICAST_DNS;
3165
3166 ResolveHostResponseHelper response(resolver_->CreateRequest(
3167 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
3168 NetLogWithSource(), parameters, resolve_context_.get(),
3169 resolve_context_->host_cache()));
3170
3171 EXPECT_THAT(response.result_error(), IsError(ERR_FAILED));
3172 EXPECT_FALSE(response.request()->GetAddressResults());
3173 }
3174
3175 // Implementation of HostResolver::MdnsListenerDelegate that records all
3176 // received results in maps.
3177 class TestMdnsListenerDelegate : public HostResolver::MdnsListener::Delegate {
3178 public:
3179 using UpdateKey =
3180 std::pair<HostResolver::MdnsListener::Delegate::UpdateType, DnsQueryType>;
3181
OnAddressResult(HostResolver::MdnsListener::Delegate::UpdateType update_type,DnsQueryType result_type,IPEndPoint address)3182 void OnAddressResult(
3183 HostResolver::MdnsListener::Delegate::UpdateType update_type,
3184 DnsQueryType result_type,
3185 IPEndPoint address) override {
3186 address_results_.insert({{update_type, result_type}, address});
3187 }
3188
OnTextResult(HostResolver::MdnsListener::Delegate::UpdateType update_type,DnsQueryType result_type,std::vector<std::string> text_records)3189 void OnTextResult(
3190 HostResolver::MdnsListener::Delegate::UpdateType update_type,
3191 DnsQueryType result_type,
3192 std::vector<std::string> text_records) override {
3193 for (auto& text_record : text_records) {
3194 text_results_.insert(
3195 {{update_type, result_type}, std::move(text_record)});
3196 }
3197 }
3198
OnHostnameResult(HostResolver::MdnsListener::Delegate::UpdateType update_type,DnsQueryType result_type,HostPortPair host)3199 void OnHostnameResult(
3200 HostResolver::MdnsListener::Delegate::UpdateType update_type,
3201 DnsQueryType result_type,
3202 HostPortPair host) override {
3203 hostname_results_.insert({{update_type, result_type}, std::move(host)});
3204 }
3205
OnUnhandledResult(HostResolver::MdnsListener::Delegate::UpdateType update_type,DnsQueryType result_type)3206 void OnUnhandledResult(
3207 HostResolver::MdnsListener::Delegate::UpdateType update_type,
3208 DnsQueryType result_type) override {
3209 unhandled_results_.insert({update_type, result_type});
3210 }
3211
address_results()3212 const std::multimap<UpdateKey, IPEndPoint>& address_results() {
3213 return address_results_;
3214 }
3215
text_results()3216 const std::multimap<UpdateKey, std::string>& text_results() {
3217 return text_results_;
3218 }
3219
hostname_results()3220 const std::multimap<UpdateKey, HostPortPair>& hostname_results() {
3221 return hostname_results_;
3222 }
3223
unhandled_results()3224 const std::multiset<UpdateKey>& unhandled_results() {
3225 return unhandled_results_;
3226 }
3227
3228 template <typename T>
CreateExpectedResult(HostResolver::MdnsListener::Delegate::UpdateType update_type,DnsQueryType query_type,T result)3229 static std::pair<UpdateKey, T> CreateExpectedResult(
3230 HostResolver::MdnsListener::Delegate::UpdateType update_type,
3231 DnsQueryType query_type,
3232 T result) {
3233 return std::make_pair(std::make_pair(update_type, query_type), result);
3234 }
3235
3236 private:
3237 std::multimap<UpdateKey, IPEndPoint> address_results_;
3238 std::multimap<UpdateKey, std::string> text_results_;
3239 std::multimap<UpdateKey, HostPortPair> hostname_results_;
3240 std::multiset<UpdateKey> unhandled_results_;
3241 };
3242
TEST_F(HostResolverManagerTest,MdnsListener)3243 TEST_F(HostResolverManagerTest, MdnsListener) {
3244 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3245 base::SimpleTestClock clock;
3246 clock.SetNow(base::Time::Now());
3247 auto cache_cleanup_timer = std::make_unique<base::MockOneShotTimer>();
3248 auto* cache_cleanup_timer_ptr = cache_cleanup_timer.get();
3249 auto mdns_client =
3250 std::make_unique<MDnsClientImpl>(&clock, std::move(cache_cleanup_timer));
3251 ASSERT_THAT(mdns_client->StartListening(socket_factory.get()), IsOk());
3252 resolver_->SetMdnsClientForTesting(std::move(mdns_client));
3253
3254 std::unique_ptr<HostResolver::MdnsListener> listener =
3255 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 80),
3256 DnsQueryType::A);
3257
3258 TestMdnsListenerDelegate delegate;
3259 ASSERT_THAT(listener->Start(&delegate), IsOk());
3260 ASSERT_THAT(delegate.address_results(), testing::IsEmpty());
3261
3262 socket_factory->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
3263 socket_factory->SimulateReceive(kMdnsResponseA2, sizeof(kMdnsResponseA2));
3264 socket_factory->SimulateReceive(kMdnsResponseA2Goodbye,
3265 sizeof(kMdnsResponseA2Goodbye));
3266
3267 // Per RFC6762 section 10.1, removals take effect 1 second after receiving the
3268 // goodbye message.
3269 clock.Advance(base::TimeDelta::FromSeconds(1));
3270 cache_cleanup_timer_ptr->Fire();
3271
3272 // Expect 1 record adding "1.2.3.4", another changing to "5.6.7.8", and a
3273 // final removing "5.6.7.8".
3274 EXPECT_THAT(delegate.address_results(),
3275 testing::ElementsAre(
3276 TestMdnsListenerDelegate::CreateExpectedResult(
3277 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3278 DnsQueryType::A, CreateExpected("1.2.3.4", 80)),
3279 TestMdnsListenerDelegate::CreateExpectedResult(
3280 HostResolver::MdnsListener::Delegate::UpdateType::CHANGED,
3281 DnsQueryType::A, CreateExpected("5.6.7.8", 80)),
3282 TestMdnsListenerDelegate::CreateExpectedResult(
3283 HostResolver::MdnsListener::Delegate::UpdateType::REMOVED,
3284 DnsQueryType::A, CreateExpected("5.6.7.8", 80))));
3285
3286 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3287 EXPECT_THAT(delegate.hostname_results(), testing::IsEmpty());
3288 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3289 }
3290
TEST_F(HostResolverManagerTest,MdnsListener_StartListenFailure)3291 TEST_F(HostResolverManagerTest, MdnsListener_StartListenFailure) {
3292 // Inject an MdnsClient mock that will always fail to start listening.
3293 auto client = std::make_unique<MockMDnsClient>();
3294 EXPECT_CALL(*client, StartListening(_)).WillOnce(Return(ERR_TIMED_OUT));
3295 EXPECT_CALL(*client, IsListening()).WillRepeatedly(Return(false));
3296 resolver_->SetMdnsClientForTesting(std::move(client));
3297
3298 std::unique_ptr<HostResolver::MdnsListener> listener =
3299 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 80),
3300 DnsQueryType::A);
3301 TestMdnsListenerDelegate delegate;
3302 EXPECT_THAT(listener->Start(&delegate), IsError(ERR_TIMED_OUT));
3303 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3304 }
3305
3306 // Test that removal notifications are sent on natural expiration of MDNS
3307 // records.
TEST_F(HostResolverManagerTest,MdnsListener_Expiration)3308 TEST_F(HostResolverManagerTest, MdnsListener_Expiration) {
3309 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3310 base::SimpleTestClock clock;
3311 clock.SetNow(base::Time::Now());
3312 auto cache_cleanup_timer = std::make_unique<base::MockOneShotTimer>();
3313 auto* cache_cleanup_timer_ptr = cache_cleanup_timer.get();
3314 auto mdns_client =
3315 std::make_unique<MDnsClientImpl>(&clock, std::move(cache_cleanup_timer));
3316 ASSERT_THAT(mdns_client->StartListening(socket_factory.get()), IsOk());
3317 resolver_->SetMdnsClientForTesting(std::move(mdns_client));
3318
3319 std::unique_ptr<HostResolver::MdnsListener> listener =
3320 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 100),
3321 DnsQueryType::A);
3322
3323 TestMdnsListenerDelegate delegate;
3324 ASSERT_THAT(listener->Start(&delegate), IsOk());
3325 ASSERT_THAT(delegate.address_results(), testing::IsEmpty());
3326
3327 socket_factory->SimulateReceive(kMdnsResponseA, sizeof(kMdnsResponseA));
3328
3329 EXPECT_THAT(
3330 delegate.address_results(),
3331 testing::ElementsAre(TestMdnsListenerDelegate::CreateExpectedResult(
3332 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3333 DnsQueryType::A, CreateExpected("1.2.3.4", 100))));
3334
3335 clock.Advance(base::TimeDelta::FromSeconds(16));
3336 cache_cleanup_timer_ptr->Fire();
3337
3338 EXPECT_THAT(delegate.address_results(),
3339 testing::ElementsAre(
3340 TestMdnsListenerDelegate::CreateExpectedResult(
3341 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3342 DnsQueryType::A, CreateExpected("1.2.3.4", 100)),
3343 TestMdnsListenerDelegate::CreateExpectedResult(
3344 HostResolver::MdnsListener::Delegate::UpdateType::REMOVED,
3345 DnsQueryType::A, CreateExpected("1.2.3.4", 100))));
3346
3347 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3348 EXPECT_THAT(delegate.hostname_results(), testing::IsEmpty());
3349 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3350 }
3351
TEST_F(HostResolverManagerTest,MdnsListener_Txt)3352 TEST_F(HostResolverManagerTest, MdnsListener_Txt) {
3353 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3354 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3355 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3356
3357 std::unique_ptr<HostResolver::MdnsListener> listener =
3358 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 12),
3359 DnsQueryType::TXT);
3360
3361 TestMdnsListenerDelegate delegate;
3362 ASSERT_THAT(listener->Start(&delegate), IsOk());
3363 ASSERT_THAT(delegate.text_results(), testing::IsEmpty());
3364
3365 socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
3366 sizeof(kMdnsResponseTxt));
3367
3368 EXPECT_THAT(delegate.text_results(),
3369 testing::ElementsAre(
3370 TestMdnsListenerDelegate::CreateExpectedResult(
3371 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3372 DnsQueryType::TXT, "foo"),
3373 TestMdnsListenerDelegate::CreateExpectedResult(
3374 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3375 DnsQueryType::TXT, "bar")));
3376
3377 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3378 EXPECT_THAT(delegate.hostname_results(), testing::IsEmpty());
3379 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3380 }
3381
TEST_F(HostResolverManagerTest,MdnsListener_Ptr)3382 TEST_F(HostResolverManagerTest, MdnsListener_Ptr) {
3383 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3384 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3385 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3386
3387 std::unique_ptr<HostResolver::MdnsListener> listener =
3388 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 13),
3389 DnsQueryType::PTR);
3390
3391 TestMdnsListenerDelegate delegate;
3392 ASSERT_THAT(listener->Start(&delegate), IsOk());
3393 ASSERT_THAT(delegate.text_results(), testing::IsEmpty());
3394
3395 socket_factory_ptr->SimulateReceive(kMdnsResponsePtr,
3396 sizeof(kMdnsResponsePtr));
3397
3398 EXPECT_THAT(
3399 delegate.hostname_results(),
3400 testing::ElementsAre(TestMdnsListenerDelegate::CreateExpectedResult(
3401 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3402 DnsQueryType::PTR, HostPortPair("foo.com", 13))));
3403
3404 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3405 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3406 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3407 }
3408
TEST_F(HostResolverManagerTest,MdnsListener_Srv)3409 TEST_F(HostResolverManagerTest, MdnsListener_Srv) {
3410 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3411 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3412 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3413
3414 std::unique_ptr<HostResolver::MdnsListener> listener =
3415 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 14),
3416 DnsQueryType::SRV);
3417
3418 TestMdnsListenerDelegate delegate;
3419 ASSERT_THAT(listener->Start(&delegate), IsOk());
3420 ASSERT_THAT(delegate.text_results(), testing::IsEmpty());
3421
3422 socket_factory_ptr->SimulateReceive(kMdnsResponseSrv,
3423 sizeof(kMdnsResponseSrv));
3424
3425 EXPECT_THAT(
3426 delegate.hostname_results(),
3427 testing::ElementsAre(TestMdnsListenerDelegate::CreateExpectedResult(
3428 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3429 DnsQueryType::SRV, HostPortPair("foo.com", 8265))));
3430
3431 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3432 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3433 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3434 }
3435
3436 // Ensure query types we are not listening for do not affect MdnsListener.
TEST_F(HostResolverManagerTest,MdnsListener_NonListeningTypes)3437 TEST_F(HostResolverManagerTest, MdnsListener_NonListeningTypes) {
3438 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3439 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3440 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3441
3442 std::unique_ptr<HostResolver::MdnsListener> listener =
3443 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 41),
3444 DnsQueryType::A);
3445
3446 TestMdnsListenerDelegate delegate;
3447 ASSERT_THAT(listener->Start(&delegate), IsOk());
3448
3449 socket_factory_ptr->SimulateReceive(kMdnsResponseAAAA,
3450 sizeof(kMdnsResponseAAAA));
3451
3452 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3453 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3454 EXPECT_THAT(delegate.hostname_results(), testing::IsEmpty());
3455 EXPECT_THAT(delegate.unhandled_results(), testing::IsEmpty());
3456 }
3457
TEST_F(HostResolverManagerTest,MdnsListener_RootDomain)3458 TEST_F(HostResolverManagerTest, MdnsListener_RootDomain) {
3459 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
3460 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
3461 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
3462
3463 std::unique_ptr<HostResolver::MdnsListener> listener =
3464 resolver_->CreateMdnsListener(HostPortPair("myhello.local", 5),
3465 DnsQueryType::PTR);
3466
3467 TestMdnsListenerDelegate delegate;
3468 ASSERT_THAT(listener->Start(&delegate), IsOk());
3469
3470 socket_factory_ptr->SimulateReceive(kMdnsResponsePtrRoot,
3471 sizeof(kMdnsResponsePtrRoot));
3472
3473 EXPECT_THAT(delegate.unhandled_results(),
3474 testing::ElementsAre(std::make_pair(
3475 HostResolver::MdnsListener::Delegate::UpdateType::ADDED,
3476 DnsQueryType::PTR)));
3477
3478 EXPECT_THAT(delegate.address_results(), testing::IsEmpty());
3479 EXPECT_THAT(delegate.text_results(), testing::IsEmpty());
3480 EXPECT_THAT(delegate.hostname_results(), testing::IsEmpty());
3481 }
3482 #endif // BUILDFLAG(ENABLE_MDNS)
3483
CreateValidDnsConfig()3484 DnsConfig CreateValidDnsConfig() {
3485 IPAddress dns_ip(192, 168, 1, 0);
3486 DnsConfig config;
3487 config.nameservers.push_back(IPEndPoint(dns_ip, dns_protocol::kDefaultPort));
3488 config.dns_over_https_servers.push_back({DnsOverHttpsServerConfig(
3489 "https://dns.example.com/", true /* use_post */)});
3490 config.secure_dns_mode = DnsConfig::SecureDnsMode::OFF;
3491 EXPECT_TRUE(config.IsValid());
3492 return config;
3493 }
3494
CreateUpgradableDnsConfig()3495 DnsConfig CreateUpgradableDnsConfig() {
3496 DnsConfig config;
3497 config.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
3498 config.allow_dns_over_https_upgrade = true;
3499 // Cloudflare upgradeable IPs
3500 IPAddress dns_ip0(1, 0, 0, 1);
3501 IPAddress dns_ip1;
3502 EXPECT_TRUE(dns_ip1.AssignFromIPLiteral("2606:4700:4700::1111"));
3503 // SafeBrowsing family filter upgradeable IP
3504 IPAddress dns_ip2;
3505 EXPECT_TRUE(dns_ip2.AssignFromIPLiteral("2a0d:2a00:2::"));
3506 // SafeBrowsing security filter upgradeable IP
3507 IPAddress dns_ip3(185, 228, 169, 9);
3508 // Non-upgradeable IP
3509 IPAddress dns_ip4(1, 2, 3, 4);
3510
3511 config.nameservers.push_back(IPEndPoint(dns_ip0, dns_protocol::kDefaultPort));
3512 config.nameservers.push_back(IPEndPoint(dns_ip1, dns_protocol::kDefaultPort));
3513 config.nameservers.push_back(IPEndPoint(dns_ip2, 54));
3514 config.nameservers.push_back(IPEndPoint(dns_ip3, dns_protocol::kDefaultPort));
3515 config.nameservers.push_back(IPEndPoint(dns_ip4, dns_protocol::kDefaultPort));
3516 EXPECT_TRUE(config.IsValid());
3517 return config;
3518 }
3519
3520 // Check that entries are written to the cache with the right NIK.
TEST_F(HostResolverManagerTest,NetworkIsolationKeyWriteToHostCache)3521 TEST_F(HostResolverManagerTest, NetworkIsolationKeyWriteToHostCache) {
3522 const url::Origin kOrigin1 =
3523 url::Origin::Create(GURL("https://origin1.test/"));
3524 const url::Origin kOrigin2 =
3525 url::Origin::Create(GURL("https://origin2.test/"));
3526 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
3527 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
3528
3529 const char kFirstDnsResult[] = "192.168.1.42";
3530 const char kSecondDnsResult[] = "192.168.1.43";
3531
3532 for (bool split_cache_by_network_isolation_key : {false, true}) {
3533 base::test::ScopedFeatureList feature_list;
3534 if (split_cache_by_network_isolation_key) {
3535 feature_list.InitAndEnableFeature(
3536 features::kSplitHostCacheByNetworkIsolationKey);
3537 } else {
3538 feature_list.InitAndDisableFeature(
3539 features::kSplitHostCacheByNetworkIsolationKey);
3540 }
3541 proc_->AddRuleForAllFamilies("just.testing", kFirstDnsResult);
3542 proc_->SignalMultiple(1u);
3543
3544 // Resolve a host using kNetworkIsolationKey1.
3545 ResolveHostResponseHelper response1(resolver_->CreateRequest(
3546 HostPortPair("just.testing", 80), kNetworkIsolationKey1,
3547 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3548 resolve_context_->host_cache()));
3549 EXPECT_THAT(response1.result_error(), IsOk());
3550 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
3551 testing::ElementsAre(CreateExpected(kFirstDnsResult, 80)));
3552 EXPECT_FALSE(response1.request()->GetStaleInfo());
3553 EXPECT_EQ(1u, proc_->GetCaptureList().size());
3554
3555 // If the host cache is being split by NetworkIsolationKeys, there should be
3556 // an entry in the HostCache with kNetworkIsolationKey1. Otherwise, there
3557 // should be an entry with the empy NIK.
3558 if (split_cache_by_network_isolation_key) {
3559 EXPECT_TRUE(GetCacheHit(
3560 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3561 0 /* host_resolver_flags */, HostResolverSource::ANY,
3562 kNetworkIsolationKey1)));
3563
3564 EXPECT_FALSE(GetCacheHit(
3565 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3566 0 /* host_resolver_flags */, HostResolverSource::ANY,
3567 NetworkIsolationKey())));
3568 } else {
3569 EXPECT_FALSE(GetCacheHit(
3570 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3571 0 /* host_resolver_flags */, HostResolverSource::ANY,
3572 kNetworkIsolationKey1)));
3573
3574 EXPECT_TRUE(GetCacheHit(
3575 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3576 0 /* host_resolver_flags */, HostResolverSource::ANY,
3577 NetworkIsolationKey())));
3578 }
3579
3580 // There should be no entry using kNetworkIsolationKey2 in either case.
3581 EXPECT_FALSE(GetCacheHit(HostCache::Key(
3582 "just.testing", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
3583 HostResolverSource::ANY, kNetworkIsolationKey2)));
3584
3585 // A request using kNetworkIsolationKey2 should only be served out of the
3586 // cache of the cache if |split_cache_by_network_isolation_key| is false. If
3587 // it's not served over the network, it is provided a different result.
3588 if (split_cache_by_network_isolation_key) {
3589 proc_->AddRuleForAllFamilies("just.testing", kSecondDnsResult);
3590 proc_->SignalMultiple(1u);
3591 }
3592 ResolveHostResponseHelper response2(resolver_->CreateRequest(
3593 HostPortPair("just.testing", 80), kNetworkIsolationKey2,
3594 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3595 resolve_context_->host_cache()));
3596 EXPECT_THAT(response2.result_error(), IsOk());
3597 if (split_cache_by_network_isolation_key) {
3598 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
3599 testing::ElementsAre(CreateExpected(kSecondDnsResult, 80)));
3600 EXPECT_FALSE(response2.request()->GetStaleInfo());
3601 EXPECT_EQ(2u, proc_->GetCaptureList().size());
3602 EXPECT_TRUE(GetCacheHit(
3603 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3604 0 /* host_resolver_flags */, HostResolverSource::ANY,
3605 kNetworkIsolationKey2)));
3606 } else {
3607 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
3608 testing::ElementsAre(CreateExpected(kFirstDnsResult, 80)));
3609 EXPECT_TRUE(response2.request()->GetStaleInfo());
3610 EXPECT_EQ(1u, proc_->GetCaptureList().size());
3611 EXPECT_FALSE(GetCacheHit(
3612 HostCache::Key("just.testing", DnsQueryType::UNSPECIFIED,
3613 0 /* host_resolver_flags */, HostResolverSource::ANY,
3614 kNetworkIsolationKey2)));
3615 }
3616
3617 resolve_context_->host_cache()->clear();
3618 proc_->ClearCaptureList();
3619 }
3620 }
3621
3622 // Check that entries are read to the cache with the right NIK.
TEST_F(HostResolverManagerTest,NetworkIsolationKeyReadFromHostCache)3623 TEST_F(HostResolverManagerTest, NetworkIsolationKeyReadFromHostCache) {
3624 const url::Origin kOrigin1 =
3625 url::Origin::Create(GURL("https://origin1.test/"));
3626 const url::Origin kOrigin2 =
3627 url::Origin::Create(GURL("https://origin2.test/"));
3628 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
3629 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
3630
3631 struct CacheEntry {
3632 NetworkIsolationKey network_isolation_key;
3633 const char* cached_ip_address;
3634 };
3635
3636 const CacheEntry kCacheEntries[] = {
3637 {NetworkIsolationKey(), "192.168.1.42"},
3638 {kNetworkIsolationKey1, "192.168.1.43"},
3639 {kNetworkIsolationKey2, "192.168.1.44"},
3640 };
3641
3642 // Add entries to cache for the empty NIK, NIK1, and NIK2. Only the
3643 // HostResolverManager obeys features::kSplitHostCacheByNetworkIsolationKey,
3644 // so this is fine to do regardless of the feature value.
3645 for (const auto& cache_entry : kCacheEntries) {
3646 HostCache::Key key("just.testing", DnsQueryType::UNSPECIFIED, 0,
3647 HostResolverSource::ANY,
3648 cache_entry.network_isolation_key);
3649 IPAddress address;
3650 ASSERT_TRUE(address.AssignFromIPLiteral(cache_entry.cached_ip_address));
3651 HostCache::Entry entry =
3652 HostCache::Entry(OK, AddressList::CreateFromIPAddress(address, 80),
3653 HostCache::Entry::SOURCE_UNKNOWN);
3654 resolve_context_->host_cache()->Set(key, entry, base::TimeTicks::Now(),
3655 base::TimeDelta::FromDays(1));
3656 }
3657
3658 for (bool split_cache_by_network_isolation_key : {false, true}) {
3659 base::test::ScopedFeatureList feature_list;
3660 if (split_cache_by_network_isolation_key) {
3661 feature_list.InitAndEnableFeature(
3662 features::kSplitHostCacheByNetworkIsolationKey);
3663 } else {
3664 feature_list.InitAndDisableFeature(
3665 features::kSplitHostCacheByNetworkIsolationKey);
3666 }
3667
3668 // A request that uses kNetworkIsolationKey1 will return cache entry 1 if
3669 // the NetworkIsolationKeys are being used, and cache entry 0 otherwise.
3670 ResolveHostResponseHelper response1(resolver_->CreateRequest(
3671 HostPortPair("just.testing", 80), kNetworkIsolationKey1,
3672 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3673 resolve_context_->host_cache()));
3674 EXPECT_THAT(response1.result_error(), IsOk());
3675 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
3676 testing::ElementsAre(CreateExpected(
3677 kCacheEntries[split_cache_by_network_isolation_key ? 1 : 0]
3678 .cached_ip_address,
3679 80)));
3680 EXPECT_TRUE(response1.request()->GetStaleInfo());
3681
3682 // A request that uses kNetworkIsolationKey2 will return cache entry 2 if
3683 // the NetworkIsolationKeys are being used, and cache entry 0 otherwise.
3684 ResolveHostResponseHelper response2(resolver_->CreateRequest(
3685 HostPortPair("just.testing", 80), kNetworkIsolationKey2,
3686 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3687 resolve_context_->host_cache()));
3688 EXPECT_THAT(response2.result_error(), IsOk());
3689 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
3690 testing::ElementsAre(CreateExpected(
3691 kCacheEntries[split_cache_by_network_isolation_key ? 2 : 0]
3692 .cached_ip_address,
3693 80)));
3694 EXPECT_TRUE(response2.request()->GetStaleInfo());
3695 }
3696 }
3697
3698 // Test that two requests made with different NetworkIsolationKeys are not
3699 // merged if |features::kSplitHostCacheByNetworkIsolationKey| is enabled.
TEST_F(HostResolverManagerTest,NetworkIsolationKeyTwoRequestsAtOnce)3700 TEST_F(HostResolverManagerTest, NetworkIsolationKeyTwoRequestsAtOnce) {
3701 const url::Origin kOrigin1 =
3702 url::Origin::Create(GURL("https://origin1.test/"));
3703 const url::Origin kOrigin2 =
3704 url::Origin::Create(GURL("https://origin2.test/"));
3705 const NetworkIsolationKey kNetworkIsolationKey1(kOrigin1, kOrigin1);
3706 const NetworkIsolationKey kNetworkIsolationKey2(kOrigin2, kOrigin2);
3707
3708 const char kDnsResult[] = "192.168.1.42";
3709
3710 for (bool split_cache_by_network_isolation_key : {false, true}) {
3711 base::test::ScopedFeatureList feature_list;
3712 if (split_cache_by_network_isolation_key) {
3713 feature_list.InitAndEnableFeature(
3714 features::kSplitHostCacheByNetworkIsolationKey);
3715 } else {
3716 feature_list.InitAndDisableFeature(
3717 features::kSplitHostCacheByNetworkIsolationKey);
3718 }
3719 proc_->AddRuleForAllFamilies("just.testing", kDnsResult);
3720
3721 // Start resolving a host using kNetworkIsolationKey1.
3722 ResolveHostResponseHelper response1(resolver_->CreateRequest(
3723 HostPortPair("just.testing", 80), kNetworkIsolationKey1,
3724 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3725 resolve_context_->host_cache()));
3726 EXPECT_FALSE(response1.complete());
3727
3728 // Start resolving the same host using kNetworkIsolationKey2.
3729 ResolveHostResponseHelper response2(resolver_->CreateRequest(
3730 HostPortPair("just.testing", 80), kNetworkIsolationKey2,
3731 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3732 resolve_context_->host_cache()));
3733 EXPECT_FALSE(response2.complete());
3734
3735 // Wait for and complete the expected number of over-the-wire DNS
3736 // resolutions.
3737 if (split_cache_by_network_isolation_key) {
3738 proc_->WaitFor(2);
3739 EXPECT_EQ(2u, proc_->GetCaptureList().size());
3740 proc_->SignalMultiple(2u);
3741 } else {
3742 proc_->WaitFor(1);
3743 EXPECT_EQ(1u, proc_->GetCaptureList().size());
3744 proc_->SignalMultiple(1u);
3745 }
3746
3747 // Both requests should have completed successfully, with neither served out
3748 // of the cache.
3749
3750 EXPECT_THAT(response1.result_error(), IsOk());
3751 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
3752 testing::ElementsAre(CreateExpected(kDnsResult, 80)));
3753 EXPECT_FALSE(response1.request()->GetStaleInfo());
3754
3755 EXPECT_THAT(response2.result_error(), IsOk());
3756 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
3757 testing::ElementsAre(CreateExpected(kDnsResult, 80)));
3758 EXPECT_FALSE(response2.request()->GetStaleInfo());
3759
3760 resolve_context_->host_cache()->clear();
3761 proc_->ClearCaptureList();
3762 }
3763 }
3764
3765 // Test that two otherwise-identical requests with different ResolveContexts are
3766 // not merged.
TEST_F(HostResolverManagerTest,ContextsNotMerged)3767 TEST_F(HostResolverManagerTest, ContextsNotMerged) {
3768 const char kDnsResult[] = "192.168.1.42";
3769
3770 proc_->AddRuleForAllFamilies("just.testing", kDnsResult);
3771
3772 // Start resolving a host using |resolve_context_|.
3773 ResolveHostResponseHelper response1(resolver_->CreateRequest(
3774 HostPortPair("just.testing", 80), NetworkIsolationKey(),
3775 NetLogWithSource(), base::nullopt, resolve_context_.get(),
3776 resolve_context_->host_cache()));
3777 EXPECT_FALSE(response1.complete());
3778
3779 // Start resolving the same host using another ResolveContext and cache.
3780 ResolveContext resolve_context2(resolve_context_->url_request_context(),
3781 true /* enable_caching */);
3782 resolver_->RegisterResolveContext(&resolve_context2);
3783 ResolveHostResponseHelper response2(resolver_->CreateRequest(
3784 HostPortPair("just.testing", 80), NetworkIsolationKey(),
3785 NetLogWithSource(), base::nullopt, &resolve_context2,
3786 resolve_context2.host_cache()));
3787 EXPECT_FALSE(response2.complete());
3788
3789 EXPECT_EQ(2u, resolver_->num_jobs_for_testing());
3790
3791 // Wait for and complete the 2 over-the-wire DNS resolutions.
3792 proc_->WaitFor(2);
3793 EXPECT_EQ(2u, proc_->GetCaptureList().size());
3794 proc_->SignalMultiple(2u);
3795
3796 // Both requests should have completed successfully, with neither served out
3797 // of the cache.
3798
3799 EXPECT_THAT(response1.result_error(), IsOk());
3800 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
3801 testing::ElementsAre(CreateExpected(kDnsResult, 80)));
3802 EXPECT_FALSE(response1.request()->GetStaleInfo());
3803
3804 EXPECT_THAT(response2.result_error(), IsOk());
3805 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
3806 testing::ElementsAre(CreateExpected(kDnsResult, 80)));
3807 EXPECT_FALSE(response2.request()->GetStaleInfo());
3808
3809 EXPECT_EQ(1u, resolve_context_->host_cache()->size());
3810 EXPECT_EQ(1u, resolve_context2.host_cache()->size());
3811
3812 resolver_->DeregisterResolveContext(&resolve_context2);
3813 }
3814
3815 // Specialized fixture for tests of DnsTask.
3816 class HostResolverManagerDnsTest : public HostResolverManagerTest {
3817 public:
HostResolverManagerDnsTest(base::test::TaskEnvironment::TimeSource time_source=base::test::TaskEnvironment::TimeSource::SYSTEM_TIME)3818 explicit HostResolverManagerDnsTest(
3819 base::test::TaskEnvironment::TimeSource time_source =
3820 base::test::TaskEnvironment::TimeSource::SYSTEM_TIME)
3821 : HostResolverManagerTest(time_source),
3822 notifier_task_runner_(
3823 base::MakeRefCounted<base::TestMockTimeTaskRunner>()),
3824 dns_client_(nullptr) {
3825 auto config_service = std::make_unique<TestDnsConfigService>();
3826 config_service_ = config_service.get();
3827 notifier_ = std::make_unique<SystemDnsConfigChangeNotifier>(
3828 notifier_task_runner_, std::move(config_service));
3829 }
3830
3831 protected:
TearDown()3832 void TearDown() override {
3833 HostResolverManagerTest::TearDown();
3834 InvalidateDnsConfig();
3835
3836 // Ensure |notifier_| is fully cleaned up before test shutdown.
3837 notifier_.reset();
3838 notifier_task_runner_->RunUntilIdle();
3839 }
3840
3841 // HostResolverManagerTest implementation:
DefaultOptions()3842 HostResolver::ManagerOptions DefaultOptions() override {
3843 HostResolver::ManagerOptions options =
3844 HostResolverManagerTest::DefaultOptions();
3845 options.insecure_dns_client_enabled = true;
3846 return options;
3847 }
3848
CreateResolverWithOptionsAndParams(HostResolver::ManagerOptions options,const ProcTaskParams & params,bool ipv6_reachable)3849 void CreateResolverWithOptionsAndParams(HostResolver::ManagerOptions options,
3850 const ProcTaskParams& params,
3851 bool ipv6_reachable) override {
3852 DestroyResolver();
3853
3854 resolver_ = std::make_unique<TestHostResolverManager>(
3855 options, notifier_.get(), nullptr /* net_log */, ipv6_reachable);
3856 auto dns_client =
3857 std::make_unique<MockDnsClient>(DnsConfig(), CreateDefaultDnsRules());
3858 dns_client_ = dns_client.get();
3859 resolver_->SetDnsClientForTesting(std::move(dns_client));
3860 resolver_->SetInsecureDnsClientEnabled(options.insecure_dns_client_enabled);
3861 resolver_->set_proc_params_for_test(params);
3862
3863 resolver_->RegisterResolveContext(resolve_context_.get());
3864 }
3865
3866 // Call after CreateResolver() to update the resolver with a new MockDnsClient
3867 // using |config| and |rules|.
UseMockDnsClient(const DnsConfig & config,MockDnsClientRuleList rules)3868 void UseMockDnsClient(const DnsConfig& config, MockDnsClientRuleList rules) {
3869 // HostResolver expects DnsConfig to get set after setting DnsClient, so
3870 // create first with an empty config and then update the config.
3871 auto dns_client =
3872 std::make_unique<MockDnsClient>(DnsConfig(), std::move(rules));
3873 dns_client_ = dns_client.get();
3874 resolver_->SetDnsClientForTesting(std::move(dns_client));
3875 resolver_->SetInsecureDnsClientEnabled(true);
3876 if (!config.Equals(DnsConfig()))
3877 ChangeDnsConfig(config);
3878 }
3879
CreateDefaultDnsRules()3880 static MockDnsClientRuleList CreateDefaultDnsRules() {
3881 MockDnsClientRuleList rules;
3882
3883 AddDnsRule(&rules, "nodomain", dns_protocol::kTypeA,
3884 MockDnsClientRule::NODOMAIN, false /* delay */);
3885 AddDnsRule(&rules, "nodomain", dns_protocol::kTypeAAAA,
3886 MockDnsClientRule::NODOMAIN, false /* delay */);
3887 AddDnsRule(&rules, "nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL,
3888 false /* delay */);
3889 AddDnsRule(&rules, "nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL,
3890 false /* delay */);
3891 AddDnsRule(&rules, "ok", dns_protocol::kTypeA, MockDnsClientRule::OK,
3892 false /* delay */);
3893 AddDnsRule(&rules, "ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
3894 false /* delay */);
3895 AddDnsRule(&rules, "4ok", dns_protocol::kTypeA, MockDnsClientRule::OK,
3896 false /* delay */);
3897 AddDnsRule(&rules, "4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
3898 false /* delay */);
3899 AddDnsRule(&rules, "6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY,
3900 false /* delay */);
3901 AddDnsRule(&rules, "6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK,
3902 false /* delay */);
3903 AddDnsRule(&rules, "4nx", dns_protocol::kTypeA, MockDnsClientRule::OK,
3904 false /* delay */);
3905 AddDnsRule(&rules, "4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL,
3906 false /* delay */);
3907 AddDnsRule(&rules, "empty", dns_protocol::kTypeA, MockDnsClientRule::EMPTY,
3908 false /* delay */);
3909 AddDnsRule(&rules, "empty", dns_protocol::kTypeAAAA,
3910 MockDnsClientRule::EMPTY, false /* delay */);
3911
3912 AddDnsRule(&rules, "slow_nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL,
3913 true /* delay */);
3914 AddDnsRule(&rules, "slow_nx", dns_protocol::kTypeAAAA,
3915 MockDnsClientRule::FAIL, true /* delay */);
3916
3917 AddDnsRule(&rules, "4slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK,
3918 true /* delay */);
3919 AddDnsRule(&rules, "4slow_ok", dns_protocol::kTypeAAAA,
3920 MockDnsClientRule::OK, false /* delay */);
3921 AddDnsRule(&rules, "6slow_ok", dns_protocol::kTypeA, MockDnsClientRule::OK,
3922 false /* delay */);
3923 AddDnsRule(&rules, "6slow_ok", dns_protocol::kTypeAAAA,
3924 MockDnsClientRule::OK, true /* delay */);
3925 AddDnsRule(&rules, "4slow_4ok", dns_protocol::kTypeA, MockDnsClientRule::OK,
3926 true /* delay */);
3927 AddDnsRule(&rules, "4slow_4ok", dns_protocol::kTypeAAAA,
3928 MockDnsClientRule::EMPTY, false /* delay */);
3929 AddDnsRule(&rules, "4slow_4timeout", dns_protocol::kTypeA,
3930 MockDnsClientRule::TIMEOUT, true /* delay */);
3931 AddDnsRule(&rules, "4slow_4timeout", dns_protocol::kTypeAAAA,
3932 MockDnsClientRule::OK, false /* delay */);
3933 AddDnsRule(&rules, "4slow_6timeout", dns_protocol::kTypeA,
3934 MockDnsClientRule::OK, true /* delay */);
3935 AddDnsRule(&rules, "4slow_6timeout", dns_protocol::kTypeAAAA,
3936 MockDnsClientRule::TIMEOUT, false /* delay */);
3937
3938 AddDnsRule(&rules, "4collision", dns_protocol::kTypeA,
3939 IPAddress(127, 0, 53, 53), false /* delay */);
3940 AddDnsRule(&rules, "4collision", dns_protocol::kTypeAAAA,
3941 MockDnsClientRule::EMPTY, false /* delay */);
3942 AddDnsRule(&rules, "6collision", dns_protocol::kTypeA,
3943 MockDnsClientRule::EMPTY, false /* delay */);
3944 // This isn't the expected IP for collisions (but looks close to it).
3945 AddDnsRule(&rules, "6collision", dns_protocol::kTypeAAAA,
3946 IPAddress(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 53, 53),
3947 false /* delay */);
3948
3949 AddSecureDnsRule(&rules, "automatic_nodomain", dns_protocol::kTypeA,
3950 MockDnsClientRule::NODOMAIN, false /* delay */);
3951 AddSecureDnsRule(&rules, "automatic_nodomain", dns_protocol::kTypeAAAA,
3952 MockDnsClientRule::NODOMAIN, false /* delay */);
3953 AddDnsRule(&rules, "automatic_nodomain", dns_protocol::kTypeA,
3954 MockDnsClientRule::NODOMAIN, false /* delay */);
3955 AddDnsRule(&rules, "automatic_nodomain", dns_protocol::kTypeAAAA,
3956 MockDnsClientRule::NODOMAIN, false /* delay */);
3957 AddSecureDnsRule(&rules, "automatic", dns_protocol::kTypeA,
3958 MockDnsClientRule::OK, false /* delay */);
3959 AddSecureDnsRule(&rules, "automatic", dns_protocol::kTypeAAAA,
3960 MockDnsClientRule::OK, false /* delay */);
3961 AddDnsRule(&rules, "automatic", dns_protocol::kTypeA, MockDnsClientRule::OK,
3962 false /* delay */);
3963 AddDnsRule(&rules, "automatic", dns_protocol::kTypeAAAA,
3964 MockDnsClientRule::OK, false /* delay */);
3965 AddDnsRule(&rules, "insecure_automatic", dns_protocol::kTypeA,
3966 MockDnsClientRule::OK, false /* delay */);
3967 AddDnsRule(&rules, "insecure_automatic", dns_protocol::kTypeAAAA,
3968 MockDnsClientRule::OK, false /* delay */);
3969
3970 AddSecureDnsRule(&rules, "secure", dns_protocol::kTypeA,
3971 MockDnsClientRule::OK, false /* delay */);
3972 AddSecureDnsRule(&rules, "secure", dns_protocol::kTypeAAAA,
3973 MockDnsClientRule::OK, false /* delay */);
3974
3975 return rules;
3976 }
3977
3978 // Adds a rule to |rules|.
AddDnsRule(MockDnsClientRuleList * rules,const std::string & prefix,uint16_t qtype,MockDnsClientRule::ResultType result_type,bool delay)3979 static void AddDnsRule(MockDnsClientRuleList* rules,
3980 const std::string& prefix,
3981 uint16_t qtype,
3982 MockDnsClientRule::ResultType result_type,
3983 bool delay) {
3984 rules->emplace_back(prefix, qtype, false /* secure */,
3985 MockDnsClientRule::Result(result_type), delay);
3986 }
3987
AddDnsRule(MockDnsClientRuleList * rules,const std::string & prefix,uint16_t qtype,const IPAddress & result_ip,bool delay)3988 static void AddDnsRule(MockDnsClientRuleList* rules,
3989 const std::string& prefix,
3990 uint16_t qtype,
3991 const IPAddress& result_ip,
3992 bool delay) {
3993 rules->emplace_back(
3994 prefix, qtype, false /* secure */,
3995 MockDnsClientRule::Result(BuildTestDnsResponse(prefix, result_ip)),
3996 delay);
3997 }
3998
AddDnsRule(MockDnsClientRuleList * rules,const std::string & prefix,uint16_t qtype,IPAddress result_ip,std::string cannonname,bool delay)3999 static void AddDnsRule(MockDnsClientRuleList* rules,
4000 const std::string& prefix,
4001 uint16_t qtype,
4002 IPAddress result_ip,
4003 std::string cannonname,
4004 bool delay) {
4005 rules->emplace_back(prefix, qtype, false /* secure */,
4006 MockDnsClientRule::Result(BuildTestDnsResponseWithCname(
4007 prefix, result_ip, std::move(cannonname))),
4008 delay);
4009 }
4010
AddSecureDnsRule(MockDnsClientRuleList * rules,const std::string & prefix,uint16_t qtype,MockDnsClientRule::ResultType result_type,bool delay)4011 static void AddSecureDnsRule(MockDnsClientRuleList* rules,
4012 const std::string& prefix,
4013 uint16_t qtype,
4014 MockDnsClientRule::ResultType result_type,
4015 bool delay) {
4016 rules->emplace_back(prefix, qtype, true /* secure */,
4017 MockDnsClientRule::Result(result_type), delay);
4018 }
4019
ChangeDnsConfig(const DnsConfig & config)4020 void ChangeDnsConfig(const DnsConfig& config) {
4021 DCHECK(config.IsValid());
4022
4023 notifier_task_runner_->PostTask(
4024 FROM_HERE,
4025 base::BindOnce(&TestDnsConfigService::OnHostsRead,
4026 base::Unretained(config_service_), config.hosts));
4027 notifier_task_runner_->PostTask(
4028 FROM_HERE, base::BindOnce(&TestDnsConfigService::OnConfigRead,
4029 base::Unretained(config_service_), config));
4030
4031 notifier_task_runner_->RunUntilIdle();
4032 base::RunLoop().RunUntilIdle();
4033 }
4034
InvalidateDnsConfig()4035 void InvalidateDnsConfig() {
4036 notifier_task_runner_->PostTask(
4037 FROM_HERE,
4038 base::BindOnce(&TestDnsConfigService::OnHostsRead,
4039 base::Unretained(config_service_), DnsHosts()));
4040 notifier_task_runner_->PostTask(
4041 FROM_HERE, base::BindOnce(&TestDnsConfigService::InvalidateConfig,
4042 base::Unretained(config_service_)));
4043
4044 notifier_task_runner_->FastForwardBy(
4045 DnsConfigService::kInvalidationTimeout);
4046 base::RunLoop().RunUntilIdle();
4047 }
4048
SetInitialDnsConfig(const DnsConfig & config)4049 void SetInitialDnsConfig(const DnsConfig& config) {
4050 InvalidateDnsConfig();
4051 ChangeDnsConfig(config);
4052 }
4053
4054 scoped_refptr<base::TestMockTimeTaskRunner> notifier_task_runner_;
4055 TestDnsConfigService* config_service_;
4056 std::unique_ptr<SystemDnsConfigChangeNotifier> notifier_;
4057
4058 // Owned by |resolver_|.
4059 MockDnsClient* dns_client_;
4060 };
4061
TEST_F(HostResolverManagerDnsTest,FlushCacheOnDnsConfigChange)4062 TEST_F(HostResolverManagerDnsTest, FlushCacheOnDnsConfigChange) {
4063 proc_->SignalMultiple(2u); // One before the flush, one after.
4064
4065 // Resolve to populate the cache.
4066 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
4067 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
4068 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4069 EXPECT_THAT(initial_response.result_error(), IsOk());
4070 EXPECT_EQ(1u, proc_->GetCaptureList().size());
4071
4072 // Result expected to come from the cache.
4073 ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
4074 HostPortPair("host1", 75), NetworkIsolationKey(), NetLogWithSource(),
4075 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4076 EXPECT_THAT(cached_response.result_error(), IsOk());
4077 EXPECT_EQ(1u, proc_->GetCaptureList().size()); // No expected increase.
4078
4079 // Flush cache by triggering a DNS config change.
4080 ChangeDnsConfig(CreateValidDnsConfig());
4081
4082 // Expect flushed from cache and therefore served from |proc_|.
4083 ResolveHostResponseHelper flushed_response(resolver_->CreateRequest(
4084 HostPortPair("host1", 80), NetworkIsolationKey(), NetLogWithSource(),
4085 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4086 EXPECT_THAT(flushed_response.result_error(), IsOk());
4087 EXPECT_EQ(2u, proc_->GetCaptureList().size()); // Expected increase.
4088 }
4089
TEST_F(HostResolverManagerDnsTest,DisableAndEnableInsecureDnsClient)4090 TEST_F(HostResolverManagerDnsTest, DisableAndEnableInsecureDnsClient) {
4091 // Disable fallback to allow testing how requests are initially handled.
4092 set_allow_fallback_to_proctask(false);
4093
4094 ChangeDnsConfig(CreateValidDnsConfig());
4095 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.2.47");
4096 proc_->SignalMultiple(1u);
4097
4098 resolver_->SetInsecureDnsClientEnabled(false);
4099 ResolveHostResponseHelper response_proc(resolver_->CreateRequest(
4100 HostPortPair("nx_succeed", 1212), NetworkIsolationKey(),
4101 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4102 resolve_context_->host_cache()));
4103 EXPECT_THAT(response_proc.result_error(), IsOk());
4104 EXPECT_THAT(response_proc.request()->GetAddressResults().value().endpoints(),
4105 testing::ElementsAre(CreateExpected("192.168.2.47", 1212)));
4106
4107 resolver_->SetInsecureDnsClientEnabled(true);
4108 ResolveHostResponseHelper response_dns_client(resolver_->CreateRequest(
4109 HostPortPair("ok_fail", 1212), NetworkIsolationKey(), NetLogWithSource(),
4110 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4111 EXPECT_THAT(response_dns_client.result_error(), IsOk());
4112 EXPECT_THAT(
4113 response_dns_client.request()->GetAddressResults().value().endpoints(),
4114 testing::UnorderedElementsAre(CreateExpected("::1", 1212),
4115 CreateExpected("127.0.0.1", 1212)));
4116 }
4117
TEST_F(HostResolverManagerDnsTest,UseProcTaskWhenPrivateDnsActive)4118 TEST_F(HostResolverManagerDnsTest, UseProcTaskWhenPrivateDnsActive) {
4119 // Disable fallback to allow testing how requests are initially handled.
4120 set_allow_fallback_to_proctask(false);
4121 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.2.47");
4122 proc_->SignalMultiple(1u);
4123
4124 DnsConfig config = CreateValidDnsConfig();
4125 config.dns_over_tls_active = true;
4126 ChangeDnsConfig(config);
4127 ResolveHostResponseHelper response_proc(resolver_->CreateRequest(
4128 HostPortPair("nx_succeed", 1212), NetworkIsolationKey(),
4129 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4130 resolve_context_->host_cache()));
4131 EXPECT_THAT(response_proc.result_error(), IsOk());
4132 EXPECT_THAT(response_proc.request()->GetAddressResults().value().endpoints(),
4133 testing::ElementsAre(CreateExpected("192.168.2.47", 1212)));
4134 }
4135
4136 // RFC 6761 localhost names should always resolve to loopback.
TEST_F(HostResolverManagerDnsTest,LocalhostLookup)4137 TEST_F(HostResolverManagerDnsTest, LocalhostLookup) {
4138 // Add a rule resolving localhost names to a non-loopback IP and test
4139 // that they still resolves to loopback.
4140 proc_->AddRuleForAllFamilies("foo.localhost", "192.168.1.42");
4141 proc_->AddRuleForAllFamilies("localhost", "192.168.1.42");
4142 proc_->AddRuleForAllFamilies("localhost.", "192.168.1.42");
4143
4144 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4145 HostPortPair("foo.localhost", 80), NetworkIsolationKey(),
4146 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4147 resolve_context_->host_cache()));
4148 EXPECT_THAT(response0.result_error(), IsOk());
4149 EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
4150 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4151 CreateExpected("::1", 80)));
4152
4153 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4154 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
4155 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4156 EXPECT_THAT(response1.result_error(), IsOk());
4157 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
4158 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4159 CreateExpected("::1", 80)));
4160
4161 ResolveHostResponseHelper response2(resolver_->CreateRequest(
4162 HostPortPair("localhost.", 80), NetworkIsolationKey(), NetLogWithSource(),
4163 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4164 EXPECT_THAT(response2.result_error(), IsOk());
4165 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
4166 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4167 CreateExpected("::1", 80)));
4168 }
4169
4170 // RFC 6761 localhost names should always resolve to loopback, even if a HOSTS
4171 // file is active.
TEST_F(HostResolverManagerDnsTest,LocalhostLookupWithHosts)4172 TEST_F(HostResolverManagerDnsTest, LocalhostLookupWithHosts) {
4173 DnsHosts hosts;
4174 hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] =
4175 IPAddress({192, 168, 1, 1});
4176 hosts[DnsHostsKey("foo.localhost", ADDRESS_FAMILY_IPV4)] =
4177 IPAddress({192, 168, 1, 2});
4178
4179 DnsConfig config = CreateValidDnsConfig();
4180 config.hosts = hosts;
4181 ChangeDnsConfig(config);
4182
4183 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4184 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
4185 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4186 EXPECT_THAT(response0.result_error(), IsOk());
4187 EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
4188 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4189 CreateExpected("::1", 80)));
4190
4191 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4192 HostPortPair("foo.localhost", 80), NetworkIsolationKey(),
4193 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4194 resolve_context_->host_cache()));
4195 EXPECT_THAT(response1.result_error(), IsOk());
4196 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
4197 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4198 CreateExpected("::1", 80)));
4199 }
4200
4201 // Test successful and fallback resolutions in HostResolverManager::DnsTask.
TEST_F(HostResolverManagerDnsTest,DnsTask)4202 TEST_F(HostResolverManagerDnsTest, DnsTask) {
4203 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4204 // All other hostnames will fail in proc_.
4205
4206 // Initially there is no config, so client should not be invoked.
4207 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
4208 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4209 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4210 EXPECT_FALSE(initial_response.complete());
4211
4212 proc_->SignalMultiple(1u);
4213
4214 EXPECT_THAT(initial_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4215
4216 ChangeDnsConfig(CreateValidDnsConfig());
4217
4218 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4219 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4220 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4221 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4222 HostPortPair("nx_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4223 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4224 ResolveHostResponseHelper response2(resolver_->CreateRequest(
4225 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4226 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4227
4228 proc_->SignalMultiple(4u);
4229
4230 // Resolved by MockDnsClient.
4231 EXPECT_THAT(response0.result_error(), IsOk());
4232 EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
4233 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4234 CreateExpected("::1", 80)));
4235
4236 // Fallback to ProcTask.
4237 EXPECT_THAT(response1.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4238 EXPECT_THAT(response2.result_error(), IsOk());
4239 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
4240 testing::ElementsAre(CreateExpected("192.168.1.102", 80)));
4241 }
4242
4243 // Test successful and failing resolutions in HostResolverManager::DnsTask when
4244 // fallback to ProcTask is disabled.
TEST_F(HostResolverManagerDnsTest,NoFallbackToProcTask)4245 TEST_F(HostResolverManagerDnsTest, NoFallbackToProcTask) {
4246 set_allow_fallback_to_proctask(false);
4247
4248 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4249 // All other hostnames will fail in proc_.
4250
4251 // Set empty DnsConfig.
4252 InvalidateDnsConfig();
4253 // Initially there is no config, so client should not be invoked.
4254 ResolveHostResponseHelper initial_response0(resolver_->CreateRequest(
4255 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4256 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4257 ResolveHostResponseHelper initial_response1(resolver_->CreateRequest(
4258 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4259 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4260 proc_->SignalMultiple(2u);
4261
4262 EXPECT_THAT(initial_response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4263 EXPECT_THAT(initial_response1.result_error(), IsOk());
4264 EXPECT_THAT(
4265 initial_response1.request()->GetAddressResults().value().endpoints(),
4266 testing::ElementsAre(CreateExpected("192.168.1.102", 80)));
4267
4268 // Switch to a valid config.
4269 ChangeDnsConfig(CreateValidDnsConfig());
4270 // First request is resolved by MockDnsClient, others should fail due to
4271 // disabled fallback to ProcTask.
4272 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4273 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4274 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4275 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4276 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4277 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4278 proc_->SignalMultiple(6u);
4279
4280 // Resolved by MockDnsClient.
4281 EXPECT_THAT(response0.result_error(), IsOk());
4282 EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
4283 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4284 CreateExpected("::1", 80)));
4285 // Fallback to ProcTask is disabled.
4286 EXPECT_THAT(response1.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4287 }
4288
4289 // Test behavior of OnDnsTaskFailure when Job is aborted.
TEST_F(HostResolverManagerDnsTest,OnDnsTaskFailureAbortedJob)4290 TEST_F(HostResolverManagerDnsTest, OnDnsTaskFailureAbortedJob) {
4291 ChangeDnsConfig(CreateValidDnsConfig());
4292 ResolveHostResponseHelper response(resolver_->CreateRequest(
4293 HostPortPair("nx_abort", 80), NetworkIsolationKey(), NetLogWithSource(),
4294 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4295 // Abort all jobs here.
4296 CreateResolver();
4297 proc_->SignalMultiple(1u);
4298 // Run to completion.
4299 base::RunLoop().RunUntilIdle(); // Notification happens async.
4300 // It shouldn't crash during OnDnsTaskFailure callbacks.
4301 EXPECT_FALSE(response.complete());
4302
4303 // Repeat test with Fallback to ProcTask disabled
4304 set_allow_fallback_to_proctask(false);
4305 ChangeDnsConfig(CreateValidDnsConfig());
4306 ResolveHostResponseHelper no_fallback_response(resolver_->CreateRequest(
4307 HostPortPair("nx_abort", 80), NetworkIsolationKey(), NetLogWithSource(),
4308 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4309 // Abort all jobs here.
4310 CreateResolver();
4311 proc_->SignalMultiple(2u);
4312 // Run to completion.
4313 base::RunLoop().RunUntilIdle(); // Notification happens async.
4314 // It shouldn't crash during OnDnsTaskFailure callbacks.
4315 EXPECT_FALSE(no_fallback_response.complete());
4316 }
4317
4318 // Fallback to proc allowed with ANY source.
TEST_F(HostResolverManagerDnsTest,FallbackBySource_Any)4319 TEST_F(HostResolverManagerDnsTest, FallbackBySource_Any) {
4320 // Ensure fallback is otherwise allowed by resolver settings.
4321 set_allow_fallback_to_proctask(true);
4322
4323 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4324 // All other hostnames will fail in proc_.
4325
4326 ChangeDnsConfig(CreateValidDnsConfig());
4327
4328 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4329 HostPortPair("nx_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4330 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4331 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4332 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4333 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4334 proc_->SignalMultiple(2u);
4335
4336 EXPECT_THAT(response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4337 EXPECT_THAT(response1.result_error(), IsOk());
4338 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
4339 testing::ElementsAre(CreateExpected("192.168.1.102", 80)));
4340 }
4341
4342 // Fallback to proc not allowed with DNS source.
TEST_F(HostResolverManagerDnsTest,FallbackBySource_Dns)4343 TEST_F(HostResolverManagerDnsTest, FallbackBySource_Dns) {
4344 // Ensure fallback is otherwise allowed by resolver settings.
4345 set_allow_fallback_to_proctask(true);
4346
4347 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4348 // All other hostnames will fail in proc_.
4349
4350 ChangeDnsConfig(CreateValidDnsConfig());
4351
4352 HostResolver::ResolveHostParameters parameters;
4353 parameters.source = HostResolverSource::DNS;
4354 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4355 HostPortPair("nx_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4356 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4357 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4358 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4359 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4360 // Nothing should reach |proc_| on success, but let failures through to fail
4361 // instead of hanging.
4362 proc_->SignalMultiple(2u);
4363
4364 EXPECT_THAT(response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4365 EXPECT_THAT(response1.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4366 }
4367
4368 // Fallback to proc on DnsClient change allowed with ANY source.
TEST_F(HostResolverManagerDnsTest,FallbackOnAbortBySource_Any)4369 TEST_F(HostResolverManagerDnsTest, FallbackOnAbortBySource_Any) {
4370 // Ensure fallback is otherwise allowed by resolver settings.
4371 set_allow_fallback_to_proctask(true);
4372
4373 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4374 // All other hostnames will fail in proc_.
4375
4376 ChangeDnsConfig(CreateValidDnsConfig());
4377
4378 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4379 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4380 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4381 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4382 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4383 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4384 proc_->SignalMultiple(2u);
4385
4386 // Simulate the case when the preference or policy has disabled the insecure
4387 // DNS client causing AbortInsecureDnsTasks.
4388 resolver_->SetInsecureDnsClientEnabled(false);
4389
4390 // All requests should fallback to proc resolver.
4391 EXPECT_THAT(response0.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4392 EXPECT_THAT(response1.result_error(), IsOk());
4393 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
4394 testing::ElementsAre(CreateExpected("192.168.1.102", 80)));
4395 }
4396
4397 // Fallback to proc on DnsClient change not allowed with DNS source.
TEST_F(HostResolverManagerDnsTest,FallbackOnAbortBySource_Dns)4398 TEST_F(HostResolverManagerDnsTest, FallbackOnAbortBySource_Dns) {
4399 // Ensure fallback is otherwise allowed by resolver settings.
4400 set_allow_fallback_to_proctask(true);
4401
4402 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102");
4403 // All other hostnames will fail in proc_.
4404
4405 ChangeDnsConfig(CreateValidDnsConfig());
4406
4407 HostResolver::ResolveHostParameters parameters;
4408 parameters.source = HostResolverSource::DNS;
4409 ResolveHostResponseHelper response0(resolver_->CreateRequest(
4410 HostPortPair("ok_fail", 80), NetworkIsolationKey(), NetLogWithSource(),
4411 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4412 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4413 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
4414 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4415 // Nothing should reach |proc_| on success, but let failures through to fail
4416 // instead of hanging.
4417 proc_->SignalMultiple(2u);
4418
4419 // Simulate the case when the preference or policy has disabled the insecure
4420 // DNS client causing AbortInsecureDnsTasks.
4421 resolver_->SetInsecureDnsClientEnabled(false);
4422
4423 // No fallback expected. All requests should fail.
4424 EXPECT_THAT(response0.result_error(), IsError(ERR_NETWORK_CHANGED));
4425 EXPECT_THAT(response1.result_error(), IsError(ERR_NETWORK_CHANGED));
4426 }
4427
4428 // Insecure DnsClient change shouldn't affect secure DnsTasks.
TEST_F(HostResolverManagerDnsTest,DisableInsecureDnsClient_SecureDnsTasksUnaffected)4429 TEST_F(HostResolverManagerDnsTest,
4430 DisableInsecureDnsClient_SecureDnsTasksUnaffected) {
4431 // Ensure fallback is otherwise allowed by resolver settings.
4432 set_allow_fallback_to_proctask(true);
4433
4434 proc_->AddRuleForAllFamilies("automatic", "192.168.1.102");
4435 // All other hostnames will fail in proc_.
4436
4437 ChangeDnsConfig(CreateValidDnsConfig());
4438
4439 HostResolver::ResolveHostParameters secure_parameters;
4440 secure_parameters.secure_dns_mode_override =
4441 DnsConfig::SecureDnsMode::AUTOMATIC;
4442 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
4443 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
4444 secure_parameters, resolve_context_.get(),
4445 resolve_context_->host_cache()));
4446 EXPECT_FALSE(response_secure.complete());
4447
4448 // Simulate the case when the preference or policy has disabled the insecure
4449 // DNS client causing AbortInsecureDnsTasks.
4450 resolver_->SetInsecureDnsClientEnabled(false);
4451
4452 EXPECT_THAT(response_secure.result_error(), IsOk());
4453 EXPECT_THAT(
4454 response_secure.request()->GetAddressResults().value().endpoints(),
4455 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4456 CreateExpected("::1", 80)));
4457 }
4458
TEST_F(HostResolverManagerDnsTest,DnsTaskUnspec)4459 TEST_F(HostResolverManagerDnsTest, DnsTaskUnspec) {
4460 ChangeDnsConfig(CreateValidDnsConfig());
4461
4462 proc_->AddRuleForAllFamilies("4nx", "192.168.1.101");
4463 // All other hostnames will fail in proc_.
4464
4465 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
4466 responses.emplace_back(
4467 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4468 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4469 base::nullopt, resolve_context_.get(),
4470 resolve_context_->host_cache())));
4471 responses.emplace_back(
4472 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4473 HostPortPair("4ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4474 base::nullopt, resolve_context_.get(),
4475 resolve_context_->host_cache())));
4476 responses.emplace_back(
4477 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4478 HostPortPair("6ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4479 base::nullopt, resolve_context_.get(),
4480 resolve_context_->host_cache())));
4481 responses.emplace_back(
4482 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4483 HostPortPair("4nx", 80), NetworkIsolationKey(), NetLogWithSource(),
4484 base::nullopt, resolve_context_.get(),
4485 resolve_context_->host_cache())));
4486
4487 proc_->SignalMultiple(4u);
4488
4489 for (auto& response : responses) {
4490 EXPECT_THAT(response->result_error(), IsOk());
4491 }
4492
4493 EXPECT_THAT(responses[0]->request()->GetAddressResults().value().endpoints(),
4494 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4495 CreateExpected("::1", 80)));
4496 EXPECT_THAT(responses[1]->request()->GetAddressResults().value().endpoints(),
4497 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
4498 EXPECT_THAT(responses[2]->request()->GetAddressResults().value().endpoints(),
4499 testing::ElementsAre(CreateExpected("::1", 80)));
4500 EXPECT_THAT(responses[3]->request()->GetAddressResults().value().endpoints(),
4501 testing::ElementsAre(CreateExpected("192.168.1.101", 80)));
4502 }
4503
TEST_F(HostResolverManagerDnsTest,NameCollisionIcann)4504 TEST_F(HostResolverManagerDnsTest, NameCollisionIcann) {
4505 ChangeDnsConfig(CreateValidDnsConfig());
4506
4507 // When the resolver returns an A record with 127.0.53.53 it should be
4508 // mapped to a special error.
4509 ResolveHostResponseHelper response_ipv4(resolver_->CreateRequest(
4510 HostPortPair("4collision", 80), NetworkIsolationKey(), NetLogWithSource(),
4511 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4512 EXPECT_THAT(response_ipv4.result_error(), IsError(ERR_ICANN_NAME_COLLISION));
4513 EXPECT_FALSE(response_ipv4.request()->GetAddressResults());
4514
4515 // When the resolver returns an AAAA record with ::127.0.53.53 it should
4516 // work just like any other IP. (Despite having the same suffix, it is not
4517 // considered special)
4518 ResolveHostResponseHelper response_ipv6(resolver_->CreateRequest(
4519 HostPortPair("6collision", 80), NetworkIsolationKey(), NetLogWithSource(),
4520 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4521 EXPECT_THAT(response_ipv6.result_error(), IsOk());
4522 EXPECT_THAT(response_ipv6.request()->GetAddressResults().value().endpoints(),
4523 testing::ElementsAre(CreateExpected("::127.0.53.53", 80)));
4524 }
4525
TEST_F(HostResolverManagerDnsTest,ServeFromHosts)4526 TEST_F(HostResolverManagerDnsTest, ServeFromHosts) {
4527 // Initially, use empty HOSTS file.
4528 DnsConfig config = CreateValidDnsConfig();
4529 ChangeDnsConfig(config);
4530
4531 proc_->AddRuleForAllFamilies(std::string(),
4532 std::string()); // Default to failures.
4533 proc_->SignalMultiple(1u); // For the first request which misses.
4534
4535 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
4536 HostPortPair("nx_ipv4", 80), NetworkIsolationKey(), NetLogWithSource(),
4537 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4538 EXPECT_THAT(initial_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4539
4540 IPAddress local_ipv4 = IPAddress::IPv4Localhost();
4541 IPAddress local_ipv6 = IPAddress::IPv6Localhost();
4542
4543 DnsHosts hosts;
4544 hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4;
4545 hosts[DnsHostsKey("nx_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6;
4546 hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV4)] = local_ipv4;
4547 hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV6)] = local_ipv6;
4548
4549 // Update HOSTS file.
4550 config.hosts = hosts;
4551 ChangeDnsConfig(config);
4552
4553 ResolveHostResponseHelper response_ipv4(resolver_->CreateRequest(
4554 HostPortPair("nx_ipv4", 80), NetworkIsolationKey(), NetLogWithSource(),
4555 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4556 EXPECT_THAT(response_ipv4.result_error(), IsOk());
4557 EXPECT_THAT(response_ipv4.request()->GetAddressResults().value().endpoints(),
4558 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
4559
4560 ResolveHostResponseHelper response_ipv6(resolver_->CreateRequest(
4561 HostPortPair("nx_ipv6", 80), NetworkIsolationKey(), NetLogWithSource(),
4562 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4563 EXPECT_THAT(response_ipv6.result_error(), IsOk());
4564 EXPECT_THAT(response_ipv6.request()->GetAddressResults().value().endpoints(),
4565 testing::ElementsAre(CreateExpected("::1", 80)));
4566
4567 ResolveHostResponseHelper response_both(resolver_->CreateRequest(
4568 HostPortPair("nx_both", 80), NetworkIsolationKey(), NetLogWithSource(),
4569 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4570 EXPECT_THAT(response_both.result_error(), IsOk());
4571 EXPECT_THAT(response_both.request()->GetAddressResults().value().endpoints(),
4572 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4573 CreateExpected("::1", 80)));
4574
4575 // Requests with specified DNS query type.
4576 HostResolver::ResolveHostParameters parameters;
4577
4578 parameters.dns_query_type = DnsQueryType::A;
4579 ResolveHostResponseHelper response_specified_ipv4(resolver_->CreateRequest(
4580 HostPortPair("nx_ipv4", 80), NetworkIsolationKey(), NetLogWithSource(),
4581 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4582 EXPECT_THAT(response_specified_ipv4.result_error(), IsOk());
4583 EXPECT_THAT(response_specified_ipv4.request()
4584 ->GetAddressResults()
4585 .value()
4586 .endpoints(),
4587 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
4588
4589 parameters.dns_query_type = DnsQueryType::AAAA;
4590 ResolveHostResponseHelper response_specified_ipv6(resolver_->CreateRequest(
4591 HostPortPair("nx_ipv6", 80), NetworkIsolationKey(), NetLogWithSource(),
4592 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4593 EXPECT_THAT(response_specified_ipv6.result_error(), IsOk());
4594 EXPECT_THAT(response_specified_ipv6.request()
4595 ->GetAddressResults()
4596 .value()
4597 .endpoints(),
4598 testing::ElementsAre(CreateExpected("::1", 80)));
4599
4600 // Request with upper case.
4601 ResolveHostResponseHelper response_upper(resolver_->CreateRequest(
4602 HostPortPair("nx_IPV4", 80), NetworkIsolationKey(), NetLogWithSource(),
4603 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4604 EXPECT_THAT(response_upper.result_error(), IsOk());
4605 EXPECT_THAT(response_upper.request()->GetAddressResults().value().endpoints(),
4606 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
4607 }
4608
TEST_F(HostResolverManagerDnsTest,SkipHostsWithUpcomingProcTask)4609 TEST_F(HostResolverManagerDnsTest, SkipHostsWithUpcomingProcTask) {
4610 // Disable the DnsClient.
4611 resolver_->SetInsecureDnsClientEnabled(false);
4612
4613 proc_->AddRuleForAllFamilies(std::string(),
4614 std::string()); // Default to failures.
4615 proc_->SignalMultiple(1u); // For the first request which misses.
4616
4617 DnsConfig config = CreateValidDnsConfig();
4618 DnsHosts hosts;
4619 hosts[DnsHostsKey("hosts", ADDRESS_FAMILY_IPV4)] = IPAddress::IPv4Localhost();
4620
4621 // Update HOSTS file.
4622 config.hosts = hosts;
4623 ChangeDnsConfig(config);
4624
4625 ResolveHostResponseHelper response(resolver_->CreateRequest(
4626 HostPortPair("hosts", 80), NetworkIsolationKey(), NetLogWithSource(),
4627 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4628 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4629 }
4630
4631 // Test that hosts ending in ".local" or ".local." are resolved using the system
4632 // resolver.
TEST_F(HostResolverManagerDnsTest,BypassDnsTask)4633 TEST_F(HostResolverManagerDnsTest, BypassDnsTask) {
4634 ChangeDnsConfig(CreateValidDnsConfig());
4635
4636 proc_->AddRuleForAllFamilies(std::string(),
4637 std::string()); // Default to failures.
4638
4639 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
4640
4641 responses.emplace_back(
4642 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4643 HostPortPair("ok.local", 80), NetworkIsolationKey(),
4644 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4645 resolve_context_->host_cache())));
4646 responses.emplace_back(
4647 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4648 HostPortPair("ok.local.", 80), NetworkIsolationKey(),
4649 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4650 resolve_context_->host_cache())));
4651 responses.emplace_back(
4652 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4653 HostPortPair("oklocal", 80), NetworkIsolationKey(),
4654 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4655 resolve_context_->host_cache())));
4656 responses.emplace_back(
4657 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4658 HostPortPair("oklocal.", 80), NetworkIsolationKey(),
4659 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4660 resolve_context_->host_cache())));
4661 responses.emplace_back(
4662 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4663 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4664 base::nullopt, resolve_context_.get(),
4665 resolve_context_->host_cache())));
4666
4667 proc_->SignalMultiple(5u);
4668
4669 for (size_t i = 0; i < 2; ++i)
4670 EXPECT_THAT(responses[i]->result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4671
4672 for (size_t i = 2; i < responses.size(); ++i)
4673 EXPECT_THAT(responses[i]->result_error(), IsOk());
4674 }
4675
4676 #if BUILDFLAG(ENABLE_MDNS)
4677 // Test that non-address queries for hosts ending in ".local" are resolved using
4678 // the MDNS resolver.
TEST_F(HostResolverManagerDnsTest,BypassDnsToMdnsWithNonAddress)4679 TEST_F(HostResolverManagerDnsTest, BypassDnsToMdnsWithNonAddress) {
4680 // Ensure DNS task and system (proc) requests will fail.
4681 MockDnsClientRuleList rules;
4682 rules.emplace_back(
4683 "myhello.local", dns_protocol::kTypeTXT, false /* secure */,
4684 MockDnsClientRule::Result(MockDnsClientRule::FAIL), false /* delay */);
4685 CreateResolver();
4686 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
4687 proc_->AddRuleForAllFamilies(std::string(), std::string());
4688
4689 auto socket_factory = std::make_unique<MockMDnsSocketFactory>();
4690 MockMDnsSocketFactory* socket_factory_ptr = socket_factory.get();
4691 resolver_->SetMdnsSocketFactoryForTesting(std::move(socket_factory));
4692 // 2 socket creations for every transaction.
4693 EXPECT_CALL(*socket_factory_ptr, OnSendTo(_)).Times(2);
4694
4695 HostResolver::ResolveHostParameters dns_parameters;
4696 dns_parameters.dns_query_type = DnsQueryType::TXT;
4697
4698 ResolveHostResponseHelper response(resolver_->CreateRequest(
4699 HostPortPair("myhello.local", 80), NetworkIsolationKey(),
4700 NetLogWithSource(), dns_parameters, resolve_context_.get(),
4701 resolve_context_->host_cache()));
4702
4703 socket_factory_ptr->SimulateReceive(kMdnsResponseTxt,
4704 sizeof(kMdnsResponseTxt));
4705 proc_->SignalMultiple(1u);
4706
4707 EXPECT_THAT(response.result_error(), IsOk());
4708 EXPECT_THAT(response.request()->GetTextResults(),
4709 testing::Optional(testing::ElementsAre("foo", "bar")));
4710 }
4711 #endif // BUILDFLAG(ENABLE_MDNS)
4712
4713 // Test that DNS task is always used when explicitly requested as the source,
4714 // even with a case that would normally bypass it eg hosts ending in ".local".
TEST_F(HostResolverManagerDnsTest,DnsNotBypassedWhenDnsSource)4715 TEST_F(HostResolverManagerDnsTest, DnsNotBypassedWhenDnsSource) {
4716 // Ensure DNS task requests will succeed and system (proc) requests will fail.
4717 ChangeDnsConfig(CreateValidDnsConfig());
4718 proc_->AddRuleForAllFamilies(std::string(), std::string());
4719
4720 HostResolver::ResolveHostParameters dns_parameters;
4721 dns_parameters.source = HostResolverSource::DNS;
4722
4723 ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
4724 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4725 dns_parameters, resolve_context_.get(), resolve_context_->host_cache()));
4726 ResolveHostResponseHelper dns_local_response(resolver_->CreateRequest(
4727 HostPortPair("ok.local", 80), NetworkIsolationKey(), NetLogWithSource(),
4728 dns_parameters, resolve_context_.get(), resolve_context_->host_cache()));
4729 ResolveHostResponseHelper normal_local_response(resolver_->CreateRequest(
4730 HostPortPair("ok.local", 80), NetworkIsolationKey(), NetLogWithSource(),
4731 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4732
4733 proc_->SignalMultiple(3u);
4734
4735 EXPECT_THAT(dns_response.result_error(), IsOk());
4736 EXPECT_THAT(dns_local_response.result_error(), IsOk());
4737 EXPECT_THAT(normal_local_response.result_error(),
4738 IsError(ERR_NAME_NOT_RESOLVED));
4739 }
4740
TEST_F(HostResolverManagerDnsTest,SystemOnlyBypassesDnsTask)4741 TEST_F(HostResolverManagerDnsTest, SystemOnlyBypassesDnsTask) {
4742 // Ensure DNS task requests will succeed and system (proc) requests will fail.
4743 ChangeDnsConfig(CreateValidDnsConfig());
4744 proc_->AddRuleForAllFamilies(std::string(), std::string());
4745
4746 ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
4747 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4748 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4749
4750 HostResolver::ResolveHostParameters parameters;
4751 parameters.source = HostResolverSource::SYSTEM;
4752 ResolveHostResponseHelper system_response(resolver_->CreateRequest(
4753 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
4754 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4755
4756 proc_->SignalMultiple(2u);
4757
4758 EXPECT_THAT(dns_response.result_error(), IsOk());
4759 EXPECT_THAT(system_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4760 }
4761
TEST_F(HostResolverManagerDnsTest,DisableInsecureDnsClientOnPersistentFailure)4762 TEST_F(HostResolverManagerDnsTest,
4763 DisableInsecureDnsClientOnPersistentFailure) {
4764 ChangeDnsConfig(CreateValidDnsConfig());
4765
4766 proc_->AddRuleForAllFamilies(std::string(),
4767 std::string()); // Default to failures.
4768
4769 // Check that DnsTask works.
4770 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
4771 HostPortPair("ok_1", 80), NetworkIsolationKey(), NetLogWithSource(),
4772 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4773 EXPECT_THAT(initial_response.result_error(), IsOk());
4774
4775 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
4776 for (unsigned i = 0; i < maximum_insecure_dns_task_failures(); ++i) {
4777 // Use custom names to require separate Jobs.
4778 std::string hostname = base::StringPrintf("nx_%u", i);
4779 // Ensure fallback to ProcTask succeeds.
4780 proc_->AddRuleForAllFamilies(hostname, "192.168.1.101");
4781 responses.emplace_back(
4782 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4783 HostPortPair(hostname, 80), NetworkIsolationKey(),
4784 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4785 resolve_context_->host_cache())));
4786 }
4787
4788 proc_->SignalMultiple(responses.size());
4789
4790 for (size_t i = 0; i < responses.size(); ++i)
4791 EXPECT_THAT(responses[i]->result_error(), IsOk());
4792
4793 ASSERT_FALSE(proc_->HasBlockedRequests());
4794
4795 // Insecure DnsTasks should be disabled by now unless explicitly requested via
4796 // |source|.
4797 ResolveHostResponseHelper fail_response(resolver_->CreateRequest(
4798 HostPortPair("ok_2", 80), NetworkIsolationKey(), NetLogWithSource(),
4799 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4800 HostResolver::ResolveHostParameters parameters;
4801 parameters.source = HostResolverSource::DNS;
4802 ResolveHostResponseHelper dns_response(resolver_->CreateRequest(
4803 HostPortPair("ok_2", 80), NetworkIsolationKey(), NetLogWithSource(),
4804 parameters, resolve_context_.get(), resolve_context_->host_cache()));
4805 proc_->SignalMultiple(2u);
4806 EXPECT_THAT(fail_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
4807 EXPECT_THAT(dns_response.result_error(), IsOk());
4808
4809 // Secure DnsTasks should not be affected.
4810 HostResolver::ResolveHostParameters secure_parameters;
4811 secure_parameters.secure_dns_mode_override =
4812 DnsConfig::SecureDnsMode::AUTOMATIC;
4813 ResolveHostResponseHelper secure_response(resolver_->CreateRequest(
4814 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
4815 secure_parameters, resolve_context_.get(),
4816 resolve_context_->host_cache()));
4817 EXPECT_THAT(secure_response.result_error(), IsOk());
4818
4819 // Check that it is re-enabled after DNS change.
4820 ChangeDnsConfig(CreateValidDnsConfig());
4821 ResolveHostResponseHelper reenabled_response(resolver_->CreateRequest(
4822 HostPortPair("ok_3", 80), NetworkIsolationKey(), NetLogWithSource(),
4823 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4824 EXPECT_THAT(reenabled_response.result_error(), IsOk());
4825 }
4826
TEST_F(HostResolverManagerDnsTest,DontDisableDnsClientOnSporadicFailure)4827 TEST_F(HostResolverManagerDnsTest, DontDisableDnsClientOnSporadicFailure) {
4828 ChangeDnsConfig(CreateValidDnsConfig());
4829
4830 // |proc_| defaults to successes.
4831
4832 // 20 failures interleaved with 20 successes.
4833 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
4834 for (unsigned i = 0; i < 40; ++i) {
4835 // Use custom names to require separate Jobs.
4836 std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i)
4837 : base::StringPrintf("ok_%u", i);
4838 responses.emplace_back(
4839 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
4840 HostPortPair(hostname, 80), NetworkIsolationKey(),
4841 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4842 resolve_context_->host_cache())));
4843 }
4844
4845 proc_->SignalMultiple(40u);
4846
4847 for (const auto& response : responses)
4848 EXPECT_THAT(response->result_error(), IsOk());
4849
4850 // Make |proc_| default to failures.
4851 proc_->AddRuleForAllFamilies(std::string(), std::string());
4852
4853 // DnsTask should still be enabled.
4854 ResolveHostResponseHelper final_response(resolver_->CreateRequest(
4855 HostPortPair("ok_last", 80), NetworkIsolationKey(), NetLogWithSource(),
4856 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4857 EXPECT_THAT(final_response.result_error(), IsOk());
4858 }
4859
TEST_F(HostResolverManagerDnsTest,Ipv6Unreachable)4860 TEST_F(HostResolverManagerDnsTest, Ipv6Unreachable) {
4861 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
4862 false /* ipv6_reachable */,
4863 true /* check_ipv6_on_wifi */);
4864 ChangeDnsConfig(CreateValidDnsConfig());
4865
4866 ResolveHostResponseHelper response(resolver_->CreateRequest(
4867 HostPortPair("ok", 500), NetworkIsolationKey(), NetLogWithSource(),
4868 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4869 EXPECT_THAT(response.result_error(), IsOk());
4870
4871 // Only expect IPv4 results.
4872 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
4873 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 500)));
4874 }
4875
4876 // Without a valid DnsConfig, assume IPv6 is needed and ignore prober.
TEST_F(HostResolverManagerDnsTest,Ipv6Unreachable_InvalidConfig)4877 TEST_F(HostResolverManagerDnsTest, Ipv6Unreachable_InvalidConfig) {
4878 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
4879 false /* ipv6_reachable */,
4880 true /* check_ipv6_on_wifi */);
4881
4882 proc_->AddRule("example.com", ADDRESS_FAMILY_UNSPECIFIED, "1.2.3.4,::5");
4883 proc_->SignalMultiple(1u);
4884
4885 ResolveHostResponseHelper response(resolver_->CreateRequest(
4886 HostPortPair("example.com", 500), NetworkIsolationKey(),
4887 NetLogWithSource(), base::nullopt, resolve_context_.get(),
4888 resolve_context_->host_cache()));
4889 EXPECT_THAT(response.result_error(), IsOk());
4890 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
4891 testing::UnorderedElementsAre(CreateExpected("1.2.3.4", 500),
4892 CreateExpected("::5", 500)));
4893 }
4894
TEST_F(HostResolverManagerDnsTest,Ipv6Unreachable_UseLocalIpv6)4895 TEST_F(HostResolverManagerDnsTest, Ipv6Unreachable_UseLocalIpv6) {
4896 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
4897 false /* ipv6_reachable */,
4898 true /* check_ipv6_on_wifi */);
4899
4900 DnsConfig config = CreateValidDnsConfig();
4901 config.use_local_ipv6 = true;
4902 ChangeDnsConfig(config);
4903
4904 ResolveHostResponseHelper response1(resolver_->CreateRequest(
4905 HostPortPair("ok", 500), NetworkIsolationKey(), NetLogWithSource(),
4906 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4907 EXPECT_THAT(response1.result_error(), IsOk());
4908 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
4909 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 500),
4910 CreateExpected("::1", 500)));
4911
4912 // Set |use_local_ipv6| to false. Expect only IPv4 results.
4913 config.use_local_ipv6 = false;
4914 ChangeDnsConfig(config);
4915
4916 ResolveHostResponseHelper response2(resolver_->CreateRequest(
4917 HostPortPair("ok", 500), NetworkIsolationKey(), NetLogWithSource(),
4918 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4919 EXPECT_THAT(response2.result_error(), IsOk());
4920 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
4921 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 500)));
4922 }
4923
4924 // Confirm that resolving "localhost" is unrestricted even if there are no
4925 // global IPv6 address. See SystemHostResolverCall for rationale.
4926 // Test both the DnsClient and system host resolver paths.
TEST_F(HostResolverManagerDnsTest,Ipv6Unreachable_Localhost)4927 TEST_F(HostResolverManagerDnsTest, Ipv6Unreachable_Localhost) {
4928 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
4929 false /* ipv6_reachable */,
4930 true /* check_ipv6_on_wifi */);
4931
4932 // Make request fail if we actually get to the system resolver.
4933 proc_->AddRuleForAllFamilies(std::string(), std::string());
4934
4935 // Try without DnsClient.
4936 resolver_->SetInsecureDnsClientEnabled(false);
4937 ResolveHostResponseHelper system_response(resolver_->CreateRequest(
4938 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
4939 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4940 EXPECT_THAT(system_response.result_error(), IsOk());
4941 EXPECT_THAT(
4942 system_response.request()->GetAddressResults().value().endpoints(),
4943 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4944 CreateExpected("::1", 80)));
4945
4946 // With DnsClient
4947 UseMockDnsClient(CreateValidDnsConfig(), CreateDefaultDnsRules());
4948 ResolveHostResponseHelper builtin_response(resolver_->CreateRequest(
4949 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
4950 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4951 EXPECT_THAT(builtin_response.result_error(), IsOk());
4952 EXPECT_THAT(
4953 builtin_response.request()->GetAddressResults().value().endpoints(),
4954 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4955 CreateExpected("::1", 80)));
4956
4957 // DnsClient configured without ipv6 (but ipv6 should still work for
4958 // localhost).
4959 DnsConfig config = CreateValidDnsConfig();
4960 config.use_local_ipv6 = false;
4961 ChangeDnsConfig(config);
4962 ResolveHostResponseHelper ipv6_disabled_response(resolver_->CreateRequest(
4963 HostPortPair("localhost", 80), NetworkIsolationKey(), NetLogWithSource(),
4964 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
4965 EXPECT_THAT(ipv6_disabled_response.result_error(), IsOk());
4966 EXPECT_THAT(
4967 ipv6_disabled_response.request()->GetAddressResults().value().endpoints(),
4968 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
4969 CreateExpected("::1", 80)));
4970 }
4971
TEST_F(HostResolverManagerDnsTest,SeparateJobsBySecureDnsMode)4972 TEST_F(HostResolverManagerDnsTest, SeparateJobsBySecureDnsMode) {
4973 MockDnsClientRuleList rules;
4974 rules.emplace_back("a", dns_protocol::kTypeA, true /* secure */,
4975 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
4976 true /* delay */);
4977 rules.emplace_back("a", dns_protocol::kTypeAAAA, true /* secure */,
4978 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
4979 true /* delay */);
4980 rules.emplace_back("a", dns_protocol::kTypeA, false /* secure */,
4981 MockDnsClientRule::Result(MockDnsClientRule::OK),
4982 false /* delay */);
4983 rules.emplace_back("a", dns_protocol::kTypeAAAA, false /* secure */,
4984 MockDnsClientRule::Result(MockDnsClientRule::OK),
4985 false /* delay */);
4986 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
4987 DnsConfigOverrides overrides;
4988 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
4989 resolver_->SetDnsConfigOverrides(overrides);
4990
4991 // Create three requests. One with a SECURE mode override, one with no
4992 // mode override, and one with an AUTOMATIC mode override (which is a no-op
4993 // since the DnsConfig uses AUTOMATIC).
4994 HostResolver::ResolveHostParameters parameters_secure_override;
4995 parameters_secure_override.secure_dns_mode_override =
4996 DnsConfig::SecureDnsMode::SECURE;
4997 ResolveHostResponseHelper secure_response(resolver_->CreateRequest(
4998 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
4999 parameters_secure_override, resolve_context_.get(),
5000 resolve_context_->host_cache()));
5001 EXPECT_EQ(1u, resolver_->num_jobs_for_testing());
5002
5003 ResolveHostResponseHelper automatic_response0(resolver_->CreateRequest(
5004 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
5005 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5006 EXPECT_EQ(2u, resolver_->num_jobs_for_testing());
5007
5008 HostResolver::ResolveHostParameters parameters_automatic_override;
5009 parameters_automatic_override.secure_dns_mode_override =
5010 DnsConfig::SecureDnsMode::AUTOMATIC;
5011 ResolveHostResponseHelper automatic_response1(resolver_->CreateRequest(
5012 HostPortPair("a", 80), NetworkIsolationKey(), NetLogWithSource(),
5013 parameters_automatic_override, resolve_context_.get(),
5014 resolve_context_->host_cache()));
5015 // The AUTOMATIC mode requests should be joined into the same job.
5016 EXPECT_EQ(2u, resolver_->num_jobs_for_testing());
5017
5018 // All requests should be blocked on the secure transactions.
5019 base::RunLoop().RunUntilIdle();
5020 EXPECT_FALSE(secure_response.complete());
5021 EXPECT_FALSE(automatic_response0.complete());
5022 EXPECT_FALSE(automatic_response1.complete());
5023
5024 // Complete secure transactions.
5025 dns_client_->CompleteDelayedTransactions();
5026 EXPECT_THAT(secure_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
5027 EXPECT_THAT(automatic_response0.result_error(), IsOk());
5028 EXPECT_THAT(automatic_response1.result_error(), IsOk());
5029 }
5030
5031 // Cancel a request with a single DNS transaction active.
TEST_F(HostResolverManagerDnsTest,CancelWithOneTransactionActive)5032 TEST_F(HostResolverManagerDnsTest, CancelWithOneTransactionActive) {
5033 // Disable ipv6 to ensure we'll only try a single transaction for the host.
5034 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
5035 false /* ipv6_reachable */,
5036 true /* check_ipv6_on_wifi */);
5037 DnsConfig config = CreateValidDnsConfig();
5038 config.use_local_ipv6 = false;
5039 ChangeDnsConfig(config);
5040
5041 ResolveHostResponseHelper response(resolver_->CreateRequest(
5042 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5043 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5044 ASSERT_FALSE(response.complete());
5045 ASSERT_EQ(1u, num_running_dispatcher_jobs());
5046
5047 response.CancelRequest();
5048 base::RunLoop().RunUntilIdle();
5049 EXPECT_FALSE(response.complete());
5050
5051 // Dispatcher state checked in TearDown.
5052 }
5053
5054 // Cancel a request with a single DNS transaction active and another pending.
TEST_F(HostResolverManagerDnsTest,CancelWithOneTransactionActiveOnePending)5055 TEST_F(HostResolverManagerDnsTest, CancelWithOneTransactionActiveOnePending) {
5056 CreateSerialResolver();
5057 ChangeDnsConfig(CreateValidDnsConfig());
5058
5059 ResolveHostResponseHelper response(resolver_->CreateRequest(
5060 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5061 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5062 EXPECT_EQ(1u, num_running_dispatcher_jobs());
5063
5064 response.CancelRequest();
5065 base::RunLoop().RunUntilIdle();
5066 EXPECT_FALSE(response.complete());
5067
5068 // Dispatcher state checked in TearDown.
5069 }
5070
5071 // Cancel a request with two DNS transactions active.
TEST_F(HostResolverManagerDnsTest,CancelWithTwoTransactionsActive)5072 TEST_F(HostResolverManagerDnsTest, CancelWithTwoTransactionsActive) {
5073 ChangeDnsConfig(CreateValidDnsConfig());
5074
5075 ResolveHostResponseHelper response(resolver_->CreateRequest(
5076 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5077 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5078 EXPECT_EQ(2u, num_running_dispatcher_jobs());
5079
5080 response.CancelRequest();
5081 base::RunLoop().RunUntilIdle();
5082 EXPECT_FALSE(response.complete());
5083
5084 // Dispatcher state checked in TearDown.
5085 }
5086
5087 // Delete a resolver with some active requests and some queued requests.
TEST_F(HostResolverManagerDnsTest,DeleteWithActiveTransactions)5088 TEST_F(HostResolverManagerDnsTest, DeleteWithActiveTransactions) {
5089 // At most 10 Jobs active at once.
5090 CreateResolverWithLimitsAndParams(10u, DefaultParams(proc_.get()),
5091 true /* ipv6_reachable */,
5092 true /* check_ipv6_on_wifi */);
5093
5094 ChangeDnsConfig(CreateValidDnsConfig());
5095
5096 // Add 12 DNS lookups (creating well more than 10 transaction).
5097 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
5098 for (int i = 0; i < 12; ++i) {
5099 std::string hostname = base::StringPrintf("ok%i", i);
5100 responses.emplace_back(
5101 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
5102 HostPortPair(hostname, 80), NetworkIsolationKey(),
5103 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5104 resolve_context_->host_cache())));
5105 }
5106 EXPECT_EQ(10u, num_running_dispatcher_jobs());
5107
5108 DestroyResolver();
5109
5110 base::RunLoop().RunUntilIdle();
5111 for (auto& response : responses) {
5112 EXPECT_FALSE(response->complete());
5113 }
5114 }
5115
TEST_F(HostResolverManagerDnsTest,DeleteWithSecureTransactions)5116 TEST_F(HostResolverManagerDnsTest, DeleteWithSecureTransactions) {
5117 ChangeDnsConfig(CreateValidDnsConfig());
5118 DnsConfigOverrides overrides;
5119 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
5120 resolver_->SetDnsConfigOverrides(overrides);
5121
5122 ResolveHostResponseHelper response(resolver_->CreateRequest(
5123 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5124 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5125
5126 DestroyResolver();
5127
5128 base::RunLoop().RunUntilIdle();
5129 EXPECT_FALSE(response.complete());
5130 }
5131
TEST_F(HostResolverManagerDnsTest,DeleteWithCompletedRequests)5132 TEST_F(HostResolverManagerDnsTest, DeleteWithCompletedRequests) {
5133 ChangeDnsConfig(CreateValidDnsConfig());
5134
5135 ResolveHostResponseHelper response(resolver_->CreateRequest(
5136 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5137 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5138
5139 EXPECT_THAT(response.result_error(), IsOk());
5140 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5141 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5142 CreateExpected("::1", 80)));
5143
5144 DestroyResolver();
5145
5146 // Completed requests should be unaffected by manager destruction.
5147 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5148 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5149 CreateExpected("::1", 80)));
5150 }
5151
TEST_F(HostResolverManagerDnsTest,ExplicitCancel)5152 TEST_F(HostResolverManagerDnsTest, ExplicitCancel) {
5153 ChangeDnsConfig(CreateValidDnsConfig());
5154
5155 ResolveHostResponseHelper response(resolver_->CreateRequest(
5156 HostPortPair("4slow_4ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5157 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5158
5159 response.request()->Cancel();
5160 dns_client_->CompleteDelayedTransactions();
5161
5162 base::RunLoop().RunUntilIdle();
5163 EXPECT_FALSE(response.complete());
5164 }
5165
TEST_F(HostResolverManagerDnsTest,ExplicitCancel_AfterManagerDestruction)5166 TEST_F(HostResolverManagerDnsTest, ExplicitCancel_AfterManagerDestruction) {
5167 ChangeDnsConfig(CreateValidDnsConfig());
5168
5169 ResolveHostResponseHelper response(resolver_->CreateRequest(
5170 HostPortPair("4slow_4ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5171 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5172
5173 DestroyResolver();
5174 response.request()->Cancel();
5175 }
5176
TEST_F(HostResolverManagerDnsTest,ExplicitCancel_Completed)5177 TEST_F(HostResolverManagerDnsTest, ExplicitCancel_Completed) {
5178 ChangeDnsConfig(CreateValidDnsConfig());
5179
5180 ResolveHostResponseHelper response(resolver_->CreateRequest(
5181 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5182 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5183
5184 EXPECT_THAT(response.result_error(), IsOk());
5185 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5186 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5187 CreateExpected("::1", 80)));
5188
5189 response.request()->Cancel();
5190
5191 // Completed requests should be unaffected by cancellation.
5192 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5193 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5194 CreateExpected("::1", 80)));
5195 }
5196
5197 // Cancel a request with only the IPv6 transaction active.
TEST_F(HostResolverManagerDnsTest,CancelWithIPv6TransactionActive)5198 TEST_F(HostResolverManagerDnsTest, CancelWithIPv6TransactionActive) {
5199 ChangeDnsConfig(CreateValidDnsConfig());
5200
5201 ResolveHostResponseHelper response(resolver_->CreateRequest(
5202 HostPortPair("6slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5203 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5204 EXPECT_EQ(2u, num_running_dispatcher_jobs());
5205
5206 // The IPv4 request should complete, the IPv6 request is still pending.
5207 base::RunLoop().RunUntilIdle();
5208 EXPECT_EQ(1u, num_running_dispatcher_jobs());
5209
5210 response.CancelRequest();
5211 base::RunLoop().RunUntilIdle();
5212 EXPECT_FALSE(response.complete());
5213
5214 // Dispatcher state checked in TearDown.
5215 }
5216
5217 // Cancel a request with only the IPv4 transaction pending.
TEST_F(HostResolverManagerDnsTest,CancelWithIPv4TransactionPending)5218 TEST_F(HostResolverManagerDnsTest, CancelWithIPv4TransactionPending) {
5219 set_allow_fallback_to_proctask(false);
5220 ChangeDnsConfig(CreateValidDnsConfig());
5221
5222 ResolveHostResponseHelper response(resolver_->CreateRequest(
5223 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5224 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5225 EXPECT_EQ(2u, num_running_dispatcher_jobs());
5226
5227 // The IPv6 request should complete, the IPv4 request is still pending.
5228 base::RunLoop().RunUntilIdle();
5229 EXPECT_EQ(1u, num_running_dispatcher_jobs());
5230
5231 response.CancelRequest();
5232 base::RunLoop().RunUntilIdle();
5233 EXPECT_FALSE(response.complete());
5234 }
5235
TEST_F(HostResolverManagerDnsTest,CancelWithAutomaticModeTransactionPending)5236 TEST_F(HostResolverManagerDnsTest, CancelWithAutomaticModeTransactionPending) {
5237 MockDnsClientRuleList rules;
5238 rules.emplace_back("secure_6slow_6nx_insecure_6slow_ok", dns_protocol::kTypeA,
5239 true /* secure */,
5240 MockDnsClientRule::Result(MockDnsClientRule::OK),
5241 false /* delay */);
5242 rules.emplace_back("secure_6slow_6nx_insecure_6slow_ok",
5243 dns_protocol::kTypeAAAA, true /* secure */,
5244 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
5245 true /* delay */);
5246 rules.emplace_back("secure_6slow_6nx_insecure_6slow_ok", dns_protocol::kTypeA,
5247 false /* secure */,
5248 MockDnsClientRule::Result(MockDnsClientRule::OK),
5249 false /* delay */);
5250 rules.emplace_back("secure_6slow_6nx_insecure_6slow_ok",
5251 dns_protocol::kTypeAAAA, false /* secure */,
5252 MockDnsClientRule::Result(MockDnsClientRule::OK),
5253 true /* delay */);
5254 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
5255
5256 DnsConfigOverrides overrides;
5257 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5258 resolver_->SetDnsConfigOverrides(overrides);
5259
5260 ResolveHostResponseHelper response0(resolver_->CreateRequest(
5261 HostPortPair("secure_6slow_6nx_insecure_6slow_ok", 80),
5262 NetworkIsolationKey(), NetLogWithSource(), base::nullopt,
5263 resolve_context_.get(), resolve_context_->host_cache()));
5264 EXPECT_EQ(0u, num_running_dispatcher_jobs());
5265
5266 // The secure IPv4 request should complete, the secure IPv6 request is still
5267 // pending.
5268 base::RunLoop().RunUntilIdle();
5269 EXPECT_EQ(0u, num_running_dispatcher_jobs());
5270
5271 response0.CancelRequest();
5272 base::RunLoop().RunUntilIdle();
5273 EXPECT_FALSE(response0.complete());
5274 EXPECT_EQ(0u, num_running_dispatcher_jobs());
5275
5276 ResolveHostResponseHelper response1(resolver_->CreateRequest(
5277 HostPortPair("secure_6slow_6nx_insecure_6slow_ok", 80),
5278 NetworkIsolationKey(), NetLogWithSource(), base::nullopt,
5279 resolve_context_.get(), resolve_context_->host_cache()));
5280 EXPECT_EQ(0u, num_running_dispatcher_jobs());
5281
5282 // The secure IPv4 request should complete, the secure IPv6 request is still
5283 // pending.
5284 base::RunLoop().RunUntilIdle();
5285 EXPECT_EQ(0u, num_running_dispatcher_jobs());
5286
5287 // Let the secure IPv6 request complete and start the insecure requests.
5288 dns_client_->CompleteDelayedTransactions();
5289 EXPECT_EQ(2u, num_running_dispatcher_jobs());
5290
5291 // The insecure IPv4 request should complete, the insecure IPv6 request is
5292 // still pending.
5293 base::RunLoop().RunUntilIdle();
5294 EXPECT_EQ(1u, num_running_dispatcher_jobs());
5295
5296 response1.CancelRequest();
5297 base::RunLoop().RunUntilIdle();
5298 EXPECT_FALSE(response1.complete());
5299
5300 // Dispatcher state checked in TearDown.
5301 }
5302
5303 // Test cases where AAAA completes first.
TEST_F(HostResolverManagerDnsTest,AAAACompletesFirst)5304 TEST_F(HostResolverManagerDnsTest, AAAACompletesFirst) {
5305 set_allow_fallback_to_proctask(false);
5306 ChangeDnsConfig(CreateValidDnsConfig());
5307
5308 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
5309 responses.emplace_back(
5310 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
5311 HostPortPair("4slow_ok", 80), NetworkIsolationKey(),
5312 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5313 resolve_context_->host_cache())));
5314 responses.emplace_back(
5315 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
5316 HostPortPair("4slow_4ok", 80), NetworkIsolationKey(),
5317 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5318 resolve_context_->host_cache())));
5319 responses.emplace_back(
5320 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
5321 HostPortPair("4slow_4timeout", 80), NetworkIsolationKey(),
5322 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5323 resolve_context_->host_cache())));
5324 responses.emplace_back(
5325 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
5326 HostPortPair("4slow_6timeout", 80), NetworkIsolationKey(),
5327 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5328 resolve_context_->host_cache())));
5329
5330 base::RunLoop().RunUntilIdle();
5331 EXPECT_FALSE(responses[0]->complete());
5332 EXPECT_FALSE(responses[1]->complete());
5333 EXPECT_FALSE(responses[2]->complete());
5334 // The IPv6 of request 3 should have failed and resulted in cancelling the
5335 // IPv4 request.
5336 EXPECT_THAT(responses[3]->result_error(), IsError(ERR_DNS_TIMED_OUT));
5337 EXPECT_EQ(3u, num_running_dispatcher_jobs());
5338
5339 dns_client_->CompleteDelayedTransactions();
5340 EXPECT_THAT(responses[0]->result_error(), IsOk());
5341 EXPECT_THAT(responses[0]->request()->GetAddressResults().value().endpoints(),
5342 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5343 CreateExpected("::1", 80)));
5344
5345 EXPECT_THAT(responses[1]->result_error(), IsOk());
5346 EXPECT_THAT(responses[1]->request()->GetAddressResults().value().endpoints(),
5347 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
5348
5349 EXPECT_THAT(responses[2]->result_error(), IsError(ERR_DNS_TIMED_OUT));
5350 }
5351
TEST_F(HostResolverManagerDnsTest,AAAACompletesFirst_AutomaticMode)5352 TEST_F(HostResolverManagerDnsTest, AAAACompletesFirst_AutomaticMode) {
5353 MockDnsClientRuleList rules;
5354 rules.emplace_back("secure_slow_nx_insecure_4slow_ok", dns_protocol::kTypeA,
5355 true /* secure */,
5356 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
5357 true /* delay */);
5358 rules.emplace_back("secure_slow_nx_insecure_4slow_ok",
5359 dns_protocol::kTypeAAAA, true /* secure */,
5360 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
5361 true /* delay */);
5362 rules.emplace_back("secure_slow_nx_insecure_4slow_ok", dns_protocol::kTypeA,
5363 false /* secure */,
5364 MockDnsClientRule::Result(MockDnsClientRule::OK),
5365 true /* delay */);
5366 rules.emplace_back("secure_slow_nx_insecure_4slow_ok",
5367 dns_protocol::kTypeAAAA, false /* secure */,
5368 MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
5369 false /* delay */);
5370 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
5371 DnsConfigOverrides overrides;
5372 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5373 resolver_->SetDnsConfigOverrides(overrides);
5374
5375 ResolveHostResponseHelper response(resolver_->CreateRequest(
5376 HostPortPair("secure_slow_nx_insecure_4slow_ok", 80),
5377 NetworkIsolationKey(), NetLogWithSource(), base::nullopt,
5378 resolve_context_.get(), resolve_context_->host_cache()));
5379 base::RunLoop().RunUntilIdle();
5380 EXPECT_FALSE(response.complete());
5381 // Complete the secure transactions.
5382 dns_client_->CompleteDelayedTransactions();
5383 base::RunLoop().RunUntilIdle();
5384 EXPECT_FALSE(response.complete());
5385 // Complete the insecure transactions.
5386 dns_client_->CompleteDelayedTransactions();
5387 ASSERT_THAT(response.result_error(), IsOk());
5388 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5389 testing::ElementsAre(CreateExpected("127.0.0.1", 80)));
5390 HostCache::Key insecure_key =
5391 HostCache::Key("secure_slow_nx_insecure_4slow_ok",
5392 DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5393 HostResolverSource::ANY, NetworkIsolationKey());
5394 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
5395 GetCacheHit(insecure_key);
5396 EXPECT_TRUE(!!cache_result);
5397 }
5398
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic)5399 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic) {
5400 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.100");
5401 set_allow_fallback_to_proctask(true);
5402
5403 ChangeDnsConfig(CreateValidDnsConfig());
5404 DnsConfigOverrides overrides;
5405 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5406 resolver_->SetDnsConfigOverrides(overrides);
5407 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5408
5409 // A successful DoH request should result in a secure cache entry.
5410 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5411 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5412 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5413 ASSERT_THAT(response_secure.result_error(), IsOk());
5414 EXPECT_FALSE(
5415 response_secure.request()->GetResolveErrorInfo().is_secure_network_error);
5416 EXPECT_THAT(
5417 response_secure.request()->GetAddressResults().value().endpoints(),
5418 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5419 CreateExpected("::1", 80)));
5420 HostCache::Key secure_key = HostCache::Key(
5421 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5422 HostResolverSource::ANY, NetworkIsolationKey());
5423 secure_key.secure = true;
5424 cache_result = GetCacheHit(secure_key);
5425 EXPECT_TRUE(!!cache_result);
5426
5427 // A successful plaintext DNS request should result in an insecure cache
5428 // entry.
5429 ResolveHostResponseHelper response_insecure(resolver_->CreateRequest(
5430 HostPortPair("insecure_automatic", 80), NetworkIsolationKey(),
5431 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5432 resolve_context_->host_cache()));
5433 ASSERT_THAT(response_insecure.result_error(), IsOk());
5434 EXPECT_FALSE(response_insecure.request()
5435 ->GetResolveErrorInfo()
5436 .is_secure_network_error);
5437 EXPECT_THAT(
5438 response_insecure.request()->GetAddressResults().value().endpoints(),
5439 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5440 CreateExpected("::1", 80)));
5441 HostCache::Key insecure_key =
5442 HostCache::Key("insecure_automatic", DnsQueryType::UNSPECIFIED,
5443 0 /* host_resolver_flags */, HostResolverSource::ANY,
5444 NetworkIsolationKey());
5445 cache_result = GetCacheHit(insecure_key);
5446 EXPECT_TRUE(!!cache_result);
5447
5448 // Fallback to ProcTask allowed in AUTOMATIC mode.
5449 ResolveHostResponseHelper response_proc(resolver_->CreateRequest(
5450 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
5451 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5452 proc_->SignalMultiple(1u);
5453 EXPECT_THAT(response_proc.result_error(), IsOk());
5454 EXPECT_THAT(response_proc.request()->GetAddressResults().value().endpoints(),
5455 testing::ElementsAre(CreateExpected("192.168.1.100", 80)));
5456 }
5457
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_SecureCache)5458 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_SecureCache) {
5459 ChangeDnsConfig(CreateValidDnsConfig());
5460 DnsConfigOverrides overrides;
5461 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5462 resolver_->SetDnsConfigOverrides(overrides);
5463
5464 // Populate cache with a secure entry.
5465 HostCache::Key cached_secure_key =
5466 HostCache::Key("automatic_cached", DnsQueryType::UNSPECIFIED,
5467 0 /* host_resolver_flags */, HostResolverSource::ANY,
5468 NetworkIsolationKey());
5469 cached_secure_key.secure = true;
5470 IPEndPoint kExpectedSecureIP = CreateExpected("192.168.1.102", 80);
5471 PopulateCache(cached_secure_key, kExpectedSecureIP);
5472
5473 // The secure cache should be checked prior to any DoH request being sent.
5474 ResolveHostResponseHelper response_secure_cached(resolver_->CreateRequest(
5475 HostPortPair("automatic_cached", 80), NetworkIsolationKey(),
5476 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5477 resolve_context_->host_cache()));
5478 EXPECT_THAT(response_secure_cached.result_error(), IsOk());
5479 EXPECT_FALSE(response_secure_cached.request()
5480 ->GetResolveErrorInfo()
5481 .is_secure_network_error);
5482 EXPECT_THAT(
5483 response_secure_cached.request()->GetAddressResults().value().endpoints(),
5484 testing::ElementsAre(kExpectedSecureIP));
5485 EXPECT_FALSE(
5486 response_secure_cached.request()->GetStaleInfo().value().is_stale());
5487 }
5488
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_InsecureCache)5489 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_InsecureCache) {
5490 ChangeDnsConfig(CreateValidDnsConfig());
5491 DnsConfigOverrides overrides;
5492 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5493 resolver_->SetDnsConfigOverrides(overrides);
5494
5495 // Populate cache with an insecure entry.
5496 HostCache::Key cached_insecure_key =
5497 HostCache::Key("insecure_automatic_cached", DnsQueryType::UNSPECIFIED,
5498 0 /* host_resolver_flags */, HostResolverSource::ANY,
5499 NetworkIsolationKey());
5500 IPEndPoint kExpectedInsecureIP = CreateExpected("192.168.1.103", 80);
5501 PopulateCache(cached_insecure_key, kExpectedInsecureIP);
5502
5503 // The insecure cache should be checked after DoH requests fail.
5504 ResolveHostResponseHelper response_insecure_cached(resolver_->CreateRequest(
5505 HostPortPair("insecure_automatic_cached", 80), NetworkIsolationKey(),
5506 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5507 resolve_context_->host_cache()));
5508 EXPECT_THAT(response_insecure_cached.result_error(), IsOk());
5509 EXPECT_FALSE(response_insecure_cached.request()
5510 ->GetResolveErrorInfo()
5511 .is_secure_network_error);
5512 EXPECT_THAT(response_insecure_cached.request()
5513 ->GetAddressResults()
5514 .value()
5515 .endpoints(),
5516 testing::ElementsAre(kExpectedInsecureIP));
5517 EXPECT_FALSE(
5518 response_insecure_cached.request()->GetStaleInfo().value().is_stale());
5519 }
5520
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_Downgrade)5521 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_Downgrade) {
5522 ChangeDnsConfig(CreateValidDnsConfig());
5523 // Remove all DoH servers from the config so there is no DoH server available.
5524 DnsConfigOverrides overrides;
5525 std::vector<DnsOverHttpsServerConfig> doh_servers;
5526 overrides.dns_over_https_servers = doh_servers;
5527 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5528 resolver_->SetDnsConfigOverrides(overrides);
5529 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5530
5531 // Populate cache with both secure and insecure entries.
5532 HostCache::Key cached_secure_key =
5533 HostCache::Key("automatic_cached", DnsQueryType::UNSPECIFIED,
5534 0 /* host_resolver_flags */, HostResolverSource::ANY,
5535 NetworkIsolationKey());
5536 cached_secure_key.secure = true;
5537 IPEndPoint kExpectedSecureIP = CreateExpected("192.168.1.102", 80);
5538 PopulateCache(cached_secure_key, kExpectedSecureIP);
5539 HostCache::Key cached_insecure_key =
5540 HostCache::Key("insecure_automatic_cached", DnsQueryType::UNSPECIFIED,
5541 0 /* host_resolver_flags */, HostResolverSource::ANY,
5542 NetworkIsolationKey());
5543 IPEndPoint kExpectedInsecureIP = CreateExpected("192.168.1.103", 80);
5544 PopulateCache(cached_insecure_key, kExpectedInsecureIP);
5545
5546 // The secure cache should still be checked first.
5547 ResolveHostResponseHelper response_cached(resolver_->CreateRequest(
5548 HostPortPair("automatic_cached", 80), NetworkIsolationKey(),
5549 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5550 resolve_context_->host_cache()));
5551 EXPECT_THAT(response_cached.result_error(), IsOk());
5552 EXPECT_THAT(
5553 response_cached.request()->GetAddressResults().value().endpoints(),
5554 testing::ElementsAre(kExpectedSecureIP));
5555
5556 // The insecure cache should be checked before any insecure requests are sent.
5557 ResolveHostResponseHelper insecure_response_cached(resolver_->CreateRequest(
5558 HostPortPair("insecure_automatic_cached", 80), NetworkIsolationKey(),
5559 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5560 resolve_context_->host_cache()));
5561 EXPECT_THAT(insecure_response_cached.result_error(), IsOk());
5562 EXPECT_THAT(insecure_response_cached.request()
5563 ->GetAddressResults()
5564 .value()
5565 .endpoints(),
5566 testing::ElementsAre(kExpectedInsecureIP));
5567
5568 // The DnsConfig doesn't contain DoH servers so AUTOMATIC mode will be
5569 // downgraded to OFF. A successful plaintext DNS request should result in an
5570 // insecure cache entry.
5571 ResolveHostResponseHelper response(resolver_->CreateRequest(
5572 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5573 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5574 ASSERT_THAT(response.result_error(), IsOk());
5575 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
5576 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5577 CreateExpected("::1", 80)));
5578 HostCache::Key key = HostCache::Key(
5579 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5580 HostResolverSource::ANY, NetworkIsolationKey());
5581 cache_result = GetCacheHit(key);
5582 EXPECT_TRUE(!!cache_result);
5583 }
5584
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_Unavailable)5585 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_Unavailable) {
5586 ChangeDnsConfig(CreateValidDnsConfig());
5587 DnsConfigOverrides overrides;
5588 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5589 resolver_->SetDnsConfigOverrides(overrides);
5590 dns_client_->SetForceDohServerAvailable(false);
5591
5592 // DoH requests should be skipped when there are no available DoH servers
5593 // in automatic mode. The cached result should be in the insecure cache.
5594 ResolveHostResponseHelper response_automatic(resolver_->CreateRequest(
5595 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5596 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5597 ASSERT_THAT(response_automatic.result_error(), IsOk());
5598 EXPECT_FALSE(response_automatic.request()
5599 ->GetResolveErrorInfo()
5600 .is_secure_network_error);
5601 EXPECT_THAT(
5602 response_automatic.request()->GetAddressResults().value().endpoints(),
5603 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5604 CreateExpected("::1", 80)));
5605 HostCache::Key secure_key = HostCache::Key(
5606 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5607 HostResolverSource::ANY, NetworkIsolationKey());
5608 secure_key.secure = true;
5609 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
5610 GetCacheHit(secure_key);
5611 EXPECT_FALSE(!!cache_result);
5612
5613 HostCache::Key insecure_key = HostCache::Key(
5614 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5615 HostResolverSource::ANY, NetworkIsolationKey());
5616 cache_result = GetCacheHit(insecure_key);
5617 EXPECT_TRUE(!!cache_result);
5618 }
5619
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_Unavailable_Fail)5620 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_Unavailable_Fail) {
5621 set_allow_fallback_to_proctask(false);
5622 ChangeDnsConfig(CreateValidDnsConfig());
5623 DnsConfigOverrides overrides;
5624 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5625 resolver_->SetDnsConfigOverrides(overrides);
5626 dns_client_->SetForceDohServerAvailable(false);
5627
5628 // Insecure requests that fail should not be cached.
5629 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5630 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5631 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5632 ASSERT_THAT(response_secure.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
5633 EXPECT_FALSE(
5634 response_secure.request()->GetResolveErrorInfo().is_secure_network_error);
5635
5636 HostCache::Key secure_key = HostCache::Key(
5637 "secure", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5638 HostResolverSource::ANY, NetworkIsolationKey());
5639 secure_key.secure = true;
5640 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
5641 GetCacheHit(secure_key);
5642 EXPECT_FALSE(!!cache_result);
5643
5644 HostCache::Key insecure_key = HostCache::Key(
5645 "secure", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5646 HostResolverSource::ANY, NetworkIsolationKey());
5647 cache_result = GetCacheHit(insecure_key);
5648 EXPECT_FALSE(!!cache_result);
5649 }
5650
5651 // Test that DoH server availability is respected per-context.
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_UnavailableByContext)5652 TEST_F(HostResolverManagerDnsTest,
5653 SecureDnsMode_Automatic_UnavailableByContext) {
5654 // Create and register two separate contexts.
5655 TestURLRequestContext request_context1;
5656 TestURLRequestContext request_context2;
5657 ResolveContext resolve_context1(&request_context1,
5658 false /* enable_caching */);
5659 ResolveContext resolve_context2(&request_context2,
5660 false /* enable_caching */);
5661 resolver_->RegisterResolveContext(&resolve_context1);
5662 resolver_->RegisterResolveContext(&resolve_context2);
5663
5664 // Configure the resolver and underlying mock to attempt a secure query iff
5665 // the context has marked a DoH server available and otherwise attempt a
5666 // non-secure query.
5667 set_allow_fallback_to_proctask(false);
5668 ChangeDnsConfig(CreateValidDnsConfig());
5669 DnsConfigOverrides overrides;
5670 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5671 resolver_->SetDnsConfigOverrides(overrides);
5672 dns_client_->SetForceDohServerAvailable(false);
5673
5674 // Mark a DoH server successful only for |resolve_context2|. Note that this
5675 // must come after the resolver's configuration is set because this relies on
5676 // the specific configuration containing a DoH server.
5677 resolve_context2.RecordServerSuccess(0u /* server_index */,
5678 true /* is_doh_server */,
5679 dns_client_->GetCurrentSession());
5680
5681 // No available DoH servers for |resolve_context1|, so expect a non-secure
5682 // request. Non-secure requests for "secure" will fail with
5683 // ERR_NAME_NOT_RESOLVED.
5684 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5685 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5686 base::nullopt, &resolve_context1, resolve_context_->host_cache()));
5687 ASSERT_THAT(response_secure.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
5688
5689 // One available DoH server for |resolve_context2|, so expect a secure
5690 // request. Secure requests for "secure" will succeed.
5691 ResolveHostResponseHelper response_secure2(resolver_->CreateRequest(
5692 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5693 base::nullopt, &resolve_context2, nullptr /* host_cache */));
5694 ASSERT_THAT(response_secure2.result_error(), IsOk());
5695
5696 resolver_->DeregisterResolveContext(&resolve_context1);
5697 resolver_->DeregisterResolveContext(&resolve_context2);
5698 }
5699
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_Stale)5700 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_Stale) {
5701 ChangeDnsConfig(CreateValidDnsConfig());
5702 DnsConfigOverrides overrides;
5703 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5704 resolver_->SetDnsConfigOverrides(overrides);
5705
5706 // Populate cache with insecure entry.
5707 HostCache::Key cached_stale_key = HostCache::Key(
5708 "automatic_stale", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5709 HostResolverSource::ANY, NetworkIsolationKey());
5710 IPEndPoint kExpectedStaleIP = CreateExpected("192.168.1.102", 80);
5711 PopulateCache(cached_stale_key, kExpectedStaleIP);
5712 MakeCacheStale();
5713
5714 HostResolver::ResolveHostParameters stale_allowed_parameters;
5715 stale_allowed_parameters.cache_usage =
5716 HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
5717
5718 // The insecure cache should be checked before secure requests are made since
5719 // stale results are allowed.
5720 ResolveHostResponseHelper response_stale(resolver_->CreateRequest(
5721 HostPortPair("automatic_stale", 80), NetworkIsolationKey(),
5722 NetLogWithSource(), stale_allowed_parameters, resolve_context_.get(),
5723 resolve_context_->host_cache()));
5724 EXPECT_THAT(response_stale.result_error(), IsOk());
5725 EXPECT_FALSE(
5726 response_stale.request()->GetResolveErrorInfo().is_secure_network_error);
5727 EXPECT_THAT(response_stale.request()->GetAddressResults().value().endpoints(),
5728 testing::ElementsAre(kExpectedStaleIP));
5729 EXPECT_TRUE(response_stale.request()->GetStaleInfo()->is_stale());
5730 }
5731
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_InsecureAsyncDisabled)5732 TEST_F(HostResolverManagerDnsTest,
5733 SecureDnsMode_Automatic_InsecureAsyncDisabled) {
5734 proc_->AddRuleForAllFamilies("insecure_automatic", "192.168.1.100");
5735 ChangeDnsConfig(CreateValidDnsConfig());
5736 resolver_->SetInsecureDnsClientEnabled(false);
5737 DnsConfigOverrides overrides;
5738 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5739 resolver_->SetDnsConfigOverrides(overrides);
5740
5741 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5742
5743 // The secure part of the dns client should be enabled.
5744 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5745 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5746 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5747 ASSERT_THAT(response_secure.result_error(), IsOk());
5748 EXPECT_THAT(
5749 response_secure.request()->GetAddressResults().value().endpoints(),
5750 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5751 CreateExpected("::1", 80)));
5752 HostCache::Key secure_key = HostCache::Key(
5753 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5754 HostResolverSource::ANY, NetworkIsolationKey());
5755 secure_key.secure = true;
5756 cache_result = GetCacheHit(secure_key);
5757 EXPECT_TRUE(!!cache_result);
5758
5759 // The insecure part of the dns client is disabled so insecure requests
5760 // should be skipped.
5761 ResolveHostResponseHelper response_insecure(resolver_->CreateRequest(
5762 HostPortPair("insecure_automatic", 80), NetworkIsolationKey(),
5763 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5764 resolve_context_->host_cache()));
5765 proc_->SignalMultiple(1u);
5766 ASSERT_THAT(response_insecure.result_error(), IsOk());
5767 EXPECT_THAT(
5768 response_insecure.request()->GetAddressResults().value().endpoints(),
5769 testing::ElementsAre(CreateExpected("192.168.1.100", 80)));
5770 HostCache::Key insecure_key =
5771 HostCache::Key("insecure_automatic", DnsQueryType::UNSPECIFIED,
5772 0 /* host_resolver_flags */, HostResolverSource::ANY,
5773 NetworkIsolationKey());
5774 cache_result = GetCacheHit(insecure_key);
5775 EXPECT_TRUE(!!cache_result);
5776
5777 HostCache::Key cached_insecure_key =
5778 HostCache::Key("insecure_automatic_cached", DnsQueryType::UNSPECIFIED,
5779 0 /* host_resolver_flags */, HostResolverSource::ANY,
5780 NetworkIsolationKey());
5781 IPEndPoint kExpectedInsecureIP = CreateExpected("192.168.1.101", 80);
5782 PopulateCache(cached_insecure_key, kExpectedInsecureIP);
5783
5784 // The insecure cache should still be checked even if the insecure part of
5785 // the dns client is disabled.
5786 ResolveHostResponseHelper response_insecure_cached(resolver_->CreateRequest(
5787 HostPortPair("insecure_automatic_cached", 80), NetworkIsolationKey(),
5788 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5789 resolve_context_->host_cache()));
5790 EXPECT_THAT(response_insecure_cached.result_error(), IsOk());
5791 EXPECT_THAT(response_insecure_cached.request()
5792 ->GetAddressResults()
5793 .value()
5794 .endpoints(),
5795 testing::ElementsAre(kExpectedInsecureIP));
5796 }
5797
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Automatic_DotActive)5798 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Automatic_DotActive) {
5799 proc_->AddRuleForAllFamilies("insecure_automatic", "192.168.1.100");
5800 DnsConfig config = CreateValidDnsConfig();
5801 config.dns_over_tls_active = true;
5802 ChangeDnsConfig(config);
5803 DnsConfigOverrides overrides;
5804 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
5805 resolver_->SetDnsConfigOverrides(overrides);
5806
5807 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5808
5809 // The secure part of the dns client should be enabled.
5810 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5811 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5812 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5813 ASSERT_THAT(response_secure.result_error(), IsOk());
5814 EXPECT_THAT(
5815 response_secure.request()->GetAddressResults().value().endpoints(),
5816 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
5817 CreateExpected("::1", 80)));
5818 HostCache::Key secure_key = HostCache::Key(
5819 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5820 HostResolverSource::ANY, NetworkIsolationKey());
5821 secure_key.secure = true;
5822 cache_result = GetCacheHit(secure_key);
5823 EXPECT_TRUE(!!cache_result);
5824
5825 // Insecure async requests should be skipped since the system resolver
5826 // requests will be secure.
5827 ResolveHostResponseHelper response_insecure(resolver_->CreateRequest(
5828 HostPortPair("insecure_automatic", 80), NetworkIsolationKey(),
5829 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5830 resolve_context_->host_cache()));
5831 proc_->SignalMultiple(1u);
5832 ASSERT_THAT(response_insecure.result_error(), IsOk());
5833 EXPECT_FALSE(response_insecure.request()
5834 ->GetResolveErrorInfo()
5835 .is_secure_network_error);
5836 EXPECT_THAT(
5837 response_insecure.request()->GetAddressResults().value().endpoints(),
5838 testing::ElementsAre(CreateExpected("192.168.1.100", 80)));
5839 HostCache::Key insecure_key =
5840 HostCache::Key("insecure_automatic", DnsQueryType::UNSPECIFIED,
5841 0 /* host_resolver_flags */, HostResolverSource::ANY,
5842 NetworkIsolationKey());
5843 cache_result = GetCacheHit(insecure_key);
5844 EXPECT_TRUE(!!cache_result);
5845
5846 HostCache::Key cached_insecure_key =
5847 HostCache::Key("insecure_automatic_cached", DnsQueryType::UNSPECIFIED,
5848 0 /* host_resolver_flags */, HostResolverSource::ANY,
5849 NetworkIsolationKey());
5850 IPEndPoint kExpectedInsecureIP = CreateExpected("192.168.1.101", 80);
5851 PopulateCache(cached_insecure_key, kExpectedInsecureIP);
5852
5853 // The insecure cache should still be checked.
5854 ResolveHostResponseHelper response_insecure_cached(resolver_->CreateRequest(
5855 HostPortPair("insecure_automatic_cached", 80), NetworkIsolationKey(),
5856 NetLogWithSource(), base::nullopt, resolve_context_.get(),
5857 resolve_context_->host_cache()));
5858 EXPECT_THAT(response_insecure_cached.result_error(), IsOk());
5859 EXPECT_FALSE(response_insecure_cached.request()
5860 ->GetResolveErrorInfo()
5861 .is_secure_network_error);
5862 EXPECT_THAT(response_insecure_cached.request()
5863 ->GetAddressResults()
5864 .value()
5865 .endpoints(),
5866 testing::ElementsAre(kExpectedInsecureIP));
5867 }
5868
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Secure)5869 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Secure) {
5870 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.100");
5871 set_allow_fallback_to_proctask(true);
5872
5873 ChangeDnsConfig(CreateValidDnsConfig());
5874 DnsConfigOverrides overrides;
5875 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
5876 resolver_->SetDnsConfigOverrides(overrides);
5877 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5878
5879 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5880 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5881 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5882 ASSERT_THAT(response_secure.result_error(), IsOk());
5883 EXPECT_FALSE(
5884 response_secure.request()->GetResolveErrorInfo().is_secure_network_error);
5885 HostCache::Key secure_key = HostCache::Key(
5886 "secure", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5887 HostResolverSource::ANY, NetworkIsolationKey());
5888 secure_key.secure = true;
5889 cache_result = GetCacheHit(secure_key);
5890 EXPECT_TRUE(!!cache_result);
5891
5892 ResolveHostResponseHelper response_insecure(resolver_->CreateRequest(
5893 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
5894 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5895 ASSERT_THAT(response_insecure.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
5896 EXPECT_TRUE(response_insecure.request()
5897 ->GetResolveErrorInfo()
5898 .is_secure_network_error);
5899 HostCache::Key insecure_key = HostCache::Key(
5900 "ok", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5901 HostResolverSource::ANY, NetworkIsolationKey());
5902 cache_result = GetCacheHit(insecure_key);
5903 EXPECT_FALSE(!!cache_result);
5904
5905 // Fallback to ProcTask not allowed in SECURE mode.
5906 ResolveHostResponseHelper response_proc(resolver_->CreateRequest(
5907 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
5908 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5909 proc_->SignalMultiple(1u);
5910 EXPECT_THAT(response_proc.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
5911 EXPECT_TRUE(
5912 response_proc.request()->GetResolveErrorInfo().is_secure_network_error);
5913 }
5914
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Secure_InsecureAsyncDisabled)5915 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Secure_InsecureAsyncDisabled) {
5916 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.100");
5917 set_allow_fallback_to_proctask(true);
5918 resolver_->SetInsecureDnsClientEnabled(false);
5919
5920 ChangeDnsConfig(CreateValidDnsConfig());
5921 DnsConfigOverrides overrides;
5922 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
5923 resolver_->SetDnsConfigOverrides(overrides);
5924 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
5925
5926 // The secure part of the dns client should be enabled.
5927 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
5928 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5929 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5930 ASSERT_THAT(response_secure.result_error(), IsOk());
5931 HostCache::Key secure_key = HostCache::Key(
5932 "secure", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5933 HostResolverSource::ANY, NetworkIsolationKey());
5934 secure_key.secure = true;
5935 cache_result = GetCacheHit(secure_key);
5936 EXPECT_TRUE(!!cache_result);
5937 }
5938
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Secure_Local_CacheMiss)5939 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Secure_Local_CacheMiss) {
5940 ChangeDnsConfig(CreateValidDnsConfig());
5941 DnsConfigOverrides overrides;
5942 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
5943 resolver_->SetDnsConfigOverrides(overrides);
5944
5945 HostResolver::ResolveHostParameters source_none_parameters;
5946 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
5947
5948 // Populate cache with an insecure entry.
5949 HostCache::Key cached_insecure_key = HostCache::Key(
5950 "automatic", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5951 HostResolverSource::ANY, NetworkIsolationKey());
5952 IPEndPoint kExpectedInsecureIP = CreateExpected("192.168.1.102", 80);
5953 PopulateCache(cached_insecure_key, kExpectedInsecureIP);
5954
5955 // NONE query expected to complete synchronously with a cache miss since
5956 // the insecure cache should not be checked.
5957 ResolveHostResponseHelper cache_miss_request(resolver_->CreateRequest(
5958 HostPortPair("automatic", 80), NetworkIsolationKey(), NetLogWithSource(),
5959 source_none_parameters, resolve_context_.get(),
5960 resolve_context_->host_cache()));
5961 EXPECT_TRUE(cache_miss_request.complete());
5962 EXPECT_THAT(cache_miss_request.result_error(), IsError(ERR_DNS_CACHE_MISS));
5963 EXPECT_FALSE(cache_miss_request.request()
5964 ->GetResolveErrorInfo()
5965 .is_secure_network_error);
5966 EXPECT_FALSE(cache_miss_request.request()->GetAddressResults());
5967 EXPECT_FALSE(cache_miss_request.request()->GetStaleInfo());
5968 }
5969
TEST_F(HostResolverManagerDnsTest,SecureDnsMode_Secure_Local_CacheHit)5970 TEST_F(HostResolverManagerDnsTest, SecureDnsMode_Secure_Local_CacheHit) {
5971 ChangeDnsConfig(CreateValidDnsConfig());
5972 DnsConfigOverrides overrides;
5973 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
5974 resolver_->SetDnsConfigOverrides(overrides);
5975
5976 HostResolver::ResolveHostParameters source_none_parameters;
5977 source_none_parameters.source = HostResolverSource::LOCAL_ONLY;
5978
5979 // Populate cache with a secure entry.
5980 HostCache::Key cached_secure_key = HostCache::Key(
5981 "secure", DnsQueryType::UNSPECIFIED, 0 /* host_resolver_flags */,
5982 HostResolverSource::ANY, NetworkIsolationKey());
5983 cached_secure_key.secure = true;
5984 IPEndPoint kExpectedSecureIP = CreateExpected("192.168.1.103", 80);
5985 PopulateCache(cached_secure_key, kExpectedSecureIP);
5986
5987 // NONE query expected to complete synchronously with a cache hit from the
5988 // secure cache.
5989 ResolveHostResponseHelper response_cached(resolver_->CreateRequest(
5990 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
5991 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
5992 EXPECT_TRUE(response_cached.complete());
5993 EXPECT_THAT(response_cached.result_error(), IsOk());
5994 EXPECT_FALSE(
5995 response_cached.request()->GetResolveErrorInfo().is_secure_network_error);
5996 EXPECT_THAT(
5997 response_cached.request()->GetAddressResults().value().endpoints(),
5998 testing::ElementsAre(kExpectedSecureIP));
5999 }
6000
6001 // Test the case where only a single transaction slot is available.
TEST_F(HostResolverManagerDnsTest,SerialResolver)6002 TEST_F(HostResolverManagerDnsTest, SerialResolver) {
6003 CreateSerialResolver();
6004 set_allow_fallback_to_proctask(false);
6005 ChangeDnsConfig(CreateValidDnsConfig());
6006
6007 ResolveHostResponseHelper response(resolver_->CreateRequest(
6008 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6009 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6010 EXPECT_FALSE(response.complete());
6011 EXPECT_EQ(1u, num_running_dispatcher_jobs());
6012
6013 base::RunLoop().RunUntilIdle();
6014 EXPECT_TRUE(response.complete());
6015 EXPECT_THAT(response.result_error(), IsOk());
6016 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
6017 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
6018 CreateExpected("::1", 80)));
6019 }
6020
6021 // Test the case where subsequent transactions are handled on transaction
6022 // completion when only part of a multi-transaction request could be initially
6023 // started.
TEST_F(HostResolverManagerDnsTest,AAAAStartsAfterOtherJobFinishes)6024 TEST_F(HostResolverManagerDnsTest, AAAAStartsAfterOtherJobFinishes) {
6025 CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()),
6026 true /* ipv6_reachable */,
6027 true /* check_ipv6_on_wifi */);
6028 set_allow_fallback_to_proctask(false);
6029 ChangeDnsConfig(CreateValidDnsConfig());
6030
6031 ResolveHostResponseHelper response0(resolver_->CreateRequest(
6032 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6033 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6034 EXPECT_EQ(2u, num_running_dispatcher_jobs());
6035 ResolveHostResponseHelper response1(resolver_->CreateRequest(
6036 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6037 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6038 EXPECT_EQ(3u, num_running_dispatcher_jobs());
6039
6040 // Request 0's transactions should complete, starting Request 1's second
6041 // transaction, which should also complete.
6042 base::RunLoop().RunUntilIdle();
6043 EXPECT_EQ(1u, num_running_dispatcher_jobs());
6044 EXPECT_TRUE(response0.complete());
6045 EXPECT_FALSE(response1.complete());
6046
6047 dns_client_->CompleteDelayedTransactions();
6048 EXPECT_THAT(response1.result_error(), IsOk());
6049 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
6050 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
6051 CreateExpected("::1", 80)));
6052 }
6053
6054 // Tests the case that a Job with a single transaction receives an empty address
6055 // list, triggering fallback to ProcTask.
TEST_F(HostResolverManagerDnsTest,IPv4EmptyFallback)6056 TEST_F(HostResolverManagerDnsTest, IPv4EmptyFallback) {
6057 // Disable ipv6 to ensure we'll only try a single transaction for the host.
6058 CreateResolverWithLimitsAndParams(kMaxJobs, DefaultParams(proc_.get()),
6059 false /* ipv6_reachable */,
6060 true /* check_ipv6_on_wifi */);
6061 DnsConfig config = CreateValidDnsConfig();
6062 config.use_local_ipv6 = false;
6063 ChangeDnsConfig(config);
6064
6065 proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1",
6066 HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
6067 proc_->SignalMultiple(1u);
6068
6069 ResolveHostResponseHelper response(resolver_->CreateRequest(
6070 HostPortPair("empty_fallback", 80), NetworkIsolationKey(),
6071 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6072 resolve_context_->host_cache()));
6073 EXPECT_THAT(response.result_error(), IsOk());
6074 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
6075 testing::ElementsAre(CreateExpected("192.168.0.1", 80)));
6076 }
6077
6078 // Tests the case that a Job with two transactions receives two empty address
6079 // lists, triggering fallback to ProcTask.
TEST_F(HostResolverManagerDnsTest,UnspecEmptyFallback)6080 TEST_F(HostResolverManagerDnsTest, UnspecEmptyFallback) {
6081 ChangeDnsConfig(CreateValidDnsConfig());
6082 proc_->AddRuleForAllFamilies("empty_fallback", "192.168.0.1");
6083 proc_->SignalMultiple(1u);
6084
6085 ResolveHostResponseHelper response(resolver_->CreateRequest(
6086 HostPortPair("empty_fallback", 80), NetworkIsolationKey(),
6087 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6088 resolve_context_->host_cache()));
6089
6090 EXPECT_THAT(response.result_error(), IsOk());
6091 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
6092 testing::ElementsAre(CreateExpected("192.168.0.1", 80)));
6093 }
6094
6095 // Tests getting a new invalid DnsConfig while there are active DnsTasks.
TEST_F(HostResolverManagerDnsTest,InvalidDnsConfigWithPendingRequests)6096 TEST_F(HostResolverManagerDnsTest, InvalidDnsConfigWithPendingRequests) {
6097 // At most 3 jobs active at once. This number is important, since we want
6098 // to make sure that aborting the first HostResolverManager::Job does not
6099 // trigger another DnsTransaction on the second Job when it releases its
6100 // second prioritized dispatcher slot.
6101 CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()),
6102 true /* ipv6_reachable */,
6103 true /* check_ipv6_on_wifi */);
6104
6105 ChangeDnsConfig(CreateValidDnsConfig());
6106
6107 proc_->AddRuleForAllFamilies("slow_nx1", "192.168.0.1");
6108 proc_->AddRuleForAllFamilies("slow_nx2", "192.168.0.2");
6109 proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
6110
6111 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
6112 // First active job gets two slots.
6113 responses.emplace_back(
6114 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6115 HostPortPair("slow_nx1", 80), NetworkIsolationKey(),
6116 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6117 resolve_context_->host_cache())));
6118 // Next job gets one slot, and waits on another.
6119 responses.emplace_back(
6120 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6121 HostPortPair("slow_nx2", 80), NetworkIsolationKey(),
6122 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6123 resolve_context_->host_cache())));
6124 responses.emplace_back(
6125 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6126 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6127 base::nullopt, resolve_context_.get(),
6128 resolve_context_->host_cache())));
6129
6130 EXPECT_EQ(3u, num_running_dispatcher_jobs());
6131 for (auto& response : responses) {
6132 EXPECT_FALSE(response->complete());
6133 }
6134
6135 // Clear DNS config. Fully in-progress, partially in-progress, and queued
6136 // requests should all be aborted.
6137 InvalidateDnsConfig();
6138 for (auto& response : responses) {
6139 EXPECT_THAT(response->result_error(), IsError(ERR_NETWORK_CHANGED));
6140 }
6141 }
6142
6143 // Test that initial DNS config read signals do not abort pending requests
6144 // when using DnsClient.
TEST_F(HostResolverManagerDnsTest,DontAbortOnInitialDNSConfigRead)6145 TEST_F(HostResolverManagerDnsTest, DontAbortOnInitialDNSConfigRead) {
6146 // DnsClient is enabled, but there's no DnsConfig, so the request should start
6147 // using ProcTask.
6148 ResolveHostResponseHelper response(resolver_->CreateRequest(
6149 HostPortPair("host1", 70), NetworkIsolationKey(), NetLogWithSource(),
6150 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6151 EXPECT_FALSE(response.complete());
6152
6153 EXPECT_TRUE(proc_->WaitFor(1u));
6154 // Send the initial config read signal, with a valid config.
6155 SetInitialDnsConfig(CreateValidDnsConfig());
6156 proc_->SignalAll();
6157
6158 EXPECT_THAT(response.result_error(), IsOk());
6159 }
6160
6161 // Tests the case that the insecure part of the DnsClient is automatically
6162 // disabled due to failures while there are active DnsTasks.
TEST_F(HostResolverManagerDnsTest,AutomaticallyDisableInsecureDnsClientWithPendingRequests)6163 TEST_F(HostResolverManagerDnsTest,
6164 AutomaticallyDisableInsecureDnsClientWithPendingRequests) {
6165 // Trying different limits is important for this test: Different limits
6166 // result in different behavior when aborting in-progress DnsTasks. Having
6167 // a DnsTask that has one job active and one in the queue when another job
6168 // occupying two slots has its DnsTask aborted is the case most likely to run
6169 // into problems. Try limits between [1, 2 * # of non failure requests].
6170 for (size_t limit = 1u; limit < 10u; ++limit) {
6171 CreateResolverWithLimitsAndParams(limit, DefaultParams(proc_.get()),
6172 true /* ipv6_reachable */,
6173 true /* check_ipv6_on_wifi */);
6174
6175 ChangeDnsConfig(CreateValidDnsConfig());
6176
6177 // Queue up enough failures to disable insecure DnsTasks. These will all
6178 // fall back to ProcTasks, and succeed there.
6179 std::vector<std::unique_ptr<ResolveHostResponseHelper>> failure_responses;
6180 for (unsigned i = 0u; i < maximum_insecure_dns_task_failures(); ++i) {
6181 std::string host = base::StringPrintf("nx%u", i);
6182 proc_->AddRuleForAllFamilies(host, "192.168.0.1");
6183 failure_responses.emplace_back(
6184 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6185 HostPortPair(host, 80), NetworkIsolationKey(), NetLogWithSource(),
6186 base::nullopt, resolve_context_.get(),
6187 resolve_context_->host_cache())));
6188 EXPECT_FALSE(failure_responses[i]->complete());
6189 }
6190
6191 // These requests should all bypass insecure DnsTasks, due to the above
6192 // failures, so should end up using ProcTasks.
6193 proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.2");
6194 ResolveHostResponseHelper response0(resolver_->CreateRequest(
6195 HostPortPair("slow_ok1", 80), NetworkIsolationKey(), NetLogWithSource(),
6196 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6197 EXPECT_FALSE(response0.complete());
6198 proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.3");
6199 ResolveHostResponseHelper response1(resolver_->CreateRequest(
6200 HostPortPair("slow_ok2", 80), NetworkIsolationKey(), NetLogWithSource(),
6201 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6202 EXPECT_FALSE(response1.complete());
6203 proc_->AddRuleForAllFamilies("slow_ok3", "192.168.0.4");
6204 ResolveHostResponseHelper response2(resolver_->CreateRequest(
6205 HostPortPair("slow_ok3", 80), NetworkIsolationKey(), NetLogWithSource(),
6206 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6207 EXPECT_FALSE(response2.complete());
6208
6209 // Requests specifying DNS source cannot fallback to ProcTask, so they
6210 // should be unaffected.
6211 HostResolver::ResolveHostParameters parameters;
6212 parameters.source = HostResolverSource::DNS;
6213 ResolveHostResponseHelper response_dns(resolver_->CreateRequest(
6214 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6215 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6216 EXPECT_FALSE(response_dns.complete());
6217
6218 // Requests specifying SYSTEM source should be unaffected by disabling
6219 // DnsClient.
6220 proc_->AddRuleForAllFamilies("nx_ok", "192.168.0.5");
6221 parameters.source = HostResolverSource::SYSTEM;
6222 ResolveHostResponseHelper response_system(resolver_->CreateRequest(
6223 HostPortPair("nx_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6224 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6225 EXPECT_FALSE(response_system.complete());
6226
6227 // Secure DnsTasks should not be affected.
6228 HostResolver::ResolveHostParameters secure_parameters;
6229 secure_parameters.secure_dns_mode_override =
6230 DnsConfig::SecureDnsMode::AUTOMATIC;
6231 ResolveHostResponseHelper response_secure(resolver_->CreateRequest(
6232 HostPortPair("automatic", 80), NetworkIsolationKey(),
6233 NetLogWithSource(), secure_parameters, resolve_context_.get(),
6234 resolve_context_->host_cache()));
6235 EXPECT_FALSE(response_secure.complete());
6236
6237 proc_->SignalMultiple(maximum_insecure_dns_task_failures() + 4);
6238
6239 for (size_t i = 0u; i < maximum_insecure_dns_task_failures(); ++i) {
6240 EXPECT_THAT(failure_responses[i]->result_error(), IsOk());
6241 EXPECT_THAT(failure_responses[i]
6242 ->request()
6243 ->GetAddressResults()
6244 .value()
6245 .endpoints(),
6246 testing::ElementsAre(CreateExpected("192.168.0.1", 80)));
6247 }
6248
6249 EXPECT_THAT(response0.result_error(), IsOk());
6250 EXPECT_THAT(response0.request()->GetAddressResults().value().endpoints(),
6251 testing::ElementsAre(CreateExpected("192.168.0.2", 80)));
6252 EXPECT_THAT(response1.result_error(), IsOk());
6253 EXPECT_THAT(response1.request()->GetAddressResults().value().endpoints(),
6254 testing::ElementsAre(CreateExpected("192.168.0.3", 80)));
6255 EXPECT_THAT(response2.result_error(), IsOk());
6256 EXPECT_THAT(response2.request()->GetAddressResults().value().endpoints(),
6257 testing::ElementsAre(CreateExpected("192.168.0.4", 80)));
6258
6259 dns_client_->CompleteDelayedTransactions();
6260 EXPECT_THAT(response_dns.result_error(), IsOk());
6261
6262 EXPECT_THAT(response_system.result_error(), IsOk());
6263 EXPECT_THAT(
6264 response_system.request()->GetAddressResults().value().endpoints(),
6265 testing::ElementsAre(CreateExpected("192.168.0.5", 80)));
6266
6267 EXPECT_THAT(response_secure.result_error(), IsOk());
6268 }
6269 }
6270
6271 // Tests a call to SetDnsClient while there are active DnsTasks.
TEST_F(HostResolverManagerDnsTest,ManuallyDisableDnsClientWithPendingRequests)6272 TEST_F(HostResolverManagerDnsTest,
6273 ManuallyDisableDnsClientWithPendingRequests) {
6274 // At most 3 jobs active at once. This number is important, since we want to
6275 // make sure that aborting the first HostResolverManager::Job does not trigger
6276 // another DnsTransaction on the second Job when it releases its second
6277 // prioritized dispatcher slot.
6278 CreateResolverWithLimitsAndParams(3u, DefaultParams(proc_.get()),
6279 true /* ipv6_reachable */,
6280 true /* check_ipv6_on_wifi */);
6281
6282 ChangeDnsConfig(CreateValidDnsConfig());
6283
6284 proc_->AddRuleForAllFamilies("slow_ok1", "192.168.0.1");
6285 proc_->AddRuleForAllFamilies("slow_ok2", "192.168.0.2");
6286 proc_->AddRuleForAllFamilies("ok", "192.168.0.3");
6287
6288 std::vector<std::unique_ptr<ResolveHostResponseHelper>> responses;
6289 // First active job gets two slots.
6290 responses.emplace_back(
6291 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6292 HostPortPair("slow_ok1", 80), NetworkIsolationKey(),
6293 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6294 resolve_context_->host_cache())));
6295 EXPECT_FALSE(responses[0]->complete());
6296 // Next job gets one slot, and waits on another.
6297 responses.emplace_back(
6298 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6299 HostPortPair("slow_ok2", 80), NetworkIsolationKey(),
6300 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6301 resolve_context_->host_cache())));
6302 EXPECT_FALSE(responses[1]->complete());
6303 // Next one is queued.
6304 responses.emplace_back(
6305 std::make_unique<ResolveHostResponseHelper>(resolver_->CreateRequest(
6306 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
6307 base::nullopt, resolve_context_.get(),
6308 resolve_context_->host_cache())));
6309 EXPECT_FALSE(responses[2]->complete());
6310
6311 EXPECT_EQ(3u, num_running_dispatcher_jobs());
6312
6313 // Clear DnsClient. The two in-progress jobs should fall back to a ProcTask,
6314 // and the next one should be started with a ProcTask.
6315 resolver_->SetInsecureDnsClientEnabled(false);
6316
6317 // All three in-progress requests should now be running a ProcTask.
6318 EXPECT_EQ(3u, num_running_dispatcher_jobs());
6319 proc_->SignalMultiple(3u);
6320
6321 for (auto& response : responses) {
6322 EXPECT_THAT(response->result_error(), IsOk());
6323 }
6324 EXPECT_THAT(responses[0]->request()->GetAddressResults().value().endpoints(),
6325 testing::ElementsAre(CreateExpected("192.168.0.1", 80)));
6326 EXPECT_THAT(responses[1]->request()->GetAddressResults().value().endpoints(),
6327 testing::ElementsAre(CreateExpected("192.168.0.2", 80)));
6328 EXPECT_THAT(responses[2]->request()->GetAddressResults().value().endpoints(),
6329 testing::ElementsAre(CreateExpected("192.168.0.3", 80)));
6330 }
6331
6332 // When explicitly requesting source=DNS, no fallback allowed, so doing so with
6333 // DnsClient disabled should result in an error.
TEST_F(HostResolverManagerDnsTest,DnsCallsWithDisabledDnsClient)6334 TEST_F(HostResolverManagerDnsTest, DnsCallsWithDisabledDnsClient) {
6335 ChangeDnsConfig(CreateValidDnsConfig());
6336 resolver_->SetInsecureDnsClientEnabled(false);
6337
6338 HostResolver::ResolveHostParameters params;
6339 params.source = HostResolverSource::DNS;
6340 ResolveHostResponseHelper response(resolver_->CreateRequest(
6341 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
6342 params, resolve_context_.get(), resolve_context_->host_cache()));
6343
6344 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_CACHE_MISS));
6345 }
6346
TEST_F(HostResolverManagerDnsTest,DnsCallsWithDisabledDnsClient_DisabledAtConstruction)6347 TEST_F(HostResolverManagerDnsTest,
6348 DnsCallsWithDisabledDnsClient_DisabledAtConstruction) {
6349 HostResolver::ManagerOptions options = DefaultOptions();
6350 options.insecure_dns_client_enabled = false;
6351 CreateResolverWithOptionsAndParams(std::move(options),
6352 DefaultParams(proc_.get()),
6353 true /* ipv6_reachable */);
6354 ChangeDnsConfig(CreateValidDnsConfig());
6355
6356 HostResolver::ResolveHostParameters params;
6357 params.source = HostResolverSource::DNS;
6358 ResolveHostResponseHelper response(resolver_->CreateRequest(
6359 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
6360 params, resolve_context_.get(), resolve_context_->host_cache()));
6361
6362 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_CACHE_MISS));
6363 }
6364
6365 // Same as DnsClient disabled, requests with source=DNS and no usable DnsConfig
6366 // should result in an error.
TEST_F(HostResolverManagerDnsTest,DnsCallsWithNoDnsConfig)6367 TEST_F(HostResolverManagerDnsTest, DnsCallsWithNoDnsConfig) {
6368 InvalidateDnsConfig();
6369
6370 HostResolver::ResolveHostParameters params;
6371 params.source = HostResolverSource::DNS;
6372 ResolveHostResponseHelper response(resolver_->CreateRequest(
6373 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
6374 params, resolve_context_.get(), resolve_context_->host_cache()));
6375
6376 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_CACHE_MISS));
6377 }
6378
TEST_F(HostResolverManagerDnsTest,NoCheckIpv6OnWifi)6379 TEST_F(HostResolverManagerDnsTest, NoCheckIpv6OnWifi) {
6380 // CreateSerialResolver will destroy the current resolver_ which will attempt
6381 // to remove itself from the NetworkChangeNotifier. If this happens after a
6382 // new NetworkChangeNotifier is active, then it will not remove itself from
6383 // the old NetworkChangeNotifier which is a potential use-after-free.
6384 DestroyResolver();
6385 test::ScopedMockNetworkChangeNotifier notifier;
6386 // Serial resolver to guarantee order of resolutions.
6387 CreateSerialResolver(false /* check_ipv6_on_wifi */);
6388
6389 notifier.mock_network_change_notifier()->SetConnectionType(
6390 NetworkChangeNotifier::CONNECTION_WIFI);
6391 // Needed so IPv6 availability check isn't skipped.
6392 ChangeDnsConfig(CreateValidDnsConfig());
6393
6394 proc_->AddRule("h1", ADDRESS_FAMILY_UNSPECIFIED, "::3");
6395 proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1");
6396 proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1",
6397 HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6);
6398 proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2");
6399
6400 ResolveHostResponseHelper response(resolver_->CreateRequest(
6401 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6402 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6403 HostResolver::ResolveHostParameters parameters;
6404 parameters.dns_query_type = DnsQueryType::A;
6405 ResolveHostResponseHelper v4_response(resolver_->CreateRequest(
6406 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6407 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6408 parameters.dns_query_type = DnsQueryType::AAAA;
6409 ResolveHostResponseHelper v6_response(resolver_->CreateRequest(
6410 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6411 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6412
6413 proc_->SignalMultiple(3u);
6414
6415 // Should revert to only IPV4 request.
6416 EXPECT_THAT(response.result_error(), IsOk());
6417 EXPECT_THAT(response.request()->GetAddressResults().value().endpoints(),
6418 testing::ElementsAre(CreateExpected("1.0.0.1", 80)));
6419
6420 EXPECT_THAT(v4_response.result_error(), IsOk());
6421 EXPECT_THAT(v4_response.request()->GetAddressResults().value().endpoints(),
6422 testing::ElementsAre(CreateExpected("1.0.0.1", 80)));
6423 EXPECT_THAT(v6_response.result_error(), IsOk());
6424 EXPECT_THAT(v6_response.request()->GetAddressResults().value().endpoints(),
6425 testing::ElementsAre(CreateExpected("::2", 80)));
6426
6427 // Now repeat the test on non-wifi to check that IPv6 is used as normal
6428 // after the network changes.
6429 notifier.mock_network_change_notifier()->SetConnectionType(
6430 NetworkChangeNotifier::CONNECTION_4G);
6431 base::RunLoop().RunUntilIdle(); // Wait for NetworkChangeNotifier.
6432
6433 ResolveHostResponseHelper no_wifi_response(resolver_->CreateRequest(
6434 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6435 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6436 parameters.dns_query_type = DnsQueryType::A;
6437 ResolveHostResponseHelper no_wifi_v4_response(resolver_->CreateRequest(
6438 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6439 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6440 parameters.dns_query_type = DnsQueryType::AAAA;
6441 ResolveHostResponseHelper no_wifi_v6_response(resolver_->CreateRequest(
6442 HostPortPair("h1", 80), NetworkIsolationKey(), NetLogWithSource(),
6443 parameters, resolve_context_.get(), resolve_context_->host_cache()));
6444
6445 proc_->SignalMultiple(3u);
6446
6447 // IPV6 should be available.
6448 EXPECT_THAT(no_wifi_response.result_error(), IsOk());
6449 EXPECT_THAT(
6450 no_wifi_response.request()->GetAddressResults().value().endpoints(),
6451 testing::ElementsAre(CreateExpected("::3", 80)));
6452
6453 EXPECT_THAT(no_wifi_v4_response.result_error(), IsOk());
6454 EXPECT_THAT(
6455 no_wifi_v4_response.request()->GetAddressResults().value().endpoints(),
6456 testing::ElementsAre(CreateExpected("1.0.0.1", 80)));
6457 EXPECT_THAT(no_wifi_v6_response.result_error(), IsOk());
6458 EXPECT_THAT(
6459 no_wifi_v6_response.request()->GetAddressResults().value().endpoints(),
6460 testing::ElementsAre(CreateExpected("::2", 80)));
6461 }
6462
TEST_F(HostResolverManagerDnsTest,NotFoundTTL)6463 TEST_F(HostResolverManagerDnsTest, NotFoundTTL) {
6464 CreateResolver();
6465 set_allow_fallback_to_proctask(false);
6466 ChangeDnsConfig(CreateValidDnsConfig());
6467
6468 // NODATA
6469 ResolveHostResponseHelper no_data_response(resolver_->CreateRequest(
6470 HostPortPair("empty", 80), NetworkIsolationKey(), NetLogWithSource(),
6471 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6472 EXPECT_THAT(no_data_response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
6473 EXPECT_FALSE(no_data_response.request()->GetAddressResults());
6474 HostCache::Key key("empty", DnsQueryType::UNSPECIFIED, 0,
6475 HostResolverSource::ANY, NetworkIsolationKey());
6476 HostCache::EntryStaleness staleness;
6477 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result =
6478 resolve_context_->host_cache()->Lookup(key, base::TimeTicks::Now(),
6479 false /* ignore_secure */);
6480 EXPECT_TRUE(!!cache_result);
6481 EXPECT_TRUE(cache_result->second.has_ttl());
6482 EXPECT_THAT(cache_result->second.ttl(), base::TimeDelta::FromSeconds(86400));
6483
6484 // NXDOMAIN
6485 ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
6486 HostPortPair("nodomain", 80), NetworkIsolationKey(), NetLogWithSource(),
6487 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6488 EXPECT_THAT(no_domain_response.result_error(),
6489 IsError(ERR_NAME_NOT_RESOLVED));
6490 EXPECT_FALSE(no_domain_response.request()->GetAddressResults());
6491 HostCache::Key nxkey("nodomain", DnsQueryType::UNSPECIFIED, 0,
6492 HostResolverSource::ANY, NetworkIsolationKey());
6493 cache_result = resolve_context_->host_cache()->Lookup(
6494 nxkey, base::TimeTicks::Now(), false /* ignore_secure */);
6495 EXPECT_TRUE(!!cache_result);
6496 EXPECT_TRUE(cache_result->second.has_ttl());
6497 EXPECT_THAT(cache_result->second.ttl(), base::TimeDelta::FromSeconds(86400));
6498 }
6499
TEST_F(HostResolverManagerDnsTest,CachedError)6500 TEST_F(HostResolverManagerDnsTest, CachedError) {
6501 proc_->AddRuleForAllFamilies(std::string(),
6502 "0.0.0.1"); // Default to failures.
6503 proc_->SignalMultiple(1u);
6504
6505 CreateResolver();
6506 set_allow_fallback_to_proctask(true);
6507 ChangeDnsConfig(CreateValidDnsConfig());
6508
6509 HostResolver::ResolveHostParameters cache_only_parameters;
6510 cache_only_parameters.source = HostResolverSource::LOCAL_ONLY;
6511
6512 // Expect cache initially empty.
6513 ResolveHostResponseHelper cache_miss_response0(resolver_->CreateRequest(
6514 HostPortPair("nodomain", 80), NetworkIsolationKey(), NetLogWithSource(),
6515 cache_only_parameters, resolve_context_.get(),
6516 resolve_context_->host_cache()));
6517 EXPECT_THAT(cache_miss_response0.result_error(), IsError(ERR_DNS_CACHE_MISS));
6518 EXPECT_FALSE(cache_miss_response0.request()->GetStaleInfo());
6519
6520 // The cache should not be populate with an error because fallback to ProcTask
6521 // was available.
6522 ResolveHostResponseHelper no_domain_response_with_fallback(
6523 resolver_->CreateRequest(HostPortPair("nodomain", 80),
6524 NetworkIsolationKey(), NetLogWithSource(),
6525 base::nullopt, resolve_context_.get(),
6526 resolve_context_->host_cache()));
6527 EXPECT_THAT(no_domain_response_with_fallback.result_error(),
6528 IsError(ERR_NAME_NOT_RESOLVED));
6529
6530 // Expect cache still empty.
6531 ResolveHostResponseHelper cache_miss_response1(resolver_->CreateRequest(
6532 HostPortPair("nodomain", 80), NetworkIsolationKey(), NetLogWithSource(),
6533 cache_only_parameters, resolve_context_.get(),
6534 resolve_context_->host_cache()));
6535 EXPECT_THAT(cache_miss_response1.result_error(), IsError(ERR_DNS_CACHE_MISS));
6536 EXPECT_FALSE(cache_miss_response1.request()->GetStaleInfo());
6537
6538 // Disable fallback to proctask
6539 set_allow_fallback_to_proctask(false);
6540
6541 // Populate cache with an error.
6542 ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
6543 HostPortPair("nodomain", 80), NetworkIsolationKey(), NetLogWithSource(),
6544 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6545 EXPECT_THAT(no_domain_response.result_error(),
6546 IsError(ERR_NAME_NOT_RESOLVED));
6547
6548 // Expect the error result can be resolved from the cache.
6549 ResolveHostResponseHelper cache_hit_response(resolver_->CreateRequest(
6550 HostPortPair("nodomain", 80), NetworkIsolationKey(), NetLogWithSource(),
6551 cache_only_parameters, resolve_context_.get(),
6552 resolve_context_->host_cache()));
6553 EXPECT_THAT(cache_hit_response.result_error(),
6554 IsError(ERR_NAME_NOT_RESOLVED));
6555 EXPECT_FALSE(cache_hit_response.request()->GetStaleInfo().value().is_stale());
6556 }
6557
TEST_F(HostResolverManagerDnsTest,CachedError_AutomaticMode)6558 TEST_F(HostResolverManagerDnsTest, CachedError_AutomaticMode) {
6559 CreateResolver();
6560 set_allow_fallback_to_proctask(false);
6561 ChangeDnsConfig(CreateValidDnsConfig());
6562
6563 // Switch to automatic mode.
6564 DnsConfigOverrides overrides;
6565 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
6566 resolver_->SetDnsConfigOverrides(overrides);
6567
6568 HostCache::Key insecure_key =
6569 HostCache::Key("automatic_nodomain", DnsQueryType::UNSPECIFIED,
6570 0 /* host_resolver_flags */, HostResolverSource::ANY,
6571 NetworkIsolationKey());
6572 HostCache::Key secure_key =
6573 HostCache::Key("automatic_nodomain", DnsQueryType::UNSPECIFIED,
6574 0 /* host_resolver_flags */, HostResolverSource::ANY,
6575 NetworkIsolationKey());
6576 secure_key.secure = true;
6577
6578 // Expect cache initially empty.
6579 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
6580 cache_result = GetCacheHit(secure_key);
6581 EXPECT_FALSE(!!cache_result);
6582 cache_result = GetCacheHit(insecure_key);
6583 EXPECT_FALSE(!!cache_result);
6584
6585 // Populate both secure and insecure caches with an error.
6586 ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
6587 HostPortPair("automatic_nodomain", 80), NetworkIsolationKey(),
6588 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6589 resolve_context_->host_cache()));
6590 EXPECT_THAT(no_domain_response.result_error(),
6591 IsError(ERR_NAME_NOT_RESOLVED));
6592
6593 // Expect both secure and insecure caches to have the error result.
6594 cache_result = GetCacheHit(secure_key);
6595 EXPECT_TRUE(!!cache_result);
6596 cache_result = GetCacheHit(insecure_key);
6597 EXPECT_TRUE(!!cache_result);
6598 }
6599
TEST_F(HostResolverManagerDnsTest,CachedError_SecureMode)6600 TEST_F(HostResolverManagerDnsTest, CachedError_SecureMode) {
6601 CreateResolver();
6602 set_allow_fallback_to_proctask(false);
6603 ChangeDnsConfig(CreateValidDnsConfig());
6604
6605 // Switch to secure mode.
6606 DnsConfigOverrides overrides;
6607 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
6608 resolver_->SetDnsConfigOverrides(overrides);
6609
6610 HostCache::Key insecure_key =
6611 HostCache::Key("automatic_nodomain", DnsQueryType::UNSPECIFIED,
6612 0 /* host_resolver_flags */, HostResolverSource::ANY,
6613 NetworkIsolationKey());
6614 HostCache::Key secure_key =
6615 HostCache::Key("automatic_nodomain", DnsQueryType::UNSPECIFIED,
6616 0 /* host_resolver_flags */, HostResolverSource::ANY,
6617 NetworkIsolationKey());
6618 secure_key.secure = true;
6619
6620 // Expect cache initially empty.
6621 const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
6622 cache_result = GetCacheHit(secure_key);
6623 EXPECT_FALSE(!!cache_result);
6624 cache_result = GetCacheHit(insecure_key);
6625 EXPECT_FALSE(!!cache_result);
6626
6627 // Populate secure cache with an error.
6628 ResolveHostResponseHelper no_domain_response(resolver_->CreateRequest(
6629 HostPortPair("automatic_nodomain", 80), NetworkIsolationKey(),
6630 NetLogWithSource(), base::nullopt, resolve_context_.get(),
6631 resolve_context_->host_cache()));
6632 EXPECT_THAT(no_domain_response.result_error(),
6633 IsError(ERR_NAME_NOT_RESOLVED));
6634
6635 // Expect only the secure cache to have the error result.
6636 cache_result = GetCacheHit(secure_key);
6637 EXPECT_TRUE(!!cache_result);
6638 cache_result = GetCacheHit(insecure_key);
6639 EXPECT_FALSE(!!cache_result);
6640 }
6641
TEST_F(HostResolverManagerDnsTest,NoCanonicalName)6642 TEST_F(HostResolverManagerDnsTest, NoCanonicalName) {
6643 MockDnsClientRuleList rules;
6644 AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(),
6645 "canonical", false /* delay */);
6646 AddDnsRule(&rules, "alias", dns_protocol::kTypeAAAA,
6647 IPAddress::IPv6Localhost(), "canonical", false /* delay */);
6648
6649 CreateResolver();
6650 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
6651 set_allow_fallback_to_proctask(false);
6652
6653 ResolveHostResponseHelper response(resolver_->CreateRequest(
6654 HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(),
6655 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6656 ASSERT_THAT(response.result_error(), IsOk());
6657
6658 // HostResolver may still give name, but if so, it must be correct.
6659 std::string result_name =
6660 response.request()->GetAddressResults().value().canonical_name();
6661 EXPECT_TRUE(result_name.empty() || result_name == "canonical");
6662 }
6663
TEST_F(HostResolverManagerDnsTest,CanonicalName)6664 TEST_F(HostResolverManagerDnsTest, CanonicalName) {
6665 MockDnsClientRuleList rules;
6666 AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(),
6667 "canonical", false /* delay */);
6668 AddDnsRule(&rules, "alias", dns_protocol::kTypeAAAA,
6669 IPAddress::IPv6Localhost(), "canonical", false /* delay */);
6670
6671 CreateResolver();
6672 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
6673 set_allow_fallback_to_proctask(false);
6674
6675 HostResolver::ResolveHostParameters params;
6676 params.include_canonical_name = true;
6677 params.source = HostResolverSource::DNS;
6678 ResolveHostResponseHelper response(resolver_->CreateRequest(
6679 HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(),
6680 params, resolve_context_.get(), resolve_context_->host_cache()));
6681 ASSERT_THAT(response.result_error(), IsOk());
6682
6683 EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
6684 "canonical");
6685 }
6686
TEST_F(HostResolverManagerDnsTest,CanonicalName_PreferV6)6687 TEST_F(HostResolverManagerDnsTest, CanonicalName_PreferV6) {
6688 MockDnsClientRuleList rules;
6689 AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(),
6690 "wrong", false /* delay */);
6691 AddDnsRule(&rules, "alias", dns_protocol::kTypeAAAA,
6692 IPAddress::IPv6Localhost(), "correct", true /* delay */);
6693
6694 CreateResolver();
6695 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
6696 set_allow_fallback_to_proctask(false);
6697
6698 HostResolver::ResolveHostParameters params;
6699 params.include_canonical_name = true;
6700 params.source = HostResolverSource::DNS;
6701 ResolveHostResponseHelper response(resolver_->CreateRequest(
6702 HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(),
6703 params, resolve_context_.get(), resolve_context_->host_cache()));
6704 ASSERT_FALSE(response.complete());
6705 base::RunLoop().RunUntilIdle();
6706 dns_client_->CompleteDelayedTransactions();
6707 ASSERT_THAT(response.result_error(), IsOk());
6708 EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
6709 "correct");
6710 }
6711
TEST_F(HostResolverManagerDnsTest,CanonicalName_V4Only)6712 TEST_F(HostResolverManagerDnsTest, CanonicalName_V4Only) {
6713 MockDnsClientRuleList rules;
6714 AddDnsRule(&rules, "alias", dns_protocol::kTypeA, IPAddress::IPv4Localhost(),
6715 "correct", false /* delay */);
6716 CreateResolver();
6717 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
6718 set_allow_fallback_to_proctask(false);
6719
6720 HostResolver::ResolveHostParameters params;
6721 params.dns_query_type = DnsQueryType::A;
6722 params.include_canonical_name = true;
6723 params.source = HostResolverSource::DNS;
6724 ResolveHostResponseHelper response(resolver_->CreateRequest(
6725 HostPortPair("alias", 80), NetworkIsolationKey(), NetLogWithSource(),
6726 params, resolve_context_.get(), resolve_context_->host_cache()));
6727 ASSERT_THAT(response.result_error(), IsOk());
6728 EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
6729 "correct");
6730 }
6731
6732 // Test that without specifying source, a request that would otherwise be
6733 // handled by DNS is sent to the system resolver if cannonname is requested.
TEST_F(HostResolverManagerDnsTest,CanonicalNameForcesProc)6734 TEST_F(HostResolverManagerDnsTest, CanonicalNameForcesProc) {
6735 // Disable fallback to ensure system resolver is used directly, not via
6736 // fallback.
6737 set_allow_fallback_to_proctask(false);
6738
6739 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102",
6740 HOST_RESOLVER_CANONNAME, "canonical");
6741 proc_->SignalMultiple(1u);
6742
6743 ChangeDnsConfig(CreateValidDnsConfig());
6744
6745 HostResolver::ResolveHostParameters params;
6746 params.include_canonical_name = true;
6747 ResolveHostResponseHelper response(resolver_->CreateRequest(
6748 HostPortPair("nx_succeed", 80), NetworkIsolationKey(), NetLogWithSource(),
6749 params, resolve_context_.get(), resolve_context_->host_cache()));
6750 ASSERT_THAT(response.result_error(), IsOk());
6751
6752 EXPECT_EQ(response.request()->GetAddressResults().value().canonical_name(),
6753 "canonical");
6754 }
6755
TEST_F(HostResolverManagerDnsTest,SortsAndDeduplicatesAddresses)6756 TEST_F(HostResolverManagerDnsTest, SortsAndDeduplicatesAddresses) {
6757 MockDnsClientRuleList rules;
6758
6759 {
6760 std::vector<DnsResourceRecord> answers(
6761 3, BuildTestAddressRecord("duplicate", IPAddress::IPv4Localhost()));
6762 std::string dns_name;
6763 CHECK(DNSDomainFromDot("duplicate", &dns_name));
6764 base::Optional<DnsQuery> query(base::in_place, 0, dns_name,
6765 dns_protocol::kTypeA);
6766
6767 rules.emplace_back(
6768 "duplicate", dns_protocol::kTypeA, false /* secure */,
6769 MockDnsClientRule::Result(std::make_unique<DnsResponse>(
6770 0, false, std::move(answers),
6771 std::vector<DnsResourceRecord>() /* authority_records */,
6772 std::vector<DnsResourceRecord>() /* additional_records */, query)),
6773 false /* delay */);
6774 }
6775
6776 {
6777 std::vector<DnsResourceRecord> answers(
6778 3, BuildTestAddressRecord("duplicate", IPAddress::IPv6Localhost()));
6779 std::string dns_name;
6780 CHECK(DNSDomainFromDot("duplicate", &dns_name));
6781 base::Optional<DnsQuery> query(base::in_place, 0, dns_name,
6782 dns_protocol::kTypeAAAA);
6783
6784 rules.emplace_back(
6785 "duplicate", dns_protocol::kTypeAAAA, false /* secure */,
6786 MockDnsClientRule::Result(std::make_unique<DnsResponse>(
6787 0, false, std::move(answers),
6788 std::vector<DnsResourceRecord>() /* authority_records */,
6789 std::vector<DnsResourceRecord>() /* additional_records */, query)),
6790 false /* delay */);
6791 }
6792
6793 CreateResolver();
6794 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
6795
6796 ResolveHostResponseHelper response(resolver_->CreateRequest(
6797 HostPortPair("duplicate", 80), NetworkIsolationKey(), NetLogWithSource(),
6798 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
6799 ASSERT_THAT(response.result_error(), IsOk());
6800
6801 EXPECT_THAT(
6802 response.request()->GetAddressResults(),
6803 testing::Optional(testing::Property(
6804 &AddressList::endpoints,
6805 testing::ElementsAre(IPEndPoint(IPAddress::IPv6Localhost(), 80),
6806 IPEndPoint(IPAddress::IPv4Localhost(), 80)))));
6807 }
6808
TEST_F(HostResolverManagerTest,ResolveLocalHostname)6809 TEST_F(HostResolverManagerTest, ResolveLocalHostname) {
6810 AddressList addresses;
6811
6812 TestBothLoopbackIPs("localhost");
6813 TestBothLoopbackIPs("localhoST");
6814 TestBothLoopbackIPs("localhost.");
6815 TestBothLoopbackIPs("localhoST.");
6816 TestBothLoopbackIPs("localhost.localdomain");
6817 TestBothLoopbackIPs("localhost.localdomAIn");
6818 TestBothLoopbackIPs("localhost.localdomain.");
6819 TestBothLoopbackIPs("localhost.localdomAIn.");
6820 TestBothLoopbackIPs("foo.localhost");
6821 TestBothLoopbackIPs("foo.localhOSt");
6822 TestBothLoopbackIPs("foo.localhost.");
6823 TestBothLoopbackIPs("foo.localhOSt.");
6824
6825 TestIPv6LoopbackOnly("localhost6");
6826 TestIPv6LoopbackOnly("localhoST6");
6827 TestIPv6LoopbackOnly("localhost6.");
6828 TestIPv6LoopbackOnly("localhost6.localdomain6");
6829 TestIPv6LoopbackOnly("localhost6.localdomain6.");
6830
6831 EXPECT_FALSE(ResolveLocalHostname("127.0.0.1", &addresses));
6832 EXPECT_FALSE(ResolveLocalHostname("::1", &addresses));
6833 EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:1", &addresses));
6834 EXPECT_FALSE(ResolveLocalHostname("localhostx", &addresses));
6835 EXPECT_FALSE(ResolveLocalHostname("localhost.x", &addresses));
6836 EXPECT_FALSE(ResolveLocalHostname("foo.localdomain", &addresses));
6837 EXPECT_FALSE(ResolveLocalHostname("foo.localdomain.x", &addresses));
6838 EXPECT_FALSE(ResolveLocalHostname("localhost6x", &addresses));
6839 EXPECT_FALSE(ResolveLocalHostname("localhost.localdomain6", &addresses));
6840 EXPECT_FALSE(ResolveLocalHostname("localhost6.localdomain", &addresses));
6841 EXPECT_FALSE(ResolveLocalHostname("127.0.0.1.1", &addresses));
6842 EXPECT_FALSE(ResolveLocalHostname(".127.0.0.255", &addresses));
6843 EXPECT_FALSE(ResolveLocalHostname("::2", &addresses));
6844 EXPECT_FALSE(ResolveLocalHostname("::1:1", &addresses));
6845 EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:1:0:0:1", &addresses));
6846 EXPECT_FALSE(ResolveLocalHostname("::1:1", &addresses));
6847 EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", &addresses));
6848 EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", &addresses));
6849 EXPECT_FALSE(ResolveLocalHostname("foo.localhoste", &addresses));
6850 }
6851
TEST_F(HostResolverManagerDnsTest,AddDnsOverHttpsServerAfterConfig)6852 TEST_F(HostResolverManagerDnsTest, AddDnsOverHttpsServerAfterConfig) {
6853 DestroyResolver();
6854 test::ScopedMockNetworkChangeNotifier notifier;
6855 CreateSerialResolver(); // To guarantee order of resolutions.
6856 notifier.mock_network_change_notifier()->SetConnectionType(
6857 NetworkChangeNotifier::CONNECTION_WIFI);
6858 ChangeDnsConfig(CreateValidDnsConfig());
6859
6860 std::string server("https://dnsserver.example.net/dns-query{?dns}");
6861 DnsConfigOverrides overrides;
6862 overrides.dns_over_https_servers.emplace(
6863 {DnsOverHttpsServerConfig(server, true)});
6864 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
6865 resolver_->SetDnsConfigOverrides(overrides);
6866 base::DictionaryValue* config;
6867
6868 auto value = resolver_->GetDnsConfigAsValue();
6869 EXPECT_TRUE(value);
6870 if (!value)
6871 return;
6872 value->GetAsDictionary(&config);
6873 base::ListValue* doh_servers;
6874 config->GetListWithoutPathExpansion("doh_servers", &doh_servers);
6875 EXPECT_TRUE(doh_servers);
6876 if (!doh_servers)
6877 return;
6878 EXPECT_EQ(doh_servers->GetSize(), 1u);
6879 base::DictionaryValue* server_method;
6880 EXPECT_TRUE(doh_servers->GetDictionary(0, &server_method));
6881 bool use_post;
6882 EXPECT_TRUE(server_method->GetBoolean("use_post", &use_post));
6883 EXPECT_TRUE(use_post);
6884 std::string server_template;
6885 EXPECT_TRUE(server_method->GetString("server_template", &server_template));
6886 EXPECT_EQ(server_template, server);
6887 EXPECT_EQ(config->FindKey("secure_dns_mode")->GetInt(),
6888 static_cast<int>(DnsConfig::SecureDnsMode::AUTOMATIC));
6889 }
6890
TEST_F(HostResolverManagerDnsTest,AddDnsOverHttpsServerBeforeConfig)6891 TEST_F(HostResolverManagerDnsTest, AddDnsOverHttpsServerBeforeConfig) {
6892 DestroyResolver();
6893 test::ScopedMockNetworkChangeNotifier notifier;
6894 CreateSerialResolver(); // To guarantee order of resolutions.
6895 std::string server("https://dnsserver.example.net/dns-query{?dns}");
6896 DnsConfigOverrides overrides;
6897 overrides.dns_over_https_servers.emplace(
6898 {DnsOverHttpsServerConfig(server, true)});
6899 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
6900 resolver_->SetDnsConfigOverrides(overrides);
6901
6902 notifier.mock_network_change_notifier()->SetConnectionType(
6903 NetworkChangeNotifier::CONNECTION_WIFI);
6904 ChangeDnsConfig(CreateValidDnsConfig());
6905
6906 base::DictionaryValue* config;
6907 auto value = resolver_->GetDnsConfigAsValue();
6908 EXPECT_TRUE(value);
6909 if (!value)
6910 return;
6911 value->GetAsDictionary(&config);
6912 base::ListValue* doh_servers;
6913 config->GetListWithoutPathExpansion("doh_servers", &doh_servers);
6914 EXPECT_TRUE(doh_servers);
6915 if (!doh_servers)
6916 return;
6917 EXPECT_EQ(doh_servers->GetSize(), 1u);
6918 base::DictionaryValue* server_method;
6919 EXPECT_TRUE(doh_servers->GetDictionary(0, &server_method));
6920 bool use_post;
6921 EXPECT_TRUE(server_method->GetBoolean("use_post", &use_post));
6922 EXPECT_TRUE(use_post);
6923 std::string server_template;
6924 EXPECT_TRUE(server_method->GetString("server_template", &server_template));
6925 EXPECT_EQ(server_template, server);
6926 EXPECT_EQ(config->FindKey("secure_dns_mode")->GetInt(),
6927 static_cast<int>(DnsConfig::SecureDnsMode::AUTOMATIC));
6928 }
6929
TEST_F(HostResolverManagerDnsTest,AddDnsOverHttpsServerBeforeClient)6930 TEST_F(HostResolverManagerDnsTest, AddDnsOverHttpsServerBeforeClient) {
6931 DestroyResolver();
6932 test::ScopedMockNetworkChangeNotifier notifier;
6933 CreateSerialResolver(); // To guarantee order of resolutions.
6934 std::string server("https://dnsserver.example.net/dns-query{?dns}");
6935 DnsConfigOverrides overrides;
6936 overrides.dns_over_https_servers.emplace(
6937 {DnsOverHttpsServerConfig(server, true)});
6938 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
6939 resolver_->SetDnsConfigOverrides(overrides);
6940
6941 notifier.mock_network_change_notifier()->SetConnectionType(
6942 NetworkChangeNotifier::CONNECTION_WIFI);
6943 ChangeDnsConfig(CreateValidDnsConfig());
6944
6945 base::DictionaryValue* config;
6946 auto value = resolver_->GetDnsConfigAsValue();
6947 EXPECT_TRUE(value);
6948 if (!value)
6949 return;
6950 value->GetAsDictionary(&config);
6951 base::ListValue* doh_servers;
6952 config->GetListWithoutPathExpansion("doh_servers", &doh_servers);
6953 EXPECT_TRUE(doh_servers);
6954 if (!doh_servers)
6955 return;
6956 EXPECT_EQ(doh_servers->GetSize(), 1u);
6957 base::DictionaryValue* server_method;
6958 EXPECT_TRUE(doh_servers->GetDictionary(0, &server_method));
6959 bool use_post;
6960 EXPECT_TRUE(server_method->GetBoolean("use_post", &use_post));
6961 EXPECT_TRUE(use_post);
6962 std::string server_template;
6963 EXPECT_TRUE(server_method->GetString("server_template", &server_template));
6964 EXPECT_EQ(server_template, server);
6965 EXPECT_EQ(config->FindKey("secure_dns_mode")->GetInt(),
6966 static_cast<int>(DnsConfig::SecureDnsMode::AUTOMATIC));
6967 }
6968
TEST_F(HostResolverManagerDnsTest,AddDnsOverHttpsServerAndThenRemove)6969 TEST_F(HostResolverManagerDnsTest, AddDnsOverHttpsServerAndThenRemove) {
6970 DestroyResolver();
6971 test::ScopedMockNetworkChangeNotifier notifier;
6972 CreateSerialResolver(); // To guarantee order of resolutions.
6973 std::string server("https://dns.example.com/");
6974 DnsConfigOverrides overrides;
6975 overrides.dns_over_https_servers.emplace(
6976 {DnsOverHttpsServerConfig(server, true)});
6977 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
6978 resolver_->SetDnsConfigOverrides(overrides);
6979
6980 notifier.mock_network_change_notifier()->SetConnectionType(
6981 NetworkChangeNotifier::CONNECTION_WIFI);
6982 DnsConfig network_dns_config = CreateValidDnsConfig();
6983 network_dns_config.dns_over_https_servers.clear();
6984 ChangeDnsConfig(network_dns_config);
6985
6986 base::DictionaryValue* config;
6987 auto value = resolver_->GetDnsConfigAsValue();
6988 EXPECT_TRUE(value);
6989 if (!value)
6990 return;
6991 value->GetAsDictionary(&config);
6992 base::ListValue* doh_servers;
6993 config->GetListWithoutPathExpansion("doh_servers", &doh_servers);
6994 EXPECT_TRUE(doh_servers);
6995 if (!doh_servers)
6996 return;
6997 EXPECT_EQ(doh_servers->GetSize(), 1u);
6998 base::DictionaryValue* server_method;
6999 EXPECT_TRUE(doh_servers->GetDictionary(0, &server_method));
7000 bool use_post;
7001 EXPECT_TRUE(server_method->GetBoolean("use_post", &use_post));
7002 EXPECT_TRUE(use_post);
7003 std::string server_template;
7004 EXPECT_TRUE(server_method->GetString("server_template", &server_template));
7005 EXPECT_EQ(server_template, server);
7006 EXPECT_EQ(config->FindKey("secure_dns_mode")->GetInt(),
7007 static_cast<int>(DnsConfig::SecureDnsMode::AUTOMATIC));
7008
7009 resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
7010 value = resolver_->GetDnsConfigAsValue();
7011 EXPECT_TRUE(value);
7012 if (!value)
7013 return;
7014 value->GetAsDictionary(&config);
7015 config->GetListWithoutPathExpansion("doh_servers", &doh_servers);
7016 EXPECT_TRUE(doh_servers);
7017 if (!doh_servers)
7018 return;
7019 EXPECT_EQ(doh_servers->GetSize(), 0u);
7020 EXPECT_EQ(config->FindKey("secure_dns_mode")->GetInt(),
7021 static_cast<int>(DnsConfig::SecureDnsMode::OFF));
7022 }
7023
7024 // Basic test socket factory that allows creation of UDP sockets, but those
7025 // sockets are mocks with no data and are not expected to be usable.
7026 class AlwaysFailSocketFactory : public MockClientSocketFactory {
7027 public:
CreateDatagramClientSocket(DatagramSocket::BindType bind_type,NetLog * net_log,const NetLogSource & source)7028 std::unique_ptr<DatagramClientSocket> CreateDatagramClientSocket(
7029 DatagramSocket::BindType bind_type,
7030 NetLog* net_log,
7031 const NetLogSource& source) override {
7032 return std::make_unique<MockUDPClientSocket>();
7033 }
7034 };
7035
7036 class TestDnsObserver : public NetworkChangeNotifier::DNSObserver {
7037 public:
OnDNSChanged()7038 void OnDNSChanged() override { ++dns_changed_calls_; }
7039
dns_changed_calls() const7040 int dns_changed_calls() const { return dns_changed_calls_; }
7041
7042 private:
7043 int dns_changed_calls_ = 0;
7044 };
7045
7046 // Built-in client and config overrides not available on iOS.
7047 #if !defined(OS_IOS)
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides)7048 TEST_F(HostResolverManagerDnsTest, SetDnsConfigOverrides) {
7049 test::ScopedMockNetworkChangeNotifier mock_network_change_notifier;
7050 TestDnsObserver config_observer;
7051 NetworkChangeNotifier::AddDNSObserver(&config_observer);
7052
7053 // Use a real DnsClient to test config-handling behavior.
7054 AlwaysFailSocketFactory socket_factory;
7055 auto client =
7056 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7057 base::BindRepeating(&base::RandInt));
7058 DnsClient* client_ptr = client.get();
7059 resolver_->SetDnsClientForTesting(std::move(client));
7060
7061 DnsConfig original_config = CreateValidDnsConfig();
7062 ChangeDnsConfig(original_config);
7063
7064 // Confirm pre-override state.
7065 ASSERT_EQ(original_config, *client_ptr->GetEffectiveConfig());
7066
7067 DnsConfigOverrides overrides;
7068 const std::vector<IPEndPoint> nameservers = {
7069 CreateExpected("192.168.0.1", 92)};
7070 overrides.nameservers = nameservers;
7071 const std::vector<std::string> search = {"str"};
7072 overrides.search = search;
7073 const DnsHosts hosts = {
7074 {DnsHostsKey("host", ADDRESS_FAMILY_IPV4), IPAddress(192, 168, 1, 1)}};
7075 overrides.hosts = hosts;
7076 overrides.append_to_multi_label_name = false;
7077 overrides.randomize_ports = true;
7078 const int ndots = 5;
7079 overrides.ndots = ndots;
7080 const base::TimeDelta timeout = base::TimeDelta::FromSeconds(10);
7081 overrides.timeout = timeout;
7082 const int attempts = 20;
7083 overrides.attempts = attempts;
7084 const int doh_attempts = 19;
7085 overrides.doh_attempts = doh_attempts;
7086 overrides.rotate = true;
7087 overrides.use_local_ipv6 = true;
7088 const std::vector<DnsOverHttpsServerConfig> dns_over_https_servers = {
7089 DnsOverHttpsServerConfig("dns.example.com", true)};
7090 overrides.dns_over_https_servers = dns_over_https_servers;
7091 const DnsConfig::SecureDnsMode secure_dns_mode =
7092 DnsConfig::SecureDnsMode::SECURE;
7093 overrides.secure_dns_mode = secure_dns_mode;
7094 overrides.allow_dns_over_https_upgrade = true;
7095 const std::vector<std::string> disabled_upgrade_providers = {"provider_name"};
7096 overrides.disabled_upgrade_providers = disabled_upgrade_providers;
7097
7098 // This test is expected to test overriding all fields.
7099 EXPECT_TRUE(overrides.OverridesEverything());
7100
7101 EXPECT_EQ(0, config_observer.dns_changed_calls());
7102
7103 resolver_->SetDnsConfigOverrides(overrides);
7104
7105 const DnsConfig* overridden_config = client_ptr->GetEffectiveConfig();
7106 ASSERT_TRUE(overridden_config);
7107 EXPECT_EQ(nameservers, overridden_config->nameservers);
7108 EXPECT_EQ(search, overridden_config->search);
7109 EXPECT_EQ(hosts, overridden_config->hosts);
7110 EXPECT_FALSE(overridden_config->append_to_multi_label_name);
7111 EXPECT_TRUE(overridden_config->randomize_ports);
7112 EXPECT_EQ(ndots, overridden_config->ndots);
7113 EXPECT_EQ(timeout, overridden_config->timeout);
7114 EXPECT_EQ(attempts, overridden_config->attempts);
7115 EXPECT_EQ(doh_attempts, overridden_config->doh_attempts);
7116 EXPECT_TRUE(overridden_config->rotate);
7117 EXPECT_TRUE(overridden_config->use_local_ipv6);
7118 EXPECT_EQ(dns_over_https_servers, overridden_config->dns_over_https_servers);
7119 EXPECT_EQ(secure_dns_mode, overridden_config->secure_dns_mode);
7120 EXPECT_TRUE(overridden_config->allow_dns_over_https_upgrade);
7121 EXPECT_EQ(disabled_upgrade_providers,
7122 overridden_config->disabled_upgrade_providers);
7123
7124 base::RunLoop().RunUntilIdle(); // Notifications are async.
7125 EXPECT_EQ(1, config_observer.dns_changed_calls());
7126
7127 NetworkChangeNotifier::RemoveDNSObserver(&config_observer);
7128 }
7129
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides_OverrideEverythingCreation)7130 TEST_F(HostResolverManagerDnsTest,
7131 SetDnsConfigOverrides_OverrideEverythingCreation) {
7132 // Use a real DnsClient to test config-handling behavior.
7133 AlwaysFailSocketFactory socket_factory;
7134 auto client =
7135 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7136 base::BindRepeating(&base::RandInt));
7137 DnsClient* client_ptr = client.get();
7138 resolver_->SetDnsClientForTesting(std::move(client));
7139
7140 DnsConfig original_config = CreateValidDnsConfig();
7141 ChangeDnsConfig(original_config);
7142
7143 // Confirm pre-override state.
7144 ASSERT_EQ(original_config, *client_ptr->GetEffectiveConfig());
7145 ASSERT_FALSE(original_config.Equals(DnsConfig()));
7146
7147 DnsConfigOverrides overrides =
7148 DnsConfigOverrides::CreateOverridingEverythingWithDefaults();
7149 EXPECT_TRUE(overrides.OverridesEverything());
7150
7151 // Ensure config is valid by setting a nameserver.
7152 std::vector<IPEndPoint> nameservers = {CreateExpected("1.2.3.4", 50)};
7153 overrides.nameservers = nameservers;
7154 EXPECT_TRUE(overrides.OverridesEverything());
7155
7156 resolver_->SetDnsConfigOverrides(overrides);
7157
7158 DnsConfig expected;
7159 expected.nameservers = nameservers;
7160 EXPECT_THAT(client_ptr->GetEffectiveConfig(), testing::Pointee(expected));
7161 }
7162
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides_PartialOverride)7163 TEST_F(HostResolverManagerDnsTest, SetDnsConfigOverrides_PartialOverride) {
7164 // Use a real DnsClient to test config-handling behavior.
7165 AlwaysFailSocketFactory socket_factory;
7166 auto client =
7167 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7168 base::BindRepeating(&base::RandInt));
7169 DnsClient* client_ptr = client.get();
7170 resolver_->SetDnsClientForTesting(std::move(client));
7171
7172 DnsConfig original_config = CreateValidDnsConfig();
7173 ChangeDnsConfig(original_config);
7174
7175 // Confirm pre-override state.
7176 ASSERT_EQ(original_config, *client_ptr->GetEffectiveConfig());
7177
7178 DnsConfigOverrides overrides;
7179 const std::vector<IPEndPoint> nameservers = {
7180 CreateExpected("192.168.0.2", 192)};
7181 overrides.nameservers = nameservers;
7182 overrides.rotate = true;
7183 EXPECT_FALSE(overrides.OverridesEverything());
7184
7185 resolver_->SetDnsConfigOverrides(overrides);
7186
7187 const DnsConfig* overridden_config = client_ptr->GetEffectiveConfig();
7188 ASSERT_TRUE(overridden_config);
7189 EXPECT_EQ(nameservers, overridden_config->nameservers);
7190 EXPECT_EQ(original_config.search, overridden_config->search);
7191 EXPECT_EQ(original_config.hosts, overridden_config->hosts);
7192 EXPECT_TRUE(overridden_config->append_to_multi_label_name);
7193 EXPECT_FALSE(overridden_config->randomize_ports);
7194 EXPECT_EQ(original_config.ndots, overridden_config->ndots);
7195 EXPECT_EQ(original_config.timeout, overridden_config->timeout);
7196 EXPECT_EQ(original_config.attempts, overridden_config->attempts);
7197 EXPECT_TRUE(overridden_config->rotate);
7198 EXPECT_FALSE(overridden_config->use_local_ipv6);
7199 EXPECT_EQ(original_config.dns_over_https_servers,
7200 overridden_config->dns_over_https_servers);
7201 EXPECT_EQ(original_config.secure_dns_mode,
7202 overridden_config->secure_dns_mode);
7203 }
7204
7205 // Test that overridden configs are reapplied over a changed underlying system
7206 // config.
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides_NewConfig)7207 TEST_F(HostResolverManagerDnsTest, SetDnsConfigOverrides_NewConfig) {
7208 // Use a real DnsClient to test config-handling behavior.
7209 AlwaysFailSocketFactory socket_factory;
7210 auto client =
7211 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7212 base::BindRepeating(&base::RandInt));
7213 DnsClient* client_ptr = client.get();
7214 resolver_->SetDnsClientForTesting(std::move(client));
7215
7216 DnsConfig original_config = CreateValidDnsConfig();
7217 ChangeDnsConfig(original_config);
7218
7219 // Confirm pre-override state.
7220 ASSERT_EQ(original_config, *client_ptr->GetEffectiveConfig());
7221
7222 DnsConfigOverrides overrides;
7223 const std::vector<IPEndPoint> nameservers = {
7224 CreateExpected("192.168.0.2", 192)};
7225 overrides.nameservers = nameservers;
7226
7227 resolver_->SetDnsConfigOverrides(overrides);
7228 ASSERT_TRUE(client_ptr->GetEffectiveConfig());
7229 ASSERT_EQ(nameservers, client_ptr->GetEffectiveConfig()->nameservers);
7230
7231 DnsConfig new_config = original_config;
7232 new_config.attempts = 103;
7233 ASSERT_NE(nameservers, new_config.nameservers);
7234 ChangeDnsConfig(new_config);
7235
7236 const DnsConfig* overridden_config = client_ptr->GetEffectiveConfig();
7237 ASSERT_TRUE(overridden_config);
7238 EXPECT_EQ(nameservers, overridden_config->nameservers);
7239 EXPECT_EQ(new_config.attempts, overridden_config->attempts);
7240 }
7241
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides_ClearOverrides)7242 TEST_F(HostResolverManagerDnsTest, SetDnsConfigOverrides_ClearOverrides) {
7243 // Use a real DnsClient to test config-handling behavior.
7244 AlwaysFailSocketFactory socket_factory;
7245 auto client =
7246 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7247 base::BindRepeating(&base::RandInt));
7248 DnsClient* client_ptr = client.get();
7249 resolver_->SetDnsClientForTesting(std::move(client));
7250
7251 DnsConfig original_config = CreateValidDnsConfig();
7252 ChangeDnsConfig(original_config);
7253
7254 DnsConfigOverrides overrides;
7255 overrides.attempts = 245;
7256 resolver_->SetDnsConfigOverrides(overrides);
7257
7258 ASSERT_THAT(client_ptr->GetEffectiveConfig(),
7259 testing::Not(testing::Pointee(original_config)));
7260
7261 resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
7262 EXPECT_THAT(client_ptr->GetEffectiveConfig(),
7263 testing::Pointee(original_config));
7264 }
7265
TEST_F(HostResolverManagerDnsTest,SetDnsConfigOverrides_NoChange)7266 TEST_F(HostResolverManagerDnsTest, SetDnsConfigOverrides_NoChange) {
7267 test::ScopedMockNetworkChangeNotifier mock_network_change_notifier;
7268 TestDnsObserver config_observer;
7269 NetworkChangeNotifier::AddDNSObserver(&config_observer);
7270
7271 // Use a real DnsClient to test config-handling behavior.
7272 AlwaysFailSocketFactory socket_factory;
7273 auto client =
7274 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7275 base::BindRepeating(&base::RandInt));
7276 DnsClient* client_ptr = client.get();
7277 resolver_->SetDnsClientForTesting(std::move(client));
7278
7279 DnsConfig original_config = CreateValidDnsConfig();
7280 ChangeDnsConfig(original_config);
7281
7282 // Confirm pre-override state.
7283 ASSERT_EQ(original_config, *client_ptr->GetEffectiveConfig());
7284
7285 DnsConfigOverrides overrides;
7286 overrides.nameservers = original_config.nameservers;
7287
7288 EXPECT_EQ(0, config_observer.dns_changed_calls());
7289
7290 resolver_->SetDnsConfigOverrides(overrides);
7291 EXPECT_THAT(client_ptr->GetEffectiveConfig(),
7292 testing::Pointee(original_config));
7293
7294 base::RunLoop().RunUntilIdle(); // Notifications are async.
7295 EXPECT_EQ(0,
7296 config_observer.dns_changed_calls()); // No expected notification
7297
7298 NetworkChangeNotifier::RemoveDNSObserver(&config_observer);
7299 }
7300
7301 // No effect or notifications expected using partial overrides without a base
7302 // system config.
TEST_F(HostResolverManagerDnsTest,NoBaseConfig_PartialOverrides)7303 TEST_F(HostResolverManagerDnsTest, NoBaseConfig_PartialOverrides) {
7304 test::ScopedMockNetworkChangeNotifier mock_network_change_notifier;
7305 TestDnsObserver config_observer;
7306 NetworkChangeNotifier::AddDNSObserver(&config_observer);
7307
7308 // Use a real DnsClient to test config-handling behavior.
7309 AlwaysFailSocketFactory socket_factory;
7310 auto client =
7311 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7312 base::BindRepeating(&base::RandInt));
7313 DnsClient* client_ptr = client.get();
7314 resolver_->SetDnsClientForTesting(std::move(client));
7315
7316 client_ptr->SetSystemConfig(base::nullopt);
7317
7318 DnsConfigOverrides overrides;
7319 overrides.nameservers.emplace({CreateExpected("192.168.0.3", 193)});
7320 resolver_->SetDnsConfigOverrides(overrides);
7321 base::RunLoop().RunUntilIdle(); // Potential notifications are async.
7322
7323 EXPECT_FALSE(client_ptr->GetEffectiveConfig());
7324 EXPECT_EQ(0, config_observer.dns_changed_calls());
7325
7326 NetworkChangeNotifier::RemoveDNSObserver(&config_observer);
7327 }
7328
TEST_F(HostResolverManagerDnsTest,NoBaseConfig_OverridesEverything)7329 TEST_F(HostResolverManagerDnsTest, NoBaseConfig_OverridesEverything) {
7330 test::ScopedMockNetworkChangeNotifier mock_network_change_notifier;
7331 TestDnsObserver config_observer;
7332 NetworkChangeNotifier::AddDNSObserver(&config_observer);
7333
7334 // Use a real DnsClient to test config-handling behavior.
7335 AlwaysFailSocketFactory socket_factory;
7336 auto client =
7337 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7338 base::BindRepeating(&base::RandInt));
7339 DnsClient* client_ptr = client.get();
7340 resolver_->SetDnsClientForTesting(std::move(client));
7341
7342 client_ptr->SetSystemConfig(base::nullopt);
7343
7344 DnsConfigOverrides overrides =
7345 DnsConfigOverrides::CreateOverridingEverythingWithDefaults();
7346 const std::vector<IPEndPoint> nameservers = {
7347 CreateExpected("192.168.0.4", 194)};
7348 overrides.nameservers = nameservers;
7349 resolver_->SetDnsConfigOverrides(overrides);
7350 base::RunLoop().RunUntilIdle(); // Notifications are async.
7351
7352 DnsConfig expected;
7353 expected.nameservers = nameservers;
7354
7355 EXPECT_THAT(client_ptr->GetEffectiveConfig(), testing::Pointee(expected));
7356 EXPECT_EQ(1, config_observer.dns_changed_calls());
7357
7358 NetworkChangeNotifier::RemoveDNSObserver(&config_observer);
7359 }
7360
TEST_F(HostResolverManagerDnsTest,DohMapping)7361 TEST_F(HostResolverManagerDnsTest, DohMapping) {
7362 // Use a real DnsClient to test config-handling behavior.
7363 AlwaysFailSocketFactory socket_factory;
7364 auto client =
7365 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7366 base::BindRepeating(&base::RandInt));
7367 DnsClient* client_ptr = client.get();
7368 resolver_->SetDnsClientForTesting(std::move(client));
7369
7370 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7371 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7372 // not associated with hardcoded DoH services.
7373 DnsConfig original_config = CreateUpgradableDnsConfig();
7374 ChangeDnsConfig(original_config);
7375
7376 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7377 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7378 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {
7379 {"https://chrome.cloudflare-dns.com/dns-query", true /* use-post */},
7380 {"https://doh.cleanbrowsing.org/doh/family-filter{?dns}",
7381 false /* use_post */},
7382 {"https://doh.cleanbrowsing.org/doh/security-filter{?dns}",
7383 false /* use_post */}};
7384 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7385 }
7386
TEST_F(HostResolverManagerDnsTest,DohMappingDisabled)7387 TEST_F(HostResolverManagerDnsTest, DohMappingDisabled) {
7388 // Use a real DnsClient to test config-handling behavior.
7389 AlwaysFailSocketFactory socket_factory;
7390 auto client =
7391 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7392 base::BindRepeating(&base::RandInt));
7393 DnsClient* client_ptr = client.get();
7394 resolver_->SetDnsClientForTesting(std::move(client));
7395
7396 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7397 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7398 // not associated with hardcoded DoH services.
7399 DnsConfig original_config = CreateUpgradableDnsConfig();
7400 original_config.allow_dns_over_https_upgrade = false;
7401 ChangeDnsConfig(original_config);
7402
7403 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7404 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7405 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {};
7406 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7407 }
7408
TEST_F(HostResolverManagerDnsTest,DohMappingModeIneligibleForUpgrade)7409 TEST_F(HostResolverManagerDnsTest, DohMappingModeIneligibleForUpgrade) {
7410 // Use a real DnsClient to test config-handling behavior.
7411 AlwaysFailSocketFactory socket_factory;
7412 auto client =
7413 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7414 base::BindRepeating(&base::RandInt));
7415 DnsClient* client_ptr = client.get();
7416 resolver_->SetDnsClientForTesting(std::move(client));
7417
7418 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7419 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7420 // not associated with hardcoded DoH services.
7421 DnsConfig original_config = CreateUpgradableDnsConfig();
7422 original_config.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
7423 ChangeDnsConfig(original_config);
7424
7425 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7426 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7427 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {};
7428 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7429 }
7430
TEST_F(HostResolverManagerDnsTest,DohMappingUnhandledOptionsIneligibleForUpgrade)7431 TEST_F(HostResolverManagerDnsTest,
7432 DohMappingUnhandledOptionsIneligibleForUpgrade) {
7433 // Use a real DnsClient to test config-handling behavior.
7434 AlwaysFailSocketFactory socket_factory;
7435 auto client =
7436 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7437 base::BindRepeating(&base::RandInt));
7438 DnsClient* client_ptr = client.get();
7439 resolver_->SetDnsClientForTesting(std::move(client));
7440
7441 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7442 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7443 // not associated with hardcoded DoH services.
7444 DnsConfig original_config = CreateUpgradableDnsConfig();
7445 original_config.unhandled_options = true;
7446 ChangeDnsConfig(original_config);
7447
7448 EXPECT_FALSE(client_ptr->GetEffectiveConfig());
7449 }
7450
TEST_F(HostResolverManagerDnsTest,DohMappingWithExclusion)7451 TEST_F(HostResolverManagerDnsTest, DohMappingWithExclusion) {
7452 // Use a real DnsClient to test config-handling behavior.
7453 AlwaysFailSocketFactory socket_factory;
7454 auto client =
7455 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7456 base::BindRepeating(&base::RandInt));
7457 DnsClient* client_ptr = client.get();
7458 resolver_->SetDnsClientForTesting(std::move(client));
7459
7460 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7461 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7462 // not associated with hardcoded DoH services.
7463 DnsConfig original_config = CreateUpgradableDnsConfig();
7464 original_config.disabled_upgrade_providers = {"CleanBrowsingSecure",
7465 "Cloudflare", "Unexpected"};
7466 ChangeDnsConfig(original_config);
7467
7468 // A DoH upgrade should be attempted on the DNS servers in the config, but
7469 // only for permitted providers.
7470 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7471 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7472 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {
7473 {"https://doh.cleanbrowsing.org/doh/family-filter{?dns}",
7474 false /* use_post */}};
7475 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7476 }
7477
TEST_F(HostResolverManagerDnsTest,DohMappingIgnoredIfTemplateSpecified)7478 TEST_F(HostResolverManagerDnsTest, DohMappingIgnoredIfTemplateSpecified) {
7479 // Use a real DnsClient to test config-handling behavior.
7480 AlwaysFailSocketFactory socket_factory;
7481 auto client =
7482 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7483 base::BindRepeating(&base::RandInt));
7484 DnsClient* client_ptr = client.get();
7485 resolver_->SetDnsClientForTesting(std::move(client));
7486
7487 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7488 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7489 // not associated with hardcoded DoH services.
7490 DnsConfig original_config = CreateUpgradableDnsConfig();
7491 ChangeDnsConfig(original_config);
7492
7493 // If the overrides contains DoH servers, no DoH upgrade should be attempted.
7494 DnsConfigOverrides overrides;
7495 const std::vector<DnsOverHttpsServerConfig> dns_over_https_servers_overrides =
7496 {DnsOverHttpsServerConfig("doh.server.override.com", true)};
7497 overrides.dns_over_https_servers = dns_over_https_servers_overrides;
7498 resolver_->SetDnsConfigOverrides(overrides);
7499 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7500 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7501 EXPECT_EQ(dns_over_https_servers_overrides,
7502 fetched_config->dns_over_https_servers);
7503 }
7504
TEST_F(HostResolverManagerDnsTest,DohMappingUnhandledOptionsAndTemplateSpecified)7505 TEST_F(HostResolverManagerDnsTest,
7506 DohMappingUnhandledOptionsAndTemplateSpecified) {
7507 // Use a real DnsClient to test config-handling behavior.
7508 AlwaysFailSocketFactory socket_factory;
7509 auto client =
7510 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7511 base::BindRepeating(&base::RandInt));
7512 DnsClient* client_ptr = client.get();
7513 resolver_->SetDnsClientForTesting(std::move(client));
7514
7515 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7516 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7517 // not associated with hardcoded DoH services.
7518 DnsConfig original_config = CreateUpgradableDnsConfig();
7519 original_config.unhandled_options = true;
7520 ChangeDnsConfig(original_config);
7521
7522 // If the overrides contains DoH servers, no DoH upgrade should be attempted.
7523 DnsConfigOverrides overrides;
7524 const std::vector<DnsOverHttpsServerConfig> dns_over_https_servers_overrides =
7525 {DnsOverHttpsServerConfig("doh.server.override.com", true)};
7526 overrides.dns_over_https_servers = dns_over_https_servers_overrides;
7527 resolver_->SetDnsConfigOverrides(overrides);
7528 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7529 EXPECT_TRUE(fetched_config->nameservers.empty());
7530 EXPECT_FALSE(client_ptr->CanUseInsecureDnsTransactions());
7531 EXPECT_EQ(dns_over_https_servers_overrides,
7532 fetched_config->dns_over_https_servers);
7533 EXPECT_TRUE(client_ptr->CanUseSecureDnsTransactions());
7534 }
7535
TEST_F(HostResolverManagerDnsTest,DohMappingWithAutomaticDot)7536 TEST_F(HostResolverManagerDnsTest, DohMappingWithAutomaticDot) {
7537 // Use a real DnsClient to test config-handling behavior.
7538 AlwaysFailSocketFactory socket_factory;
7539 auto client =
7540 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7541 base::BindRepeating(&base::RandInt));
7542 DnsClient* client_ptr = client.get();
7543 resolver_->SetDnsClientForTesting(std::move(client));
7544
7545 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7546 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7547 // not associated with hardcoded DoH services.
7548 DnsConfig original_config = CreateUpgradableDnsConfig();
7549 original_config.dns_over_tls_active = true;
7550 ChangeDnsConfig(original_config);
7551
7552 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7553 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7554 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {
7555 {"https://chrome.cloudflare-dns.com/dns-query", true /* use-post */},
7556 {"https://doh.cleanbrowsing.org/doh/family-filter{?dns}",
7557 false /* use_post */},
7558 {"https://doh.cleanbrowsing.org/doh/security-filter{?dns}",
7559 false /* use_post */}};
7560 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7561 }
7562
TEST_F(HostResolverManagerDnsTest,DohMappingWithStrictDot)7563 TEST_F(HostResolverManagerDnsTest, DohMappingWithStrictDot) {
7564 // Use a real DnsClient to test config-handling behavior.
7565 AlwaysFailSocketFactory socket_factory;
7566 auto client =
7567 DnsClient::CreateClientForTesting(nullptr /* net_log */, &socket_factory,
7568 base::BindRepeating(&base::RandInt));
7569 DnsClient* client_ptr = client.get();
7570 resolver_->SetDnsClientForTesting(std::move(client));
7571
7572 // Create a DnsConfig containing IP addresses associated with Cloudflare,
7573 // SafeBrowsing family filter, SafeBrowsing security filter, and other IPs
7574 // not associated with hardcoded DoH services.
7575 DnsConfig original_config = CreateUpgradableDnsConfig();
7576 original_config.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
7577 original_config.dns_over_tls_active = true;
7578
7579 // Google DoT hostname
7580 original_config.dns_over_tls_hostname = "dns.google";
7581 ChangeDnsConfig(original_config);
7582 const DnsConfig* fetched_config = client_ptr->GetEffectiveConfig();
7583 EXPECT_EQ(original_config.nameservers, fetched_config->nameservers);
7584 std::vector<DnsOverHttpsServerConfig> expected_doh_servers = {
7585 {"https://dns.google/dns-query{?dns}", false /* use_post */}};
7586 EXPECT_EQ(expected_doh_servers, fetched_config->dns_over_https_servers);
7587 }
7588
7589 #endif // !defined(OS_IOS)
7590
TEST_F(HostResolverManagerDnsTest,FlushCacheOnDnsConfigOverridesChange)7591 TEST_F(HostResolverManagerDnsTest, FlushCacheOnDnsConfigOverridesChange) {
7592 ChangeDnsConfig(CreateValidDnsConfig());
7593
7594 HostResolver::ResolveHostParameters local_source_parameters;
7595 local_source_parameters.source = HostResolverSource::LOCAL_ONLY;
7596
7597 // Populate cache.
7598 ResolveHostResponseHelper initial_response(resolver_->CreateRequest(
7599 HostPortPair("ok", 70), NetworkIsolationKey(), NetLogWithSource(),
7600 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7601 EXPECT_THAT(initial_response.result_error(), IsOk());
7602
7603 // Confirm result now cached.
7604 ResolveHostResponseHelper cached_response(resolver_->CreateRequest(
7605 HostPortPair("ok", 75), NetworkIsolationKey(), NetLogWithSource(),
7606 local_source_parameters, resolve_context_.get(),
7607 resolve_context_->host_cache()));
7608 ASSERT_THAT(cached_response.result_error(), IsOk());
7609 ASSERT_TRUE(cached_response.request()->GetStaleInfo());
7610
7611 // Flush cache by triggering a DnsConfigOverrides change.
7612 DnsConfigOverrides overrides;
7613 overrides.attempts = 4;
7614 resolver_->SetDnsConfigOverrides(overrides);
7615
7616 // Expect no longer cached
7617 ResolveHostResponseHelper flushed_response(resolver_->CreateRequest(
7618 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7619 local_source_parameters, resolve_context_.get(),
7620 resolve_context_->host_cache()));
7621 EXPECT_THAT(flushed_response.result_error(), IsError(ERR_DNS_CACHE_MISS));
7622 }
7623
TEST_F(HostResolverManagerDnsTest,FlushContextSessionDataOnDnsConfigOverridesChange)7624 TEST_F(HostResolverManagerDnsTest,
7625 FlushContextSessionDataOnDnsConfigOverridesChange) {
7626 ChangeDnsConfig(CreateValidDnsConfig());
7627
7628 DnsSession* session_before = dns_client_->GetCurrentSession();
7629 resolve_context_->RecordServerSuccess(
7630 0u /* server_index */, true /* is_doh_server */, session_before);
7631 ASSERT_TRUE(resolve_context_->GetDohServerAvailability(0u, session_before));
7632
7633 // Flush data by triggering a DnsConfigOverrides change.
7634 DnsConfigOverrides overrides;
7635 overrides.attempts = 4;
7636 resolver_->SetDnsConfigOverrides(overrides);
7637
7638 DnsSession* session_after = dns_client_->GetCurrentSession();
7639 EXPECT_NE(session_before, session_after);
7640
7641 EXPECT_FALSE(resolve_context_->GetDohServerAvailability(0u, session_after));
7642
7643 // Confirm new session is in use.
7644 resolve_context_->RecordServerSuccess(
7645 0u /* server_index */, true /* is_doh_server */, session_after);
7646 EXPECT_TRUE(resolve_context_->GetDohServerAvailability(0u, session_after));
7647 }
7648
7649 // Test that even when using config overrides, a change to the base system
7650 // config cancels pending requests.
TEST_F(HostResolverManagerDnsTest,CancellationOnBaseConfigChange)7651 TEST_F(HostResolverManagerDnsTest, CancellationOnBaseConfigChange) {
7652 DnsConfig original_config = CreateValidDnsConfig();
7653 ChangeDnsConfig(original_config);
7654
7655 DnsConfigOverrides overrides;
7656 overrides.nameservers.emplace({CreateExpected("123.123.123.123", 80)});
7657 ASSERT_FALSE(overrides.OverridesEverything());
7658 resolver_->SetDnsConfigOverrides(overrides);
7659
7660 ResolveHostResponseHelper response(resolver_->CreateRequest(
7661 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7662 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7663 ASSERT_FALSE(response.complete());
7664
7665 DnsConfig new_config = original_config;
7666 new_config.attempts = 103;
7667 ChangeDnsConfig(new_config);
7668
7669 EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
7670 }
7671
7672 // Test that when all configuration is overridden, system configuration changes
7673 // do not cancel requests.
TEST_F(HostResolverManagerDnsTest,CancellationOnBaseConfigChange_OverridesEverything)7674 TEST_F(HostResolverManagerDnsTest,
7675 CancellationOnBaseConfigChange_OverridesEverything) {
7676 DnsConfig original_config = CreateValidDnsConfig();
7677 ChangeDnsConfig(original_config);
7678
7679 DnsConfigOverrides overrides =
7680 DnsConfigOverrides::CreateOverridingEverythingWithDefaults();
7681 overrides.nameservers.emplace({CreateExpected("123.123.123.123", 80)});
7682 ASSERT_TRUE(overrides.OverridesEverything());
7683 resolver_->SetDnsConfigOverrides(overrides);
7684
7685 ResolveHostResponseHelper response(resolver_->CreateRequest(
7686 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7687 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7688 ASSERT_FALSE(response.complete());
7689
7690 DnsConfig new_config = original_config;
7691 new_config.attempts = 103;
7692 ChangeDnsConfig(new_config);
7693
7694 dns_client_->CompleteDelayedTransactions();
7695 EXPECT_THAT(response.result_error(), IsOk());
7696 }
7697
7698 // Test that in-progress queries are cancelled on applying new DNS config
7699 // overrides, same as receiving a new DnsConfig from the system.
TEST_F(HostResolverManagerDnsTest,CancelQueriesOnSettingOverrides)7700 TEST_F(HostResolverManagerDnsTest, CancelQueriesOnSettingOverrides) {
7701 ChangeDnsConfig(CreateValidDnsConfig());
7702 ResolveHostResponseHelper response(resolver_->CreateRequest(
7703 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7704 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7705 ASSERT_FALSE(response.complete());
7706
7707 DnsConfigOverrides overrides;
7708 overrides.attempts = 123;
7709 resolver_->SetDnsConfigOverrides(overrides);
7710
7711 EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
7712 }
7713
7714 // Queries should not be cancelled if equal overrides are set.
TEST_F(HostResolverManagerDnsTest,CancelQueriesOnSettingOverrides_SameOverrides)7715 TEST_F(HostResolverManagerDnsTest,
7716 CancelQueriesOnSettingOverrides_SameOverrides) {
7717 ChangeDnsConfig(CreateValidDnsConfig());
7718 DnsConfigOverrides overrides;
7719 overrides.attempts = 123;
7720 resolver_->SetDnsConfigOverrides(overrides);
7721
7722 ResolveHostResponseHelper response(resolver_->CreateRequest(
7723 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7724 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7725 ASSERT_FALSE(response.complete());
7726
7727 resolver_->SetDnsConfigOverrides(overrides);
7728
7729 dns_client_->CompleteDelayedTransactions();
7730 EXPECT_THAT(response.result_error(), IsOk());
7731 }
7732
7733 // Test that in-progress queries are cancelled on clearing DNS config overrides,
7734 // same as receiving a new DnsConfig from the system.
TEST_F(HostResolverManagerDnsTest,CancelQueriesOnClearingOverrides)7735 TEST_F(HostResolverManagerDnsTest, CancelQueriesOnClearingOverrides) {
7736 ChangeDnsConfig(CreateValidDnsConfig());
7737 DnsConfigOverrides overrides;
7738 overrides.attempts = 123;
7739 resolver_->SetDnsConfigOverrides(overrides);
7740
7741 ResolveHostResponseHelper response(resolver_->CreateRequest(
7742 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7743 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7744 ASSERT_FALSE(response.complete());
7745
7746 resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
7747
7748 EXPECT_THAT(response.result_error(), IsError(ERR_NETWORK_CHANGED));
7749 }
7750
7751 // Queries should not be cancelled on clearing overrides if there were not any
7752 // overrides.
TEST_F(HostResolverManagerDnsTest,CancelQueriesOnClearingOverrides_NoOverrides)7753 TEST_F(HostResolverManagerDnsTest,
7754 CancelQueriesOnClearingOverrides_NoOverrides) {
7755 ChangeDnsConfig(CreateValidDnsConfig());
7756 ResolveHostResponseHelper response(resolver_->CreateRequest(
7757 HostPortPair("4slow_ok", 80), NetworkIsolationKey(), NetLogWithSource(),
7758 base::nullopt, resolve_context_.get(), resolve_context_->host_cache()));
7759 ASSERT_FALSE(response.complete());
7760
7761 resolver_->SetDnsConfigOverrides(DnsConfigOverrides());
7762
7763 dns_client_->CompleteDelayedTransactions();
7764 EXPECT_THAT(response.result_error(), IsOk());
7765 }
7766
TEST_F(HostResolverManagerDnsTest,FlushContextSessionDataOnSystemConfigChange)7767 TEST_F(HostResolverManagerDnsTest,
7768 FlushContextSessionDataOnSystemConfigChange) {
7769 DnsConfig original_config = CreateValidDnsConfig();
7770 ChangeDnsConfig(original_config);
7771
7772 DnsSession* session_before = dns_client_->GetCurrentSession();
7773 resolve_context_->RecordServerSuccess(
7774 0u /* server_index */, true /* is_doh_server */, session_before);
7775 ASSERT_TRUE(resolve_context_->GetDohServerAvailability(0u, session_before));
7776
7777 // Flush data by triggering a config change.
7778 DnsConfig new_config = original_config;
7779 new_config.attempts = 103;
7780 ChangeDnsConfig(new_config);
7781
7782 DnsSession* session_after = dns_client_->GetCurrentSession();
7783 EXPECT_NE(session_before, session_after);
7784
7785 EXPECT_FALSE(resolve_context_->GetDohServerAvailability(0u, session_after));
7786
7787 // Confirm new session is in use.
7788 resolve_context_->RecordServerSuccess(
7789 0u /* server_index */, true /* is_doh_server */, session_after);
7790 EXPECT_TRUE(resolve_context_->GetDohServerAvailability(0u, session_after));
7791 }
7792
TEST_F(HostResolverManagerDnsTest,TxtQuery)7793 TEST_F(HostResolverManagerDnsTest, TxtQuery) {
7794 // Simulate two separate DNS records, each with multiple strings.
7795 std::vector<std::string> foo_records = {"foo1", "foo2", "foo3"};
7796 std::vector<std::string> bar_records = {"bar1", "bar2"};
7797 std::vector<std::vector<std::string>> text_records = {foo_records,
7798 bar_records};
7799
7800 MockDnsClientRuleList rules;
7801 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7802 MockDnsClientRule::Result(BuildTestDnsTextResponse(
7803 "host", std::move(text_records))),
7804 false /* delay */);
7805
7806 CreateResolver();
7807 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7808
7809 HostResolver::ResolveHostParameters parameters;
7810 parameters.dns_query_type = DnsQueryType::TXT;
7811
7812 ResolveHostResponseHelper response(resolver_->CreateRequest(
7813 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7814 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7815 EXPECT_THAT(response.result_error(), IsOk());
7816 EXPECT_FALSE(response.request()->GetAddressResults());
7817 EXPECT_FALSE(response.request()->GetHostnameResults());
7818 EXPECT_FALSE(response.request()->GetEsniResults());
7819
7820 // Order between separate DNS records is undefined, but each record should
7821 // stay in order as that order may be meaningful.
7822 ASSERT_THAT(response.request()->GetTextResults(),
7823 testing::Optional(testing::UnorderedElementsAre(
7824 "foo1", "foo2", "foo3", "bar1", "bar2")));
7825 std::vector<std::string> results =
7826 response.request()->GetTextResults().value();
7827 EXPECT_NE(results.end(), std::search(results.begin(), results.end(),
7828 foo_records.begin(), foo_records.end()));
7829 EXPECT_NE(results.end(), std::search(results.begin(), results.end(),
7830 bar_records.begin(), bar_records.end()));
7831 }
7832
TEST_F(HostResolverManagerDnsTest,TxtQuery_InvalidConfig)7833 TEST_F(HostResolverManagerDnsTest, TxtQuery_InvalidConfig) {
7834 set_allow_fallback_to_proctask(false);
7835 // Set empty DnsConfig.
7836 InvalidateDnsConfig();
7837
7838 HostResolver::ResolveHostParameters parameters;
7839 parameters.dns_query_type = DnsQueryType::TXT;
7840
7841 ResolveHostResponseHelper response(resolver_->CreateRequest(
7842 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7843 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7844 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_CACHE_MISS));
7845 }
7846
TEST_F(HostResolverManagerDnsTest,TxtQuery_NonexistentDomain)7847 TEST_F(HostResolverManagerDnsTest, TxtQuery_NonexistentDomain) {
7848 // Setup fallback to confirm it is not used for non-address results.
7849 set_allow_fallback_to_proctask(true);
7850 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
7851 proc_->SignalMultiple(1u);
7852
7853 MockDnsClientRuleList rules;
7854 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7855 MockDnsClientRule::Result(MockDnsClientRule::NODOMAIN),
7856 false /* delay */);
7857
7858 CreateResolver();
7859 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7860
7861 HostResolver::ResolveHostParameters parameters;
7862 parameters.dns_query_type = DnsQueryType::TXT;
7863
7864 ResolveHostResponseHelper response(resolver_->CreateRequest(
7865 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7866 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7867 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
7868 EXPECT_FALSE(response.request()->GetAddressResults());
7869 EXPECT_FALSE(response.request()->GetTextResults());
7870 EXPECT_FALSE(response.request()->GetHostnameResults());
7871 EXPECT_FALSE(response.request()->GetEsniResults());
7872 }
7873
TEST_F(HostResolverManagerDnsTest,TxtQuery_Failure)7874 TEST_F(HostResolverManagerDnsTest, TxtQuery_Failure) {
7875 // Setup fallback to confirm it is not used for non-address results.
7876 set_allow_fallback_to_proctask(true);
7877 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
7878 proc_->SignalMultiple(1u);
7879
7880 MockDnsClientRuleList rules;
7881 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7882 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
7883 false /* delay */);
7884
7885 CreateResolver();
7886 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7887
7888 HostResolver::ResolveHostParameters parameters;
7889 parameters.dns_query_type = DnsQueryType::TXT;
7890
7891 ResolveHostResponseHelper response(resolver_->CreateRequest(
7892 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7893 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7894 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
7895 EXPECT_FALSE(response.request()->GetAddressResults());
7896 EXPECT_FALSE(response.request()->GetTextResults());
7897 EXPECT_FALSE(response.request()->GetHostnameResults());
7898 EXPECT_FALSE(response.request()->GetEsniResults());
7899 }
7900
TEST_F(HostResolverManagerDnsTest,TxtQuery_Timeout)7901 TEST_F(HostResolverManagerDnsTest, TxtQuery_Timeout) {
7902 // Setup fallback to confirm it is not used for non-address results.
7903 set_allow_fallback_to_proctask(true);
7904 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
7905 proc_->SignalMultiple(1u);
7906
7907 MockDnsClientRuleList rules;
7908 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7909 MockDnsClientRule::Result(MockDnsClientRule::TIMEOUT),
7910 false /* delay */);
7911
7912 CreateResolver();
7913 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7914
7915 HostResolver::ResolveHostParameters parameters;
7916 parameters.dns_query_type = DnsQueryType::TXT;
7917
7918 ResolveHostResponseHelper response(resolver_->CreateRequest(
7919 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7920 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7921 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
7922 EXPECT_FALSE(response.request()->GetAddressResults());
7923 EXPECT_FALSE(response.request()->GetTextResults());
7924 EXPECT_FALSE(response.request()->GetHostnameResults());
7925 EXPECT_FALSE(response.request()->GetEsniResults());
7926 }
7927
TEST_F(HostResolverManagerDnsTest,TxtQuery_Empty)7928 TEST_F(HostResolverManagerDnsTest, TxtQuery_Empty) {
7929 // Setup fallback to confirm it is not used for non-address results.
7930 set_allow_fallback_to_proctask(true);
7931 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
7932 proc_->SignalMultiple(1u);
7933
7934 MockDnsClientRuleList rules;
7935 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7936 MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
7937 false /* delay */);
7938
7939 CreateResolver();
7940 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7941
7942 HostResolver::ResolveHostParameters parameters;
7943 parameters.dns_query_type = DnsQueryType::TXT;
7944
7945 ResolveHostResponseHelper response(resolver_->CreateRequest(
7946 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7947 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7948 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
7949 EXPECT_FALSE(response.request()->GetAddressResults());
7950 EXPECT_FALSE(response.request()->GetTextResults());
7951 EXPECT_FALSE(response.request()->GetHostnameResults());
7952 EXPECT_FALSE(response.request()->GetEsniResults());
7953 }
7954
TEST_F(HostResolverManagerDnsTest,TxtQuery_Malformed)7955 TEST_F(HostResolverManagerDnsTest, TxtQuery_Malformed) {
7956 // Setup fallback to confirm it is not used for non-address results.
7957 set_allow_fallback_to_proctask(true);
7958 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
7959 proc_->SignalMultiple(1u);
7960
7961 MockDnsClientRuleList rules;
7962 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7963 MockDnsClientRule::Result(MockDnsClientRule::MALFORMED),
7964 false /* delay */);
7965
7966 CreateResolver();
7967 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7968
7969 HostResolver::ResolveHostParameters parameters;
7970 parameters.dns_query_type = DnsQueryType::TXT;
7971
7972 ResolveHostResponseHelper response(resolver_->CreateRequest(
7973 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7974 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7975 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
7976 EXPECT_FALSE(response.request()->GetAddressResults());
7977 EXPECT_FALSE(response.request()->GetTextResults());
7978 EXPECT_FALSE(response.request()->GetHostnameResults());
7979 EXPECT_FALSE(response.request()->GetEsniResults());
7980 }
7981
TEST_F(HostResolverManagerDnsTest,TxtQuery_MismatchedName)7982 TEST_F(HostResolverManagerDnsTest, TxtQuery_MismatchedName) {
7983 std::vector<std::vector<std::string>> text_records = {{"text"}};
7984 MockDnsClientRuleList rules;
7985 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
7986 MockDnsClientRule::Result(BuildTestDnsTextResponse(
7987 "host", std::move(text_records), "not.host")),
7988 false /* delay */);
7989
7990 CreateResolver();
7991 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
7992
7993 HostResolver::ResolveHostParameters parameters;
7994 parameters.dns_query_type = DnsQueryType::TXT;
7995
7996 ResolveHostResponseHelper response(resolver_->CreateRequest(
7997 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
7998 parameters, resolve_context_.get(), resolve_context_->host_cache()));
7999 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
8000 EXPECT_FALSE(response.request()->GetAddressResults());
8001 EXPECT_FALSE(response.request()->GetTextResults());
8002 EXPECT_FALSE(response.request()->GetHostnameResults());
8003 EXPECT_FALSE(response.request()->GetEsniResults());
8004 }
8005
TEST_F(HostResolverManagerDnsTest,TxtQuery_WrongType)8006 TEST_F(HostResolverManagerDnsTest, TxtQuery_WrongType) {
8007 // Respond to a TXT query with an A response.
8008 MockDnsClientRuleList rules;
8009 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
8010 MockDnsClientRule::Result(
8011 BuildTestDnsResponse("host", IPAddress(1, 2, 3, 4))),
8012 false /* delay */);
8013
8014 CreateResolver();
8015 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8016
8017 HostResolver::ResolveHostParameters parameters;
8018 parameters.dns_query_type = DnsQueryType::TXT;
8019
8020 // Responses for the wrong type should be ignored.
8021 ResolveHostResponseHelper response(resolver_->CreateRequest(
8022 HostPortPair("ok", 108), NetworkIsolationKey(), NetLogWithSource(),
8023 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8024 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8025 EXPECT_FALSE(response.request()->GetAddressResults());
8026 EXPECT_FALSE(response.request()->GetTextResults());
8027 EXPECT_FALSE(response.request()->GetHostnameResults());
8028 EXPECT_FALSE(response.request()->GetEsniResults());
8029 }
8030
8031 // Same as TxtQuery except we specify DNS HostResolverSource instead of relying
8032 // on automatic determination. Expect same results since DNS should be what we
8033 // automatically determine, but some slightly different logic paths are
8034 // involved.
TEST_F(HostResolverManagerDnsTest,TxtDnsQuery)8035 TEST_F(HostResolverManagerDnsTest, TxtDnsQuery) {
8036 // Simulate two separate DNS records, each with multiple strings.
8037 std::vector<std::string> foo_records = {"foo1", "foo2", "foo3"};
8038 std::vector<std::string> bar_records = {"bar1", "bar2"};
8039 std::vector<std::vector<std::string>> text_records = {foo_records,
8040 bar_records};
8041
8042 MockDnsClientRuleList rules;
8043 rules.emplace_back("host", dns_protocol::kTypeTXT, false /* secure */,
8044 MockDnsClientRule::Result(BuildTestDnsTextResponse(
8045 "host", std::move(text_records))),
8046 false /* delay */);
8047
8048 CreateResolver();
8049 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8050
8051 HostResolver::ResolveHostParameters parameters;
8052 parameters.source = HostResolverSource::DNS;
8053 parameters.dns_query_type = DnsQueryType::TXT;
8054
8055 ResolveHostResponseHelper response(resolver_->CreateRequest(
8056 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8057 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8058 EXPECT_THAT(response.result_error(), IsOk());
8059 EXPECT_FALSE(response.request()->GetAddressResults());
8060 EXPECT_FALSE(response.request()->GetHostnameResults());
8061 EXPECT_FALSE(response.request()->GetEsniResults());
8062
8063 // Order between separate DNS records is undefined, but each record should
8064 // stay in order as that order may be meaningful.
8065 ASSERT_THAT(response.request()->GetTextResults(),
8066 testing::Optional(testing::UnorderedElementsAre(
8067 "foo1", "foo2", "foo3", "bar1", "bar2")));
8068 std::vector<std::string> results =
8069 response.request()->GetTextResults().value();
8070 EXPECT_NE(results.end(), std::search(results.begin(), results.end(),
8071 foo_records.begin(), foo_records.end()));
8072 EXPECT_NE(results.end(), std::search(results.begin(), results.end(),
8073 bar_records.begin(), bar_records.end()));
8074 }
8075
TEST_F(HostResolverManagerDnsTest,PtrQuery)8076 TEST_F(HostResolverManagerDnsTest, PtrQuery) {
8077 MockDnsClientRuleList rules;
8078 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8079 MockDnsClientRule::Result(BuildTestDnsPointerResponse(
8080 "host", {"foo.com", "bar.com"})),
8081 false /* delay */);
8082
8083 CreateResolver();
8084 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8085
8086 HostResolver::ResolveHostParameters parameters;
8087 parameters.dns_query_type = DnsQueryType::PTR;
8088
8089 ResolveHostResponseHelper response(resolver_->CreateRequest(
8090 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8091 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8092 EXPECT_THAT(response.result_error(), IsOk());
8093 EXPECT_FALSE(response.request()->GetAddressResults());
8094 EXPECT_FALSE(response.request()->GetTextResults());
8095 EXPECT_FALSE(response.request()->GetEsniResults());
8096
8097 // Order between separate records is undefined.
8098 EXPECT_THAT(response.request()->GetHostnameResults(),
8099 testing::Optional(testing::UnorderedElementsAre(
8100 HostPortPair("foo.com", 108), HostPortPair("bar.com", 108))));
8101 }
8102
TEST_F(HostResolverManagerDnsTest,PtrQuery_Ip)8103 TEST_F(HostResolverManagerDnsTest, PtrQuery_Ip) {
8104 MockDnsClientRuleList rules;
8105 rules.emplace_back("8.8.8.8", dns_protocol::kTypePTR, false /* secure */,
8106 MockDnsClientRule::Result(BuildTestDnsPointerResponse(
8107 "8.8.8.8", {"foo.com", "bar.com"})),
8108 false /* delay */);
8109
8110 CreateResolver();
8111 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8112
8113 HostResolver::ResolveHostParameters parameters;
8114 parameters.dns_query_type = DnsQueryType::PTR;
8115
8116 ResolveHostResponseHelper response(resolver_->CreateRequest(
8117 HostPortPair("8.8.8.8", 108), NetworkIsolationKey(), NetLogWithSource(),
8118 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8119 EXPECT_THAT(response.result_error(), IsOk());
8120 EXPECT_FALSE(response.request()->GetAddressResults());
8121 EXPECT_FALSE(response.request()->GetTextResults());
8122 EXPECT_FALSE(response.request()->GetEsniResults());
8123
8124 // Order between separate records is undefined.
8125 EXPECT_THAT(response.request()->GetHostnameResults(),
8126 testing::Optional(testing::UnorderedElementsAre(
8127 HostPortPair("foo.com", 108), HostPortPair("bar.com", 108))));
8128 }
8129
TEST_F(HostResolverManagerDnsTest,PtrQuery_NonexistentDomain)8130 TEST_F(HostResolverManagerDnsTest, PtrQuery_NonexistentDomain) {
8131 // Setup fallback to confirm it is not used for non-address results.
8132 set_allow_fallback_to_proctask(true);
8133 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8134 proc_->SignalMultiple(1u);
8135
8136 MockDnsClientRuleList rules;
8137 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8138 MockDnsClientRule::Result(MockDnsClientRule::NODOMAIN),
8139 false /* delay */);
8140
8141 CreateResolver();
8142 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8143
8144 HostResolver::ResolveHostParameters parameters;
8145 parameters.dns_query_type = DnsQueryType::PTR;
8146
8147 ResolveHostResponseHelper response(resolver_->CreateRequest(
8148 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8149 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8150 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8151 EXPECT_FALSE(response.request()->GetAddressResults());
8152 EXPECT_FALSE(response.request()->GetTextResults());
8153 EXPECT_FALSE(response.request()->GetHostnameResults());
8154 EXPECT_FALSE(response.request()->GetEsniResults());
8155 }
8156
TEST_F(HostResolverManagerDnsTest,PtrQuery_Failure)8157 TEST_F(HostResolverManagerDnsTest, PtrQuery_Failure) {
8158 // Setup fallback to confirm it is not used for non-address results.
8159 set_allow_fallback_to_proctask(true);
8160 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8161 proc_->SignalMultiple(1u);
8162
8163 MockDnsClientRuleList rules;
8164 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8165 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
8166 false /* delay */);
8167
8168 CreateResolver();
8169 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8170
8171 HostResolver::ResolveHostParameters parameters;
8172 parameters.dns_query_type = DnsQueryType::PTR;
8173
8174 ResolveHostResponseHelper response(resolver_->CreateRequest(
8175 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8176 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8177 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8178 EXPECT_FALSE(response.request()->GetAddressResults());
8179 EXPECT_FALSE(response.request()->GetTextResults());
8180 EXPECT_FALSE(response.request()->GetHostnameResults());
8181 EXPECT_FALSE(response.request()->GetEsniResults());
8182 }
8183
TEST_F(HostResolverManagerDnsTest,PtrQuery_Timeout)8184 TEST_F(HostResolverManagerDnsTest, PtrQuery_Timeout) {
8185 // Setup fallback to confirm it is not used for non-address results.
8186 set_allow_fallback_to_proctask(true);
8187 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8188 proc_->SignalMultiple(1u);
8189
8190 MockDnsClientRuleList rules;
8191 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8192 MockDnsClientRule::Result(MockDnsClientRule::TIMEOUT),
8193 false /* delay */);
8194
8195 CreateResolver();
8196 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8197
8198 HostResolver::ResolveHostParameters parameters;
8199 parameters.dns_query_type = DnsQueryType::PTR;
8200
8201 ResolveHostResponseHelper response(resolver_->CreateRequest(
8202 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8203 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8204 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
8205 EXPECT_FALSE(response.request()->GetAddressResults());
8206 EXPECT_FALSE(response.request()->GetTextResults());
8207 EXPECT_FALSE(response.request()->GetHostnameResults());
8208 EXPECT_FALSE(response.request()->GetEsniResults());
8209 }
8210
TEST_F(HostResolverManagerDnsTest,PtrQuery_Empty)8211 TEST_F(HostResolverManagerDnsTest, PtrQuery_Empty) {
8212 // Setup fallback to confirm it is not used for non-address results.
8213 set_allow_fallback_to_proctask(true);
8214 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8215 proc_->SignalMultiple(1u);
8216
8217 MockDnsClientRuleList rules;
8218 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8219 MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
8220 false /* delay */);
8221
8222 CreateResolver();
8223 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8224
8225 HostResolver::ResolveHostParameters parameters;
8226 parameters.dns_query_type = DnsQueryType::PTR;
8227
8228 ResolveHostResponseHelper response(resolver_->CreateRequest(
8229 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8230 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8231 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8232 EXPECT_FALSE(response.request()->GetAddressResults());
8233 EXPECT_FALSE(response.request()->GetTextResults());
8234 EXPECT_FALSE(response.request()->GetHostnameResults());
8235 EXPECT_FALSE(response.request()->GetEsniResults());
8236 }
8237
TEST_F(HostResolverManagerDnsTest,PtrQuery_Malformed)8238 TEST_F(HostResolverManagerDnsTest, PtrQuery_Malformed) {
8239 // Setup fallback to confirm it is not used for non-address results.
8240 set_allow_fallback_to_proctask(true);
8241 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8242 proc_->SignalMultiple(1u);
8243
8244 MockDnsClientRuleList rules;
8245 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8246 MockDnsClientRule::Result(MockDnsClientRule::MALFORMED),
8247 false /* delay */);
8248
8249 CreateResolver();
8250 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8251
8252 HostResolver::ResolveHostParameters parameters;
8253 parameters.dns_query_type = DnsQueryType::PTR;
8254
8255 ResolveHostResponseHelper response(resolver_->CreateRequest(
8256 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8257 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8258 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
8259 EXPECT_FALSE(response.request()->GetAddressResults());
8260 EXPECT_FALSE(response.request()->GetTextResults());
8261 EXPECT_FALSE(response.request()->GetHostnameResults());
8262 EXPECT_FALSE(response.request()->GetEsniResults());
8263 }
8264
TEST_F(HostResolverManagerDnsTest,PtrQuery_MismatchedName)8265 TEST_F(HostResolverManagerDnsTest, PtrQuery_MismatchedName) {
8266 std::vector<std::string> ptr_records = {{"foo.com"}};
8267 MockDnsClientRuleList rules;
8268 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8269 MockDnsClientRule::Result(BuildTestDnsPointerResponse(
8270 "host", std::move(ptr_records), "not.host")),
8271 false /* delay */);
8272
8273 CreateResolver();
8274 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8275
8276 HostResolver::ResolveHostParameters parameters;
8277 parameters.dns_query_type = DnsQueryType::PTR;
8278
8279 ResolveHostResponseHelper response(resolver_->CreateRequest(
8280 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8281 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8282 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
8283 EXPECT_FALSE(response.request()->GetAddressResults());
8284 EXPECT_FALSE(response.request()->GetTextResults());
8285 EXPECT_FALSE(response.request()->GetHostnameResults());
8286 EXPECT_FALSE(response.request()->GetEsniResults());
8287 }
8288
TEST_F(HostResolverManagerDnsTest,PtrQuery_WrongType)8289 TEST_F(HostResolverManagerDnsTest, PtrQuery_WrongType) {
8290 // Respond to a TXT query with an A response.
8291 MockDnsClientRuleList rules;
8292 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8293 MockDnsClientRule::Result(
8294 BuildTestDnsResponse("host", IPAddress(1, 2, 3, 4))),
8295 false /* delay */);
8296
8297 CreateResolver();
8298 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8299
8300 HostResolver::ResolveHostParameters parameters;
8301 parameters.dns_query_type = DnsQueryType::PTR;
8302
8303 // Responses for the wrong type should be ignored.
8304 ResolveHostResponseHelper response(resolver_->CreateRequest(
8305 HostPortPair("ok", 108), NetworkIsolationKey(), NetLogWithSource(),
8306 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8307 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8308 EXPECT_FALSE(response.request()->GetAddressResults());
8309 EXPECT_FALSE(response.request()->GetTextResults());
8310 EXPECT_FALSE(response.request()->GetHostnameResults());
8311 EXPECT_FALSE(response.request()->GetEsniResults());
8312 }
8313
8314 // Same as PtrQuery except we specify DNS HostResolverSource instead of relying
8315 // on automatic determination. Expect same results since DNS should be what we
8316 // automatically determine, but some slightly different logic paths are
8317 // involved.
TEST_F(HostResolverManagerDnsTest,PtrDnsQuery)8318 TEST_F(HostResolverManagerDnsTest, PtrDnsQuery) {
8319 MockDnsClientRuleList rules;
8320 rules.emplace_back("host", dns_protocol::kTypePTR, false /* secure */,
8321 MockDnsClientRule::Result(BuildTestDnsPointerResponse(
8322 "host", {"foo.com", "bar.com"})),
8323 false /* delay */);
8324
8325 CreateResolver();
8326 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8327
8328 HostResolver::ResolveHostParameters parameters;
8329 parameters.source = HostResolverSource::DNS;
8330 parameters.dns_query_type = DnsQueryType::PTR;
8331
8332 ResolveHostResponseHelper response(resolver_->CreateRequest(
8333 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8334 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8335 EXPECT_THAT(response.result_error(), IsOk());
8336 EXPECT_FALSE(response.request()->GetAddressResults());
8337 EXPECT_FALSE(response.request()->GetTextResults());
8338 EXPECT_FALSE(response.request()->GetEsniResults());
8339
8340 // Order between separate records is undefined.
8341 EXPECT_THAT(response.request()->GetHostnameResults(),
8342 testing::Optional(testing::UnorderedElementsAre(
8343 HostPortPair("foo.com", 108), HostPortPair("bar.com", 108))));
8344 }
8345
TEST_F(HostResolverManagerDnsTest,SrvQuery)8346 TEST_F(HostResolverManagerDnsTest, SrvQuery) {
8347 const TestServiceRecord kRecord1 = {2, 3, 1223, "foo.com"};
8348 const TestServiceRecord kRecord2 = {5, 10, 80, "bar.com"};
8349 const TestServiceRecord kRecord3 = {5, 1, 5, "google.com"};
8350 const TestServiceRecord kRecord4 = {2, 100, 12345, "chromium.org"};
8351 MockDnsClientRuleList rules;
8352 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8353 MockDnsClientRule::Result(BuildTestDnsServiceResponse(
8354 "host", {kRecord1, kRecord2, kRecord3, kRecord4})),
8355 false /* delay */);
8356
8357 CreateResolver();
8358 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8359
8360 HostResolver::ResolveHostParameters parameters;
8361 parameters.dns_query_type = DnsQueryType::SRV;
8362
8363 ResolveHostResponseHelper response(resolver_->CreateRequest(
8364 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8365 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8366 EXPECT_THAT(response.result_error(), IsOk());
8367 EXPECT_FALSE(response.request()->GetAddressResults());
8368 EXPECT_FALSE(response.request()->GetTextResults());
8369 EXPECT_FALSE(response.request()->GetEsniResults());
8370
8371 // Expect ordered by priority, and random within a priority.
8372 base::Optional<std::vector<HostPortPair>> results =
8373 response.request()->GetHostnameResults();
8374 ASSERT_THAT(
8375 results,
8376 testing::Optional(testing::UnorderedElementsAre(
8377 HostPortPair("foo.com", 1223), HostPortPair("bar.com", 80),
8378 HostPortPair("google.com", 5), HostPortPair("chromium.org", 12345))));
8379 auto priority2 = std::vector<HostPortPair>(results.value().begin(),
8380 results.value().begin() + 2);
8381 EXPECT_THAT(priority2, testing::UnorderedElementsAre(
8382 HostPortPair("foo.com", 1223),
8383 HostPortPair("chromium.org", 12345)));
8384 auto priority5 = std::vector<HostPortPair>(results.value().begin() + 2,
8385 results.value().end());
8386 EXPECT_THAT(priority5,
8387 testing::UnorderedElementsAre(HostPortPair("bar.com", 80),
8388 HostPortPair("google.com", 5)));
8389 }
8390
8391 // 0-weight services are allowed. Ensure that we can handle such records,
8392 // especially the case where all entries have weight 0.
TEST_F(HostResolverManagerDnsTest,SrvQuery_ZeroWeight)8393 TEST_F(HostResolverManagerDnsTest, SrvQuery_ZeroWeight) {
8394 const TestServiceRecord kRecord1 = {5, 0, 80, "bar.com"};
8395 const TestServiceRecord kRecord2 = {5, 0, 5, "google.com"};
8396 MockDnsClientRuleList rules;
8397 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8398 MockDnsClientRule::Result(BuildTestDnsServiceResponse(
8399 "host", {kRecord1, kRecord2})),
8400 false /* delay */);
8401
8402 CreateResolver();
8403 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8404
8405 HostResolver::ResolveHostParameters parameters;
8406 parameters.dns_query_type = DnsQueryType::SRV;
8407
8408 ResolveHostResponseHelper response(resolver_->CreateRequest(
8409 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8410 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8411 EXPECT_THAT(response.result_error(), IsOk());
8412 EXPECT_FALSE(response.request()->GetAddressResults());
8413 EXPECT_FALSE(response.request()->GetTextResults());
8414 EXPECT_FALSE(response.request()->GetEsniResults());
8415
8416 // Expect ordered by priority, and random within a priority.
8417 EXPECT_THAT(response.request()->GetHostnameResults(),
8418 testing::Optional(testing::UnorderedElementsAre(
8419 HostPortPair("bar.com", 80), HostPortPair("google.com", 5))));
8420 }
8421
TEST_F(HostResolverManagerDnsTest,SrvQuery_NonexistentDomain)8422 TEST_F(HostResolverManagerDnsTest, SrvQuery_NonexistentDomain) {
8423 // Setup fallback to confirm it is not used for non-address results.
8424 set_allow_fallback_to_proctask(true);
8425 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8426 proc_->SignalMultiple(1u);
8427
8428 MockDnsClientRuleList rules;
8429 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8430 MockDnsClientRule::Result(MockDnsClientRule::NODOMAIN),
8431 false /* delay */);
8432
8433 CreateResolver();
8434 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8435
8436 HostResolver::ResolveHostParameters parameters;
8437 parameters.dns_query_type = DnsQueryType::SRV;
8438
8439 ResolveHostResponseHelper response(resolver_->CreateRequest(
8440 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8441 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8442 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8443 EXPECT_FALSE(response.request()->GetAddressResults());
8444 EXPECT_FALSE(response.request()->GetTextResults());
8445 EXPECT_FALSE(response.request()->GetHostnameResults());
8446 EXPECT_FALSE(response.request()->GetEsniResults());
8447 }
8448
TEST_F(HostResolverManagerDnsTest,SrvQuery_Failure)8449 TEST_F(HostResolverManagerDnsTest, SrvQuery_Failure) {
8450 // Setup fallback to confirm it is not used for non-address results.
8451 set_allow_fallback_to_proctask(true);
8452 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8453 proc_->SignalMultiple(1u);
8454
8455 MockDnsClientRuleList rules;
8456 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8457 MockDnsClientRule::Result(MockDnsClientRule::FAIL),
8458 false /* delay */);
8459
8460 CreateResolver();
8461 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8462
8463 HostResolver::ResolveHostParameters parameters;
8464 parameters.dns_query_type = DnsQueryType::SRV;
8465
8466 ResolveHostResponseHelper response(resolver_->CreateRequest(
8467 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8468 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8469 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8470 EXPECT_FALSE(response.request()->GetAddressResults());
8471 EXPECT_FALSE(response.request()->GetTextResults());
8472 EXPECT_FALSE(response.request()->GetHostnameResults());
8473 EXPECT_FALSE(response.request()->GetEsniResults());
8474 }
8475
TEST_F(HostResolverManagerDnsTest,SrvQuery_Timeout)8476 TEST_F(HostResolverManagerDnsTest, SrvQuery_Timeout) {
8477 // Setup fallback to confirm it is not used for non-address results.
8478 set_allow_fallback_to_proctask(true);
8479 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8480 proc_->SignalMultiple(1u);
8481
8482 MockDnsClientRuleList rules;
8483 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8484 MockDnsClientRule::Result(MockDnsClientRule::TIMEOUT),
8485 false /* delay */);
8486
8487 CreateResolver();
8488 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8489
8490 HostResolver::ResolveHostParameters parameters;
8491 parameters.dns_query_type = DnsQueryType::SRV;
8492
8493 ResolveHostResponseHelper response(resolver_->CreateRequest(
8494 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8495 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8496 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
8497 EXPECT_FALSE(response.request()->GetAddressResults());
8498 EXPECT_FALSE(response.request()->GetTextResults());
8499 EXPECT_FALSE(response.request()->GetHostnameResults());
8500 EXPECT_FALSE(response.request()->GetEsniResults());
8501 }
8502
TEST_F(HostResolverManagerDnsTest,SrvQuery_Empty)8503 TEST_F(HostResolverManagerDnsTest, SrvQuery_Empty) {
8504 // Setup fallback to confirm it is not used for non-address results.
8505 set_allow_fallback_to_proctask(true);
8506 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8507 proc_->SignalMultiple(1u);
8508
8509 MockDnsClientRuleList rules;
8510 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8511 MockDnsClientRule::Result(MockDnsClientRule::EMPTY),
8512 false /* delay */);
8513
8514 CreateResolver();
8515 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8516
8517 HostResolver::ResolveHostParameters parameters;
8518 parameters.dns_query_type = DnsQueryType::SRV;
8519
8520 ResolveHostResponseHelper response(resolver_->CreateRequest(
8521 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8522 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8523 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8524 EXPECT_FALSE(response.request()->GetAddressResults());
8525 EXPECT_FALSE(response.request()->GetTextResults());
8526 EXPECT_FALSE(response.request()->GetHostnameResults());
8527 EXPECT_FALSE(response.request()->GetEsniResults());
8528 }
8529
TEST_F(HostResolverManagerDnsTest,SrvQuery_Malformed)8530 TEST_F(HostResolverManagerDnsTest, SrvQuery_Malformed) {
8531 // Setup fallback to confirm it is not used for non-address results.
8532 set_allow_fallback_to_proctask(true);
8533 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8534 proc_->SignalMultiple(1u);
8535
8536 MockDnsClientRuleList rules;
8537 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8538 MockDnsClientRule::Result(MockDnsClientRule::MALFORMED),
8539 false /* delay */);
8540
8541 CreateResolver();
8542 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8543
8544 HostResolver::ResolveHostParameters parameters;
8545 parameters.dns_query_type = DnsQueryType::SRV;
8546
8547 ResolveHostResponseHelper response(resolver_->CreateRequest(
8548 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8549 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8550 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
8551 EXPECT_FALSE(response.request()->GetAddressResults());
8552 EXPECT_FALSE(response.request()->GetTextResults());
8553 EXPECT_FALSE(response.request()->GetHostnameResults());
8554 EXPECT_FALSE(response.request()->GetEsniResults());
8555 }
8556
TEST_F(HostResolverManagerDnsTest,SrvQuery_MismatchedName)8557 TEST_F(HostResolverManagerDnsTest, SrvQuery_MismatchedName) {
8558 std::vector<TestServiceRecord> srv_records = {{1, 2, 3, "foo.com"}};
8559 MockDnsClientRuleList rules;
8560 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8561 MockDnsClientRule::Result(BuildTestDnsServiceResponse(
8562 "host", std::move(srv_records), "not.host")),
8563 false /* delay */);
8564
8565 CreateResolver();
8566 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8567
8568 HostResolver::ResolveHostParameters parameters;
8569 parameters.dns_query_type = DnsQueryType::SRV;
8570
8571 ResolveHostResponseHelper response(resolver_->CreateRequest(
8572 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8573 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8574 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
8575 EXPECT_FALSE(response.request()->GetAddressResults());
8576 EXPECT_FALSE(response.request()->GetTextResults());
8577 EXPECT_FALSE(response.request()->GetHostnameResults());
8578 EXPECT_FALSE(response.request()->GetEsniResults());
8579 }
8580
TEST_F(HostResolverManagerDnsTest,SrvQuery_WrongType)8581 TEST_F(HostResolverManagerDnsTest, SrvQuery_WrongType) {
8582 // Respond to a SRV query with an A response.
8583 MockDnsClientRuleList rules;
8584 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8585 MockDnsClientRule::Result(
8586 BuildTestDnsResponse("host", IPAddress(1, 2, 3, 4))),
8587 false /* delay */);
8588
8589 CreateResolver();
8590 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8591
8592 HostResolver::ResolveHostParameters parameters;
8593 parameters.dns_query_type = DnsQueryType::SRV;
8594
8595 // Responses for the wrong type should be ignored.
8596 ResolveHostResponseHelper response(resolver_->CreateRequest(
8597 HostPortPair("ok", 108), NetworkIsolationKey(), NetLogWithSource(),
8598 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8599 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8600 EXPECT_FALSE(response.request()->GetAddressResults());
8601 EXPECT_FALSE(response.request()->GetTextResults());
8602 EXPECT_FALSE(response.request()->GetHostnameResults());
8603 EXPECT_FALSE(response.request()->GetEsniResults());
8604 }
8605
8606 // Same as SrvQuery except we specify DNS HostResolverSource instead of relying
8607 // on automatic determination. Expect same results since DNS should be what we
8608 // automatically determine, but some slightly different logic paths are
8609 // involved.
TEST_F(HostResolverManagerDnsTest,SrvDnsQuery)8610 TEST_F(HostResolverManagerDnsTest, SrvDnsQuery) {
8611 const TestServiceRecord kRecord1 = {2, 3, 1223, "foo.com"};
8612 const TestServiceRecord kRecord2 = {5, 10, 80, "bar.com"};
8613 const TestServiceRecord kRecord3 = {5, 1, 5, "google.com"};
8614 const TestServiceRecord kRecord4 = {2, 100, 12345, "chromium.org"};
8615 MockDnsClientRuleList rules;
8616 rules.emplace_back("host", dns_protocol::kTypeSRV, false /* secure */,
8617 MockDnsClientRule::Result(BuildTestDnsServiceResponse(
8618 "host", {kRecord1, kRecord2, kRecord3, kRecord4})),
8619 false /* delay */);
8620
8621 CreateResolver();
8622 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8623
8624 HostResolver::ResolveHostParameters parameters;
8625 parameters.source = HostResolverSource::DNS;
8626 parameters.dns_query_type = DnsQueryType::SRV;
8627
8628 ResolveHostResponseHelper response(resolver_->CreateRequest(
8629 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8630 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8631 EXPECT_THAT(response.result_error(), IsOk());
8632 EXPECT_FALSE(response.request()->GetAddressResults());
8633 EXPECT_FALSE(response.request()->GetTextResults());
8634 EXPECT_FALSE(response.request()->GetEsniResults());
8635
8636 // Expect ordered by priority, and random within a priority.
8637 base::Optional<std::vector<HostPortPair>> results =
8638 response.request()->GetHostnameResults();
8639 ASSERT_THAT(
8640 results,
8641 testing::Optional(testing::UnorderedElementsAre(
8642 HostPortPair("foo.com", 1223), HostPortPair("bar.com", 80),
8643 HostPortPair("google.com", 5), HostPortPair("chromium.org", 12345))));
8644 auto priority2 = std::vector<HostPortPair>(results.value().begin(),
8645 results.value().begin() + 2);
8646 EXPECT_THAT(priority2, testing::UnorderedElementsAre(
8647 HostPortPair("foo.com", 1223),
8648 HostPortPair("chromium.org", 12345)));
8649 auto priority5 = std::vector<HostPortPair>(results.value().begin() + 2,
8650 results.value().end());
8651 EXPECT_THAT(priority5,
8652 testing::UnorderedElementsAre(HostPortPair("bar.com", 80),
8653 HostPortPair("google.com", 5)));
8654 }
8655
TEST_F(HostResolverManagerDnsTest,DohProbeRequest)8656 TEST_F(HostResolverManagerDnsTest, DohProbeRequest) {
8657 ChangeDnsConfig(CreateValidDnsConfig());
8658
8659 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8660
8661 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8662 resolver_->CreateDohProbeRequest(resolve_context_.get());
8663 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8664
8665 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8666
8667 request.reset();
8668
8669 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8670 }
8671
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_ExplicitCancel)8672 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_ExplicitCancel) {
8673 ChangeDnsConfig(CreateValidDnsConfig());
8674
8675 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8676 resolver_->CreateDohProbeRequest(resolve_context_.get());
8677 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8678 ASSERT_TRUE(dns_client_->factory()->doh_probes_running());
8679
8680 request->Cancel();
8681
8682 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8683 }
8684
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_ExplicitCancel_NotStarted)8685 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_ExplicitCancel_NotStarted) {
8686 ChangeDnsConfig(CreateValidDnsConfig());
8687
8688 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8689 resolver_->CreateDohProbeRequest(resolve_context_.get());
8690
8691 request->Cancel();
8692
8693 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8694 }
8695
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_ExplicitCancel_AfterManagerDestruction)8696 TEST_F(HostResolverManagerDnsTest,
8697 DohProbeRequest_ExplicitCancel_AfterManagerDestruction) {
8698 ChangeDnsConfig(CreateValidDnsConfig());
8699
8700 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8701 resolver_->CreateDohProbeRequest(resolve_context_.get());
8702 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8703 ASSERT_TRUE(dns_client_->factory()->doh_probes_running());
8704
8705 DestroyResolver();
8706 request->Cancel();
8707 }
8708
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_BeforeConfig)8709 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_BeforeConfig) {
8710 InvalidateDnsConfig();
8711
8712 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8713 resolver_->CreateDohProbeRequest(resolve_context_.get());
8714 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8715 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8716
8717 ChangeDnsConfig(CreateValidDnsConfig());
8718 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8719 }
8720
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_InvalidateConfig)8721 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_InvalidateConfig) {
8722 ChangeDnsConfig(CreateValidDnsConfig());
8723
8724 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8725 resolver_->CreateDohProbeRequest(resolve_context_.get());
8726 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8727 ASSERT_TRUE(dns_client_->factory()->doh_probes_running());
8728
8729 InvalidateDnsConfig();
8730
8731 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8732 }
8733
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_CancelBeforeConfig)8734 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_CancelBeforeConfig) {
8735 InvalidateDnsConfig();
8736
8737 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8738 resolver_->CreateDohProbeRequest(resolve_context_.get());
8739 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8740 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8741
8742 request->Cancel();
8743
8744 ChangeDnsConfig(CreateValidDnsConfig());
8745 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8746 }
8747
TEST_F(HostResolverManagerDnsTest,DohProbeRequest_RestartOnConnectionChange)8748 TEST_F(HostResolverManagerDnsTest, DohProbeRequest_RestartOnConnectionChange) {
8749 DestroyResolver();
8750 test::ScopedMockNetworkChangeNotifier notifier;
8751 CreateSerialResolver();
8752 notifier.mock_network_change_notifier()->SetConnectionType(
8753 NetworkChangeNotifier::CONNECTION_NONE);
8754 ChangeDnsConfig(CreateValidDnsConfig());
8755
8756 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request =
8757 resolver_->CreateDohProbeRequest(resolve_context_.get());
8758 EXPECT_THAT(request->Start(), IsError(ERR_IO_PENDING));
8759 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8760 dns_client_->factory()->CompleteDohProbeRuners();
8761 ASSERT_FALSE(dns_client_->factory()->doh_probes_running());
8762
8763 notifier.mock_network_change_notifier()->SetConnectionTypeAndNotifyObservers(
8764 NetworkChangeNotifier::CONNECTION_NONE);
8765
8766 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8767 }
8768
TEST_F(HostResolverManagerDnsTest,MultipleDohProbeRequests)8769 TEST_F(HostResolverManagerDnsTest, MultipleDohProbeRequests) {
8770 ChangeDnsConfig(CreateValidDnsConfig());
8771
8772 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8773
8774 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request1 =
8775 resolver_->CreateDohProbeRequest(resolve_context_.get());
8776 EXPECT_THAT(request1->Start(), IsError(ERR_IO_PENDING));
8777 std::unique_ptr<HostResolverManager::CancellableProbeRequest> request2 =
8778 resolver_->CreateDohProbeRequest(resolve_context_.get());
8779 EXPECT_THAT(request2->Start(), IsError(ERR_IO_PENDING));
8780
8781 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8782
8783 request1.reset();
8784 EXPECT_TRUE(dns_client_->factory()->doh_probes_running());
8785
8786 request2.reset();
8787 EXPECT_FALSE(dns_client_->factory()->doh_probes_running());
8788 }
8789
TEST_F(HostResolverManagerDnsTest,EsniQuery)8790 TEST_F(HostResolverManagerDnsTest, EsniQuery) {
8791 EsniContent c1, c2, c3;
8792 IPAddress a1(1, 2, 3, 4), a2(5, 6, 7, 8);
8793 IPAddress a3(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
8794
8795 std::string kKey1 = GenerateWellFormedEsniKeys("a");
8796 std::string kKey2 = GenerateWellFormedEsniKeys("b");
8797 std::string kKey3 = GenerateWellFormedEsniKeys("c");
8798
8799 c1.AddKey(kKey1);
8800
8801 c2.AddKeyForAddress(a1, kKey2);
8802 c2.AddKeyForAddress(a2, kKey2);
8803 c2.AddKeyForAddress(a3, kKey2);
8804
8805 c3.AddKeyForAddress(a1, kKey3);
8806
8807 std::vector<EsniContent> esni_records = {c1, c2, c3};
8808
8809 MockDnsClientRuleList rules;
8810 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
8811 false /* secure */,
8812 MockDnsClientRule::Result(BuildTestDnsEsniResponse(
8813 "host", std::move(esni_records))),
8814 false /* delay */);
8815
8816 CreateResolver();
8817 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8818
8819 HostResolver::ResolveHostParameters parameters;
8820 parameters.dns_query_type = DnsQueryType::ESNI;
8821
8822 ResolveHostResponseHelper response(resolver_->CreateRequest(
8823 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8824 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8825 EXPECT_THAT(response.result_error(), IsOk());
8826
8827 EXPECT_FALSE(response.request()->GetHostnameResults());
8828 EXPECT_FALSE(response.request()->GetTextResults());
8829
8830 // The IPv6 address |a3| should come first, and the other
8831 // addresses should have been deduplicated.
8832 EXPECT_THAT(
8833 response.request()->GetAddressResults(),
8834 Optional(AllOf(Property(&AddressList::endpoints,
8835 UnorderedElementsAre(IPEndPoint(a3, 108),
8836 IPEndPoint(a1, 108),
8837 IPEndPoint(a2, 108))),
8838 Property(&AddressList::front, IPEndPoint(a3, 108)))));
8839
8840 // During aggregation of ESNI query results, we drop ESNI keys
8841 // with no associated addresses, like key 1 here. (This is an implementation
8842 // decision declining a "MAY" behavior from the spec.)
8843 // So, we require that only keys 2 and 3 are surfaced.
8844 //
8845 // The Eq() wrappers are necessary here because keys_for_addresses
8846 // returns a container of StringPieces.
8847 EXPECT_THAT(
8848 response.request()->GetEsniResults(),
8849 Optional(AllOf(
8850 Property(&EsniContent::keys,
8851 UnorderedElementsAre(Eq(kKey2), Eq(kKey3))),
8852 Property(&EsniContent::keys_for_addresses,
8853 UnorderedElementsAre(
8854 Pair(a1, UnorderedElementsAre(Eq(kKey2), Eq(kKey3))),
8855 Pair(a2, UnorderedElementsAre(Eq(kKey2))),
8856 Pair(a3, UnorderedElementsAre(Eq(kKey2))))))));
8857 }
8858
TEST_F(HostResolverManagerDnsTest,EsniQuery_InvalidConfig)8859 TEST_F(HostResolverManagerDnsTest, EsniQuery_InvalidConfig) {
8860 set_allow_fallback_to_proctask(false);
8861 // Set empty DnsConfig.
8862 InvalidateDnsConfig();
8863
8864 HostResolver::ResolveHostParameters parameters;
8865 parameters.dns_query_type = DnsQueryType::ESNI;
8866
8867 ResolveHostResponseHelper response(resolver_->CreateRequest(
8868 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8869 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8870 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_CACHE_MISS));
8871 }
8872
TEST_F(HostResolverManagerDnsTest,EsniQuery_NonexistentDomain)8873 TEST_F(HostResolverManagerDnsTest, EsniQuery_NonexistentDomain) {
8874 // Setup fallback to confirm it is not used for non-address results.
8875 set_allow_fallback_to_proctask(true);
8876 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8877 proc_->SignalMultiple(1u);
8878
8879 MockDnsClientRuleList rules;
8880 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
8881 false /* secure */,
8882 MockDnsClientRule::Result(MockDnsClientRule::NODOMAIN),
8883 false /* delay */);
8884
8885 CreateResolver();
8886 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8887
8888 HostResolver::ResolveHostParameters parameters;
8889 parameters.dns_query_type = DnsQueryType::ESNI;
8890
8891 ResolveHostResponseHelper response(resolver_->CreateRequest(
8892 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8893 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8894 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8895 EXPECT_FALSE(response.request()->GetAddressResults());
8896 EXPECT_FALSE(response.request()->GetTextResults());
8897 EXPECT_FALSE(response.request()->GetHostnameResults());
8898 EXPECT_FALSE(response.request()->GetEsniResults());
8899 }
8900
TEST_F(HostResolverManagerDnsTest,EsniQuery_Failure)8901 TEST_F(HostResolverManagerDnsTest, EsniQuery_Failure) {
8902 // Setup fallback to confirm it is not used for non-address results.
8903 set_allow_fallback_to_proctask(true);
8904 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8905 proc_->SignalMultiple(1u);
8906
8907 MockDnsClientRuleList rules;
8908 rules.emplace_back(
8909 "host", dns_protocol::kExperimentalTypeEsniDraft4, false /* secure */,
8910 MockDnsClientRule::Result(MockDnsClientRule::FAIL), false /* delay */);
8911
8912 CreateResolver();
8913 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8914
8915 HostResolver::ResolveHostParameters parameters;
8916 parameters.dns_query_type = DnsQueryType::ESNI;
8917
8918 ResolveHostResponseHelper response(resolver_->CreateRequest(
8919 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8920 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8921 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8922 EXPECT_FALSE(response.request()->GetAddressResults());
8923 EXPECT_FALSE(response.request()->GetTextResults());
8924 EXPECT_FALSE(response.request()->GetHostnameResults());
8925 EXPECT_FALSE(response.request()->GetEsniResults());
8926 }
8927
TEST_F(HostResolverManagerDnsTest,EsniQuery_Timeout)8928 TEST_F(HostResolverManagerDnsTest, EsniQuery_Timeout) {
8929 // Setup fallback to confirm it is not used for non-address results.
8930 set_allow_fallback_to_proctask(true);
8931 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8932 proc_->SignalMultiple(1u);
8933
8934 MockDnsClientRuleList rules;
8935 rules.emplace_back(
8936 "host", dns_protocol::kExperimentalTypeEsniDraft4, false /* secure */,
8937 MockDnsClientRule::Result(MockDnsClientRule::TIMEOUT), false /* delay */);
8938
8939 CreateResolver();
8940 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8941
8942 HostResolver::ResolveHostParameters parameters;
8943 parameters.dns_query_type = DnsQueryType::ESNI;
8944
8945 ResolveHostResponseHelper response(resolver_->CreateRequest(
8946 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8947 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8948 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_TIMED_OUT));
8949 EXPECT_FALSE(response.request()->GetAddressResults());
8950 EXPECT_FALSE(response.request()->GetTextResults());
8951 EXPECT_FALSE(response.request()->GetHostnameResults());
8952 EXPECT_FALSE(response.request()->GetEsniResults());
8953 }
8954
TEST_F(HostResolverManagerDnsTest,EsniQuery_Empty)8955 TEST_F(HostResolverManagerDnsTest, EsniQuery_Empty) {
8956 // Setup fallback to confirm it is not used for non-address results.
8957 set_allow_fallback_to_proctask(true);
8958 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8959 proc_->SignalMultiple(1u);
8960
8961 MockDnsClientRuleList rules;
8962 rules.emplace_back(
8963 "host", dns_protocol::kExperimentalTypeEsniDraft4, false /* secure */,
8964 MockDnsClientRule::Result(MockDnsClientRule::EMPTY), false /* delay */);
8965
8966 CreateResolver();
8967 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8968
8969 HostResolver::ResolveHostParameters parameters;
8970 parameters.dns_query_type = DnsQueryType::ESNI;
8971
8972 ResolveHostResponseHelper response(resolver_->CreateRequest(
8973 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
8974 parameters, resolve_context_.get(), resolve_context_->host_cache()));
8975 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
8976 EXPECT_FALSE(response.request()->GetAddressResults());
8977 EXPECT_FALSE(response.request()->GetTextResults());
8978 EXPECT_FALSE(response.request()->GetHostnameResults());
8979 EXPECT_FALSE(response.request()->GetEsniResults());
8980 }
8981
TEST_F(HostResolverManagerDnsTest,EsniQuery_Malformed)8982 TEST_F(HostResolverManagerDnsTest, EsniQuery_Malformed) {
8983 // Setup fallback to confirm it is not used for non-address results.
8984 set_allow_fallback_to_proctask(true);
8985 proc_->AddRuleForAllFamilies("host", "192.168.1.102");
8986 proc_->SignalMultiple(1u);
8987
8988 MockDnsClientRuleList rules;
8989 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
8990 false /* secure */,
8991 MockDnsClientRule::Result(MockDnsClientRule::MALFORMED),
8992 false /* delay */);
8993
8994 CreateResolver();
8995 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
8996
8997 HostResolver::ResolveHostParameters parameters;
8998 parameters.dns_query_type = DnsQueryType::ESNI;
8999
9000 ResolveHostResponseHelper response(resolver_->CreateRequest(
9001 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
9002 parameters, resolve_context_.get(), resolve_context_->host_cache()));
9003 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
9004 EXPECT_FALSE(response.request()->GetAddressResults());
9005 EXPECT_FALSE(response.request()->GetTextResults());
9006 EXPECT_FALSE(response.request()->GetHostnameResults());
9007 EXPECT_FALSE(response.request()->GetEsniResults());
9008 }
9009
TEST_F(HostResolverManagerDnsTest,EsniQuery_MismatchedName)9010 TEST_F(HostResolverManagerDnsTest, EsniQuery_MismatchedName) {
9011 EsniContent content;
9012 IPAddress address(1, 2, 3, 4);
9013 std::string key = GenerateWellFormedEsniKeys("a");
9014 content.AddKeyForAddress(address, key);
9015
9016 std::vector<EsniContent> esni_records = {content};
9017
9018 MockDnsClientRuleList rules;
9019 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
9020 false /* secure */,
9021 MockDnsClientRule::Result(BuildTestDnsEsniResponse(
9022 "host", std::move(esni_records), "not.host")),
9023 false /* delay */);
9024
9025 CreateResolver();
9026 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9027
9028 HostResolver::ResolveHostParameters parameters;
9029 parameters.dns_query_type = DnsQueryType::ESNI;
9030
9031 ResolveHostResponseHelper response(resolver_->CreateRequest(
9032 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
9033 parameters, resolve_context_.get(), resolve_context_->host_cache()));
9034 EXPECT_THAT(response.result_error(), IsError(ERR_DNS_MALFORMED_RESPONSE));
9035 EXPECT_FALSE(response.request()->GetAddressResults());
9036 EXPECT_FALSE(response.request()->GetTextResults());
9037 EXPECT_FALSE(response.request()->GetHostnameResults());
9038 EXPECT_FALSE(response.request()->GetEsniResults());
9039 }
9040
TEST_F(HostResolverManagerDnsTest,EsniQuery_WrongType)9041 TEST_F(HostResolverManagerDnsTest, EsniQuery_WrongType) {
9042 // Respond to an ESNI query with an A response.
9043 MockDnsClientRuleList rules;
9044 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
9045 false /* secure */,
9046 MockDnsClientRule::Result(
9047 BuildTestDnsResponse("host", IPAddress(1, 2, 3, 4))),
9048 false /* delay */);
9049
9050 CreateResolver();
9051 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9052
9053 HostResolver::ResolveHostParameters parameters;
9054 parameters.dns_query_type = DnsQueryType::ESNI;
9055
9056 // Responses for the wrong type should be ignored.
9057 ResolveHostResponseHelper response(resolver_->CreateRequest(
9058 HostPortPair("ok", 108), NetworkIsolationKey(), NetLogWithSource(),
9059 parameters, resolve_context_.get(), resolve_context_->host_cache()));
9060 EXPECT_THAT(response.result_error(), IsError(ERR_NAME_NOT_RESOLVED));
9061 EXPECT_FALSE(response.request()->GetAddressResults());
9062 EXPECT_FALSE(response.request()->GetTextResults());
9063 EXPECT_FALSE(response.request()->GetHostnameResults());
9064 EXPECT_FALSE(response.request()->GetEsniResults());
9065 }
9066
9067 // Same as EsniQuery except we specify DNS HostResolverSource instead of relying
9068 // on automatic determination. Expect same results since DNS should be what we
9069 // automatically determine, but some slightly different logic paths are
9070 // involved.
TEST_F(HostResolverManagerDnsTest,EsniDnsQuery)9071 TEST_F(HostResolverManagerDnsTest, EsniDnsQuery) {
9072 EsniContent c1, c2, c3;
9073 IPAddress a1(1, 2, 3, 4), a2(5, 6, 7, 8);
9074
9075 const std::string kKey1 = GenerateWellFormedEsniKeys("a");
9076 const std::string kKey2 = GenerateWellFormedEsniKeys("b");
9077 const std::string kKey3 = GenerateWellFormedEsniKeys("c");
9078
9079 c1.AddKey(kKey1);
9080
9081 c2.AddKeyForAddress(a1, kKey2);
9082 c2.AddKeyForAddress(a2, kKey2);
9083
9084 c3.AddKeyForAddress(a1, kKey3);
9085
9086 std::vector<EsniContent> esni_records = {c1, c2, c3};
9087
9088 MockDnsClientRuleList rules;
9089 rules.emplace_back("host", dns_protocol::kExperimentalTypeEsniDraft4,
9090 false /* secure */,
9091 MockDnsClientRule::Result(BuildTestDnsEsniResponse(
9092 "host", std::move(esni_records))),
9093 false /* delay */);
9094
9095 CreateResolver();
9096 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9097
9098 HostResolver::ResolveHostParameters parameters;
9099 parameters.source = HostResolverSource::DNS;
9100 parameters.dns_query_type = DnsQueryType::ESNI;
9101
9102 ResolveHostResponseHelper response(resolver_->CreateRequest(
9103 HostPortPair("host", 108), NetworkIsolationKey(), NetLogWithSource(),
9104 parameters, resolve_context_.get(), resolve_context_->host_cache()));
9105 EXPECT_THAT(response.result_error(), IsOk());
9106 EXPECT_FALSE(response.request()->GetHostnameResults());
9107 EXPECT_FALSE(response.request()->GetTextResults());
9108
9109 // The multiple ESNI records should have been merged when parsing
9110 // the results.
9111 c1.MergeFrom(c2);
9112 c1.MergeFrom(c3);
9113
9114 // The ESNI records' addresses should have been merged into
9115 // the address list.
9116 ASSERT_TRUE(response.request()->GetAddressResults());
9117 EXPECT_THAT(
9118 response.request()->GetAddressResults()->endpoints(),
9119 testing::UnorderedElementsAre(IPEndPoint(a1, 108), IPEndPoint(a2, 108)));
9120
9121 ASSERT_TRUE(response.request()->GetEsniResults().has_value());
9122
9123 // During aggregation of ESNI query results, we drop ESNI keys
9124 // with no associated addresses, like key 1 here. (This is an implementation
9125 // decision declining a "MAY" behavior from the spec.) So, we require that
9126 // only keys 2 and 3 are surfaced.
9127 EXPECT_THAT(response.request()->GetEsniResults()->keys(),
9128 testing::UnorderedElementsAre(kKey2, kKey3));
9129 EXPECT_EQ(response.request()->GetEsniResults()->keys_for_addresses(),
9130 c1.keys_for_addresses());
9131 }
9132
9133 // Test that a newly-registered ResolveContext is immediately usable with a DNS
9134 // configuration loaded before the context registration.
TEST_F(HostResolverManagerDnsTest,NewlyRegisteredContext_ConfigBeforeRegistration)9135 TEST_F(HostResolverManagerDnsTest,
9136 NewlyRegisteredContext_ConfigBeforeRegistration) {
9137 ResolveContext context(nullptr /* url_request_context */,
9138 true /* enable_caching */);
9139 set_allow_fallback_to_proctask(false);
9140 ChangeDnsConfig(CreateValidDnsConfig());
9141 DnsConfigOverrides overrides;
9142 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
9143 resolver_->SetDnsConfigOverrides(overrides);
9144
9145 ASSERT_TRUE(dns_client_->GetCurrentSession());
9146
9147 resolver_->RegisterResolveContext(&context);
9148 EXPECT_EQ(context.current_session_for_testing(),
9149 dns_client_->GetCurrentSession());
9150
9151 // Test a SECURE-mode DoH request with SetForceDohServerAvailable(false).
9152 // Should only succeed if a DoH server is marked available in the
9153 // ResolveContext. MockDnsClient skips most other interaction with
9154 // ResolveContext.
9155 dns_client_->SetForceDohServerAvailable(false);
9156 context.RecordServerSuccess(0u /* server_index */, true /* is_doh_server */,
9157 dns_client_->GetCurrentSession());
9158 ResolveHostResponseHelper response(resolver_->CreateRequest(
9159 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
9160 base::nullopt, &context, context.host_cache()));
9161 EXPECT_THAT(response.result_error(), IsOk());
9162
9163 resolver_->DeregisterResolveContext(&context);
9164 }
9165
9166 // Test interaction with a ResolveContext registered before a DNS config is
9167 // ready.
TEST_F(HostResolverManagerDnsTest,NewlyRegisteredContext_NoConfigAtRegistration)9168 TEST_F(HostResolverManagerDnsTest,
9169 NewlyRegisteredContext_NoConfigAtRegistration) {
9170 ResolveContext context(nullptr /* url_request_context */,
9171 true /* enable_caching */);
9172 set_allow_fallback_to_proctask(false);
9173 InvalidateDnsConfig();
9174 DnsConfigOverrides overrides;
9175 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::SECURE;
9176 resolver_->SetDnsConfigOverrides(overrides);
9177
9178 ASSERT_FALSE(dns_client_->GetCurrentSession());
9179
9180 // Register context before loading a DNS config.
9181 resolver_->RegisterResolveContext(&context);
9182 EXPECT_FALSE(context.current_session_for_testing());
9183
9184 // Load DNS config and expect the session to be loaded into the ResolveContext
9185 ChangeDnsConfig(CreateValidDnsConfig());
9186 ASSERT_TRUE(dns_client_->GetCurrentSession());
9187 EXPECT_EQ(context.current_session_for_testing(),
9188 dns_client_->GetCurrentSession());
9189
9190 // Test a SECURE-mode DoH request with SetForceDohServerAvailable(false).
9191 // Should only succeed if a DoH server is marked available in the
9192 // ResolveContext. MockDnsClient skips most other interaction with
9193 // ResolveContext.
9194 dns_client_->SetForceDohServerAvailable(false);
9195 context.RecordServerSuccess(0u /* server_index */, true /* is_doh_server */,
9196 dns_client_->GetCurrentSession());
9197 ResolveHostResponseHelper response(resolver_->CreateRequest(
9198 HostPortPair("secure", 80), NetworkIsolationKey(), NetLogWithSource(),
9199 base::nullopt, &context, context.host_cache()));
9200 EXPECT_THAT(response.result_error(), IsOk());
9201
9202 resolver_->DeregisterResolveContext(&context);
9203 }
9204
9205 class HostResolverManagerEsniTest : public HostResolverManagerDnsTest {
9206 public:
HostResolverManagerEsniTest()9207 HostResolverManagerEsniTest()
9208 : HostResolverManagerDnsTest(
9209 base::test::TaskEnvironment::TimeSource::MOCK_TIME) {
9210 scoped_feature_list_.InitAndEnableFeature(features::kRequestEsniDnsRecords);
9211 }
9212
9213 protected:
9214 base::test::ScopedFeatureList scoped_feature_list_;
9215
9216 // Adds a rule returning a collection of ESNI records such that
9217 // - there is a lone key with no associated addresses
9218 // - there is an address associated with multiple keys
9219 // - there is a key associated with multiple addresses
9220 //
9221 // Returns a pair containing:
9222 // (1) a single merged EsniContent object which should be contained in
9223 // the eventual response.
9224 // (2) the collection of IPEndPoints corresponding to the
9225 // ESNI records' contained addresses; these are expected to
9226 // be contained in the eventual response's address list (assuming
9227 // no addresses are pruned by the address sorter, which will
9228 // be the case in the test, because MockAddressSorter no-ops)
9229 struct AddEsniRecordsRuleOptions {
9230 bool secure = true, delay = false;
9231 };
AddEsniRecordsRule(base::StringPiece hostname,AddEsniRecordsRuleOptions options,MockDnsClientRuleList * rules)9232 std::pair<EsniContent, std::vector<IPEndPoint>> AddEsniRecordsRule(
9233 base::StringPiece hostname,
9234 AddEsniRecordsRuleOptions options,
9235 MockDnsClientRuleList* rules) {
9236 EsniContent c1, c2, c3;
9237 IPAddress a1(1, 2, 3, 4);
9238 IPAddress a2(5, 6, 7, 8);
9239
9240 const std::string kKey1 = GenerateWellFormedEsniKeys("a");
9241 const std::string kKey2 = GenerateWellFormedEsniKeys("b");
9242 const std::string kKey3 = GenerateWellFormedEsniKeys("c");
9243
9244 c1.AddKey(kKey1);
9245
9246 c2.AddKeyForAddress(a1, kKey2);
9247 c2.AddKeyForAddress(a2, kKey2);
9248
9249 c3.AddKeyForAddress(a1, kKey3);
9250
9251 std::vector<EsniContent> esni_records = {c1, c2, c3};
9252 rules->emplace_back(std::string(hostname),
9253 dns_protocol::kExperimentalTypeEsniDraft4,
9254 options.secure,
9255 MockDnsClientRule::Result(BuildTestDnsEsniResponse(
9256 std::string(hostname), std::move(esni_records))),
9257 options.delay);
9258
9259 // Key 1 will be dropped because it corresponds to no addresses;
9260 // section 4.2.2 of ESNI draft 4 gives implementors the option to associate
9261 // these with all IP addresses received in concurrent A and AAAA responses,
9262 // and we choose not to do this.
9263 c2.MergeFrom(c3);
9264 return std::make_pair(
9265 c2, std::vector<IPEndPoint>{IPEndPoint(a1, 80), IPEndPoint(a2, 80)});
9266 }
9267 };
9268
9269 // Check that resolving ESNI queries alongside A and AAAA queries
9270 // results in a correct aggregation of addresses.
TEST_F(HostResolverManagerEsniTest,AggregatesResults)9271 TEST_F(HostResolverManagerEsniTest, AggregatesResults) {
9272 MockDnsClientRuleList rules;
9273
9274 EsniContent esni_expectation;
9275 std::vector<IPEndPoint> expected_addresses;
9276 std::tie(esni_expectation, expected_addresses) =
9277 AddEsniRecordsRule("host", AddEsniRecordsRuleOptions(), &rules);
9278
9279 rules.emplace_back("host", dns_protocol::kTypeA, true /* secure */,
9280 MockDnsClientRule::Result(MockDnsClientRule::OK),
9281 false /* delay */);
9282 rules.emplace_back("host", dns_protocol::kTypeAAAA, true /* secure */,
9283 MockDnsClientRule::Result(MockDnsClientRule::OK),
9284 false /* delay */);
9285 // Even though the A and AAAA results' addresses won't have any
9286 // associated ESNI keys, they should still be surfaced in GetAddressResults().
9287 expected_addresses.push_back(CreateExpected("127.0.0.1", 80));
9288 expected_addresses.push_back(CreateExpected("::1", 80));
9289
9290 CreateResolver();
9291 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9292 DnsConfigOverrides overrides;
9293 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
9294 resolver_->SetDnsConfigOverrides(overrides);
9295
9296 ResolveHostResponseHelper response(resolver_->CreateRequest(
9297 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
9298 HostResolver::ResolveHostParameters(), resolve_context_.get(),
9299 resolve_context_->host_cache()));
9300
9301 ASSERT_THAT(response.result_error(), IsOk());
9302 EXPECT_THAT(response.request()->GetEsniResults(),
9303 testing::Optional(testing::Eq(esni_expectation)));
9304 // GetAddressResults() should surface addresses with and without
9305 // associated ESNI keys.
9306 ASSERT_THAT(response.request()->GetAddressResults()->endpoints(),
9307 testing::UnorderedElementsAreArray(expected_addresses));
9308 }
9309
9310 // Test that addresses with associated ESNI keys are placed
9311 // first in the order provided to the address sorter.
9312 // (This corresponds to the order of the address list in the results
9313 // because MockAddressSorter's sort is a no-op.)
TEST_F(HostResolverManagerEsniTest,EsniAddressesFirstInOrder)9314 TEST_F(HostResolverManagerEsniTest, EsniAddressesFirstInOrder) {
9315 MockDnsClientRuleList rules;
9316
9317 EsniContent esni_expectation;
9318 std::vector<IPEndPoint> esni_addresses;
9319 std::tie(esni_expectation, esni_addresses) =
9320 AddEsniRecordsRule("host", AddEsniRecordsRuleOptions(), &rules);
9321
9322 rules.emplace_back("host", dns_protocol::kTypeA, true /* secure */,
9323 MockDnsClientRule::Result(MockDnsClientRule::OK),
9324 false /* delay */);
9325 rules.emplace_back("host", dns_protocol::kTypeAAAA, true /* secure */,
9326 MockDnsClientRule::Result(MockDnsClientRule::OK),
9327 false /* delay */);
9328
9329 CreateResolver();
9330 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9331 DnsConfigOverrides overrides;
9332 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
9333 resolver_->SetDnsConfigOverrides(overrides);
9334
9335 HostResolver::ResolveHostParameters parameters;
9336 ResolveHostResponseHelper response(resolver_->CreateRequest(
9337 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
9338 parameters, resolve_context_.get(), resolve_context_->host_cache()));
9339
9340 // Check that the IP addresses with associated
9341 // ESNI key objects occupy the initial entries of the
9342 // address list returned by the DNS query.
9343 ASSERT_THAT(response.result_error(), IsOk());
9344 ASSERT_TRUE(response.request()->GetAddressResults());
9345 const auto& result_addresses =
9346 response.request()->GetAddressResults()->endpoints();
9347 for (const IPEndPoint& address_with_esni_keys : esni_addresses) {
9348 int index = std::find(result_addresses.begin(), result_addresses.end(),
9349 address_with_esni_keys) -
9350 result_addresses.begin();
9351
9352 // Since this address has associated ESNI keys, it should be in
9353 // the first esni_addresses.size() many entries of the result's
9354 // address list.
9355 ASSERT_TRUE(base::IsValueInRangeForNumericType<size_t>(index));
9356 EXPECT_LT(static_cast<size_t>(index), esni_addresses.size());
9357 }
9358 }
9359
TEST_F(HostResolverManagerEsniTest,OnlyMakesRequestOverSecureDns)9360 TEST_F(HostResolverManagerEsniTest, OnlyMakesRequestOverSecureDns) {
9361 // Add some insecurely-accessible ESNI results alongside
9362 // the default (insecurely-accessible) IPv4 and IPv6 results
9363 // for the "ok" hostname.
9364 MockDnsClientRuleList rules = CreateDefaultDnsRules();
9365 AddEsniRecordsRuleOptions options;
9366 options.secure = false;
9367 AddEsniRecordsRule("ok", options, &rules);
9368
9369 CreateResolver();
9370 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9371
9372 ResolveHostResponseHelper response(resolver_->CreateRequest(
9373 HostPortPair("ok", 80), NetworkIsolationKey(), NetLogWithSource(),
9374 HostResolver::ResolveHostParameters(), resolve_context_.get(),
9375 resolve_context_->host_cache()));
9376
9377 ASSERT_THAT(response.result_error(), IsOk());
9378
9379 // Since the request wasn't secure, we shouldn't have
9380 // queried for any ESNI results.
9381 ASSERT_FALSE(response.request()->GetEsniResults());
9382 }
9383
9384 // Make sure that ESNI queries don't get cancelled *before* the
9385 // configured timeout, but do get cancelled after it,
9386 // in the case where the absolute timeout dominates.
TEST_F(HostResolverManagerEsniTest,RespectsAbsoluteTimeout)9387 TEST_F(HostResolverManagerEsniTest, RespectsAbsoluteTimeout) {
9388 // Add some delayed ESNI, IPv4, and IPv6 results
9389 MockDnsClientRuleList rules = CreateDefaultDnsRules();
9390 AddEsniRecordsRuleOptions options;
9391 options.delay = true;
9392 AddEsniRecordsRule("host", options, &rules);
9393 rules.emplace_back("host", dns_protocol::kTypeA, true /* secure */,
9394 MockDnsClientRule::Result(MockDnsClientRule::OK),
9395 true /* delay */);
9396 rules.emplace_back("host", dns_protocol::kTypeAAAA, true /* secure */,
9397 MockDnsClientRule::Result(MockDnsClientRule::OK),
9398 true /* delay */);
9399
9400 CreateResolver();
9401 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9402 DnsConfigOverrides overrides;
9403 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
9404 resolver_->SetDnsConfigOverrides(overrides);
9405
9406 ResolveHostResponseHelper response(resolver_->CreateRequest(
9407 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
9408 HostResolver::ResolveHostParameters(), resolve_context_.get(),
9409 resolve_context_->host_cache()));
9410
9411 base::TimeDelta absolute_timeout =
9412 features::EsniDnsMaxAbsoluteAdditionalWait();
9413
9414 // Let enough time pass during the A and AAAA transactions that the
9415 // absolute timeout will be less than the relative timeout.
9416 base::TimeDelta a_aaaa_elapsed =
9417 50 * (100.0 / features::kEsniDnsMaxRelativeAdditionalWaitPercent.Get()) *
9418 absolute_timeout;
9419
9420 FastForwardBy(a_aaaa_elapsed);
9421 ASSERT_TRUE(
9422 dns_client_->CompleteOneDelayedTransactionOfType(DnsQueryType::A));
9423 ASSERT_TRUE(
9424 dns_client_->CompleteOneDelayedTransactionOfType(DnsQueryType::AAAA));
9425
9426 // Since the A and AAAA queries have only just completed, we shouldn't
9427 // have timed out the ESNI query.
9428 EXPECT_FALSE(response.complete());
9429
9430 // After half of the absolute timeout, the query should still be alive.
9431 FastForwardBy(0.5 * absolute_timeout);
9432
9433 // Since the absolute timeout has not yet elapsed, and it is shorter by
9434 // design than the relative timeout, we shouldn't
9435 // have timed out the ESNI transaction.
9436 EXPECT_FALSE(response.complete());
9437
9438 // After (more than) the timeout has passed, we should have cancelled
9439 // the ESNI transaction.
9440 FastForwardBy(absolute_timeout);
9441 ASSERT_THAT(response.result_error(), IsOk());
9442
9443 // Since we cancelled the transaction, we shouldn't have any ESNI results.
9444 EXPECT_FALSE(response.request()->GetEsniResults());
9445 }
9446
9447 // Make sure that ESNI queries don't get cancelled *before* the
9448 // configured timeout, but do get cancelled after it,
9449 // in the case where the relative timeout dominates.
TEST_F(HostResolverManagerEsniTest,RespectsRelativeTimeout)9450 TEST_F(HostResolverManagerEsniTest, RespectsRelativeTimeout) {
9451 // Add some delayed ESNI, IPv4, and IPv6 results
9452 MockDnsClientRuleList rules = CreateDefaultDnsRules();
9453 AddEsniRecordsRuleOptions options;
9454 options.delay = true;
9455 AddEsniRecordsRule("host", options, &rules);
9456 rules.emplace_back("host", dns_protocol::kTypeA, true /* secure */,
9457 MockDnsClientRule::Result(MockDnsClientRule::OK),
9458 false /* delay */);
9459 rules.emplace_back("host", dns_protocol::kTypeAAAA, true /* secure */,
9460 MockDnsClientRule::Result(MockDnsClientRule::OK),
9461 true /* delay */);
9462
9463 CreateResolver();
9464 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9465 DnsConfigOverrides overrides;
9466 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
9467 resolver_->SetDnsConfigOverrides(overrides);
9468
9469 ResolveHostResponseHelper response(resolver_->CreateRequest(
9470 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
9471 HostResolver::ResolveHostParameters(), resolve_context_.get(),
9472 resolve_context_->host_cache()));
9473
9474 // Let little enough time pass during the A and AAAA transactions that the
9475 // relative timeout will be less than the absolute timeout.
9476 base::TimeDelta a_aaaa_elapsed =
9477 0.05 * features::EsniDnsMaxAbsoluteAdditionalWait() *
9478 (100 / features::kEsniDnsMaxRelativeAdditionalWaitPercent.Get());
9479
9480 // Since the A and AAAA queries haven't both completed yet, we shouldn't time
9481 // out the ESNI query.
9482 FastForwardBy(a_aaaa_elapsed);
9483
9484 // Upon completing the AAAA transaction, the ESNI timer should start
9485 ASSERT_TRUE(
9486 dns_client_->CompleteOneDelayedTransactionOfType(DnsQueryType::AAAA));
9487
9488 base::TimeDelta relative_timeout =
9489 0.01 * features::kEsniDnsMaxRelativeAdditionalWaitPercent.Get() *
9490 a_aaaa_elapsed;
9491
9492 // After *less* than the relative timeout, the query shouldn't have concluded.
9493 FastForwardBy(relative_timeout * 0.5);
9494
9495 EXPECT_FALSE(response.complete());
9496
9497 // After more than the relative timeout, the query should conclude by aborting
9498 // the ESNI query.
9499 FastForwardBy(relative_timeout * 0.5);
9500
9501 // The task should have completed with a cancelled ESNI query.
9502 ASSERT_THAT(response.result_error(), IsOk());
9503 EXPECT_FALSE(response.request()->GetEsniResults());
9504 ASSERT_TRUE(response.request()->GetAddressResults());
9505 EXPECT_THAT(response.request()->GetAddressResults()->endpoints(),
9506 testing::UnorderedElementsAre(CreateExpected("127.0.0.1", 80),
9507 CreateExpected("::1", 80)));
9508 }
9509
9510 // Test that we still receive delayed A/AAAA records
9511 // that arrive after a successful (non-delayed) ESNI transaction.
TEST_F(HostResolverManagerEsniTest,WaitsForSlowAccompanyingQueries)9512 TEST_F(HostResolverManagerEsniTest, WaitsForSlowAccompanyingQueries) {
9513 MockDnsClientRuleList rules;
9514
9515 EsniContent esni_expectation;
9516 std::vector<IPEndPoint> expected_addresses;
9517 std::tie(esni_expectation, expected_addresses) =
9518 AddEsniRecordsRule("host", AddEsniRecordsRuleOptions(), &rules);
9519
9520 rules.emplace_back("host", dns_protocol::kTypeA, true /* secure */,
9521 MockDnsClientRule::Result(MockDnsClientRule::OK),
9522 true /* delay */);
9523 expected_addresses.push_back(CreateExpected("127.0.0.1", 80));
9524
9525 rules.emplace_back("host", dns_protocol::kTypeAAAA, true /* secure */,
9526 MockDnsClientRule::Result(MockDnsClientRule::OK),
9527 true /* delay */);
9528 expected_addresses.push_back(CreateExpected("::1", 80));
9529
9530 CreateResolver();
9531 UseMockDnsClient(CreateValidDnsConfig(), std::move(rules));
9532 DnsConfigOverrides overrides;
9533 overrides.secure_dns_mode = DnsConfig::SecureDnsMode::AUTOMATIC;
9534 resolver_->SetDnsConfigOverrides(overrides);
9535
9536 ResolveHostResponseHelper response(resolver_->CreateRequest(
9537 HostPortPair("host", 80), NetworkIsolationKey(), NetLogWithSource(),
9538 HostResolver::ResolveHostParameters(), resolve_context_.get(),
9539 resolve_context_->host_cache()));
9540
9541 // Wait quite a long time. (If the timer were erroneously to have been
9542 // started, it should expire by the end of this elapsed window.)
9543 FastForwardBy(features::EsniDnsMaxAbsoluteAdditionalWait() * 10);
9544 dns_client_->CompleteDelayedTransactions();
9545
9546 EXPECT_THAT(response.result_error(), IsOk());
9547 EXPECT_THAT(response.request()->GetEsniResults(),
9548 testing::Optional(testing::Eq(esni_expectation)));
9549 ASSERT_TRUE(response.request()->GetAddressResults());
9550 EXPECT_THAT(response.request()->GetAddressResults()->endpoints(),
9551 testing::UnorderedElementsAreArray(expected_addresses));
9552 }
9553
9554 } // namespace net
9555