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_impl.h" 6 7 #include <algorithm> 8 #include <string> 9 10 #include "base/bind.h" 11 #include "base/bind_helpers.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_vector.h" 14 #include "base/message_loop/message_loop.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/stringprintf.h" 17 #include "base/synchronization/condition_variable.h" 18 #include "base/synchronization/lock.h" 19 #include "base/test/test_timeouts.h" 20 #include "base/time/time.h" 21 #include "net/base/address_list.h" 22 #include "net/base/net_errors.h" 23 #include "net/base/net_util.h" 24 #include "net/dns/dns_client.h" 25 #include "net/dns/dns_test_util.h" 26 #include "net/dns/host_cache.h" 27 #include "net/dns/mock_host_resolver.h" 28 #include "testing/gtest/include/gtest/gtest.h" 29 30 namespace net { 31 32 namespace { 33 34 const size_t kMaxJobs = 10u; 35 const size_t kMaxRetryAttempts = 4u; 36 37 PrioritizedDispatcher::Limits DefaultLimits() { 38 PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, kMaxJobs); 39 return limits; 40 } 41 42 HostResolverImpl::ProcTaskParams DefaultParams( 43 HostResolverProc* resolver_proc) { 44 return HostResolverImpl::ProcTaskParams(resolver_proc, kMaxRetryAttempts); 45 } 46 47 // A HostResolverProc that pushes each host mapped into a list and allows 48 // waiting for a specific number of requests. Unlike RuleBasedHostResolverProc 49 // it never calls SystemHostResolverCall. By default resolves all hostnames to 50 // "127.0.0.1". After AddRule(), it resolves only names explicitly specified. 51 class MockHostResolverProc : public HostResolverProc { 52 public: 53 struct ResolveKey { 54 ResolveKey(const std::string& hostname, AddressFamily address_family) 55 : hostname(hostname), address_family(address_family) {} 56 bool operator<(const ResolveKey& other) const { 57 return address_family < other.address_family || 58 (address_family == other.address_family && hostname < other.hostname); 59 } 60 std::string hostname; 61 AddressFamily address_family; 62 }; 63 64 typedef std::vector<ResolveKey> CaptureList; 65 66 MockHostResolverProc() 67 : HostResolverProc(NULL), 68 num_requests_waiting_(0), 69 num_slots_available_(0), 70 requests_waiting_(&lock_), 71 slots_available_(&lock_) { 72 } 73 74 // Waits until |count| calls to |Resolve| are blocked. Returns false when 75 // timed out. 76 bool WaitFor(unsigned count) { 77 base::AutoLock lock(lock_); 78 base::Time start_time = base::Time::Now(); 79 while (num_requests_waiting_ < count) { 80 requests_waiting_.TimedWait(TestTimeouts::action_timeout()); 81 if (base::Time::Now() > start_time + TestTimeouts::action_timeout()) 82 return false; 83 } 84 return true; 85 } 86 87 // Signals |count| waiting calls to |Resolve|. First come first served. 88 void SignalMultiple(unsigned count) { 89 base::AutoLock lock(lock_); 90 num_slots_available_ += count; 91 slots_available_.Broadcast(); 92 } 93 94 // Signals all waiting calls to |Resolve|. Beware of races. 95 void SignalAll() { 96 base::AutoLock lock(lock_); 97 num_slots_available_ = num_requests_waiting_; 98 slots_available_.Broadcast(); 99 } 100 101 void AddRule(const std::string& hostname, AddressFamily family, 102 const AddressList& result) { 103 base::AutoLock lock(lock_); 104 rules_[ResolveKey(hostname, family)] = result; 105 } 106 107 void AddRule(const std::string& hostname, AddressFamily family, 108 const std::string& ip_list) { 109 AddressList result; 110 int rv = ParseAddressList(ip_list, std::string(), &result); 111 DCHECK_EQ(OK, rv); 112 AddRule(hostname, family, result); 113 } 114 115 void AddRuleForAllFamilies(const std::string& hostname, 116 const std::string& ip_list) { 117 AddressList result; 118 int rv = ParseAddressList(ip_list, std::string(), &result); 119 DCHECK_EQ(OK, rv); 120 AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result); 121 AddRule(hostname, ADDRESS_FAMILY_IPV4, result); 122 AddRule(hostname, ADDRESS_FAMILY_IPV6, result); 123 } 124 125 virtual int Resolve(const std::string& hostname, 126 AddressFamily address_family, 127 HostResolverFlags host_resolver_flags, 128 AddressList* addrlist, 129 int* os_error) OVERRIDE { 130 base::AutoLock lock(lock_); 131 capture_list_.push_back(ResolveKey(hostname, address_family)); 132 ++num_requests_waiting_; 133 requests_waiting_.Broadcast(); 134 while (!num_slots_available_) 135 slots_available_.Wait(); 136 DCHECK_GT(num_requests_waiting_, 0u); 137 --num_slots_available_; 138 --num_requests_waiting_; 139 if (rules_.empty()) { 140 int rv = ParseAddressList("127.0.0.1", std::string(), addrlist); 141 DCHECK_EQ(OK, rv); 142 return OK; 143 } 144 ResolveKey key(hostname, address_family); 145 if (rules_.count(key) == 0) 146 return ERR_NAME_NOT_RESOLVED; 147 *addrlist = rules_[key]; 148 return OK; 149 } 150 151 CaptureList GetCaptureList() const { 152 CaptureList copy; 153 { 154 base::AutoLock lock(lock_); 155 copy = capture_list_; 156 } 157 return copy; 158 } 159 160 bool HasBlockedRequests() const { 161 base::AutoLock lock(lock_); 162 return num_requests_waiting_ > num_slots_available_; 163 } 164 165 protected: 166 virtual ~MockHostResolverProc() {} 167 168 private: 169 mutable base::Lock lock_; 170 std::map<ResolveKey, AddressList> rules_; 171 CaptureList capture_list_; 172 unsigned num_requests_waiting_; 173 unsigned num_slots_available_; 174 base::ConditionVariable requests_waiting_; 175 base::ConditionVariable slots_available_; 176 177 DISALLOW_COPY_AND_ASSIGN(MockHostResolverProc); 178 }; 179 180 bool AddressListContains(const AddressList& list, const std::string& address, 181 int port) { 182 IPAddressNumber ip; 183 bool rv = ParseIPLiteralToNumber(address, &ip); 184 DCHECK(rv); 185 return std::find(list.begin(), 186 list.end(), 187 IPEndPoint(ip, port)) != list.end(); 188 } 189 190 // A wrapper for requests to a HostResolver. 191 class Request { 192 public: 193 // Base class of handlers to be executed on completion of requests. 194 struct Handler { 195 virtual ~Handler() {} 196 virtual void Handle(Request* request) = 0; 197 }; 198 199 Request(const HostResolver::RequestInfo& info, 200 size_t index, 201 HostResolver* resolver, 202 Handler* handler) 203 : info_(info), 204 index_(index), 205 resolver_(resolver), 206 handler_(handler), 207 quit_on_complete_(false), 208 result_(ERR_UNEXPECTED), 209 handle_(NULL) {} 210 211 int Resolve() { 212 DCHECK(resolver_); 213 DCHECK(!handle_); 214 list_ = AddressList(); 215 result_ = resolver_->Resolve( 216 info_, &list_, base::Bind(&Request::OnComplete, base::Unretained(this)), 217 &handle_, BoundNetLog()); 218 if (!list_.empty()) 219 EXPECT_EQ(OK, result_); 220 return result_; 221 } 222 223 int ResolveFromCache() { 224 DCHECK(resolver_); 225 DCHECK(!handle_); 226 return resolver_->ResolveFromCache(info_, &list_, BoundNetLog()); 227 } 228 229 void Cancel() { 230 DCHECK(resolver_); 231 DCHECK(handle_); 232 resolver_->CancelRequest(handle_); 233 handle_ = NULL; 234 } 235 236 const HostResolver::RequestInfo& info() const { return info_; } 237 size_t index() const { return index_; } 238 const AddressList& list() const { return list_; } 239 int result() const { return result_; } 240 bool completed() const { return result_ != ERR_IO_PENDING; } 241 bool pending() const { return handle_ != NULL; } 242 243 bool HasAddress(const std::string& address, int port) const { 244 return AddressListContains(list_, address, port); 245 } 246 247 // Returns the number of addresses in |list_|. 248 unsigned NumberOfAddresses() const { 249 return list_.size(); 250 } 251 252 bool HasOneAddress(const std::string& address, int port) const { 253 return HasAddress(address, port) && (NumberOfAddresses() == 1u); 254 } 255 256 // Returns ERR_UNEXPECTED if timed out. 257 int WaitForResult() { 258 if (completed()) 259 return result_; 260 base::CancelableClosure closure(base::MessageLoop::QuitClosure()); 261 base::MessageLoop::current()->PostDelayedTask( 262 FROM_HERE, closure.callback(), TestTimeouts::action_max_timeout()); 263 quit_on_complete_ = true; 264 base::MessageLoop::current()->Run(); 265 bool did_quit = !quit_on_complete_; 266 quit_on_complete_ = false; 267 closure.Cancel(); 268 if (did_quit) 269 return result_; 270 else 271 return ERR_UNEXPECTED; 272 } 273 274 private: 275 void OnComplete(int rv) { 276 EXPECT_TRUE(pending()); 277 EXPECT_EQ(ERR_IO_PENDING, result_); 278 EXPECT_NE(ERR_IO_PENDING, rv); 279 result_ = rv; 280 handle_ = NULL; 281 if (!list_.empty()) { 282 EXPECT_EQ(OK, result_); 283 EXPECT_EQ(info_.port(), list_.front().port()); 284 } 285 if (handler_) 286 handler_->Handle(this); 287 if (quit_on_complete_) { 288 base::MessageLoop::current()->Quit(); 289 quit_on_complete_ = false; 290 } 291 } 292 293 HostResolver::RequestInfo info_; 294 size_t index_; 295 HostResolver* resolver_; 296 Handler* handler_; 297 bool quit_on_complete_; 298 299 AddressList list_; 300 int result_; 301 HostResolver::RequestHandle handle_; 302 303 DISALLOW_COPY_AND_ASSIGN(Request); 304 }; 305 306 // Using LookupAttemptHostResolverProc simulate very long lookups, and control 307 // which attempt resolves the host. 308 class LookupAttemptHostResolverProc : public HostResolverProc { 309 public: 310 LookupAttemptHostResolverProc(HostResolverProc* previous, 311 int attempt_number_to_resolve, 312 int total_attempts) 313 : HostResolverProc(previous), 314 attempt_number_to_resolve_(attempt_number_to_resolve), 315 current_attempt_number_(0), 316 total_attempts_(total_attempts), 317 total_attempts_resolved_(0), 318 resolved_attempt_number_(0), 319 all_done_(&lock_) { 320 } 321 322 // Test harness will wait for all attempts to finish before checking the 323 // results. 324 void WaitForAllAttemptsToFinish(const base::TimeDelta& wait_time) { 325 base::TimeTicks end_time = base::TimeTicks::Now() + wait_time; 326 { 327 base::AutoLock auto_lock(lock_); 328 while (total_attempts_resolved_ != total_attempts_ && 329 base::TimeTicks::Now() < end_time) { 330 all_done_.TimedWait(end_time - base::TimeTicks::Now()); 331 } 332 } 333 } 334 335 // All attempts will wait for an attempt to resolve the host. 336 void WaitForAnAttemptToComplete() { 337 base::TimeDelta wait_time = base::TimeDelta::FromSeconds(60); 338 base::TimeTicks end_time = base::TimeTicks::Now() + wait_time; 339 { 340 base::AutoLock auto_lock(lock_); 341 while (resolved_attempt_number_ == 0 && base::TimeTicks::Now() < end_time) 342 all_done_.TimedWait(end_time - base::TimeTicks::Now()); 343 } 344 all_done_.Broadcast(); // Tell all waiting attempts to proceed. 345 } 346 347 // Returns the number of attempts that have finished the Resolve() method. 348 int total_attempts_resolved() { return total_attempts_resolved_; } 349 350 // Returns the first attempt that that has resolved the host. 351 int resolved_attempt_number() { return resolved_attempt_number_; } 352 353 // HostResolverProc methods. 354 virtual int Resolve(const std::string& host, 355 AddressFamily address_family, 356 HostResolverFlags host_resolver_flags, 357 AddressList* addrlist, 358 int* os_error) OVERRIDE { 359 bool wait_for_right_attempt_to_complete = true; 360 { 361 base::AutoLock auto_lock(lock_); 362 ++current_attempt_number_; 363 if (current_attempt_number_ == attempt_number_to_resolve_) { 364 resolved_attempt_number_ = current_attempt_number_; 365 wait_for_right_attempt_to_complete = false; 366 } 367 } 368 369 if (wait_for_right_attempt_to_complete) 370 // Wait for the attempt_number_to_resolve_ attempt to resolve. 371 WaitForAnAttemptToComplete(); 372 373 int result = ResolveUsingPrevious(host, address_family, host_resolver_flags, 374 addrlist, os_error); 375 376 { 377 base::AutoLock auto_lock(lock_); 378 ++total_attempts_resolved_; 379 } 380 381 all_done_.Broadcast(); // Tell all attempts to proceed. 382 383 // Since any negative number is considered a network error, with -1 having 384 // special meaning (ERR_IO_PENDING). We could return the attempt that has 385 // resolved the host as a negative number. For example, if attempt number 3 386 // resolves the host, then this method returns -4. 387 if (result == OK) 388 return -1 - resolved_attempt_number_; 389 else 390 return result; 391 } 392 393 protected: 394 virtual ~LookupAttemptHostResolverProc() {} 395 396 private: 397 int attempt_number_to_resolve_; 398 int current_attempt_number_; // Incremented whenever Resolve is called. 399 int total_attempts_; 400 int total_attempts_resolved_; 401 int resolved_attempt_number_; 402 403 // All attempts wait for right attempt to be resolve. 404 base::Lock lock_; 405 base::ConditionVariable all_done_; 406 }; 407 408 } // namespace 409 410 class HostResolverImplTest : public testing::Test { 411 public: 412 static const int kDefaultPort = 80; 413 414 HostResolverImplTest() : proc_(new MockHostResolverProc()) {} 415 416 protected: 417 // A Request::Handler which is a proxy to the HostResolverImplTest fixture. 418 struct Handler : public Request::Handler { 419 virtual ~Handler() {} 420 421 // Proxy functions so that classes derived from Handler can access them. 422 Request* CreateRequest(const HostResolver::RequestInfo& info) { 423 return test->CreateRequest(info); 424 } 425 Request* CreateRequest(const std::string& hostname, int port) { 426 return test->CreateRequest(hostname, port); 427 } 428 Request* CreateRequest(const std::string& hostname) { 429 return test->CreateRequest(hostname); 430 } 431 ScopedVector<Request>& requests() { return test->requests_; } 432 433 void DeleteResolver() { test->resolver_.reset(); } 434 435 HostResolverImplTest* test; 436 }; 437 438 void CreateResolver() { 439 resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(), 440 DefaultLimits(), 441 DefaultParams(proc_.get()), 442 NULL)); 443 } 444 445 // This HostResolverImpl will only allow 1 outstanding resolve at a time and 446 // perform no retries. 447 void CreateSerialResolver() { 448 HostResolverImpl::ProcTaskParams params = DefaultParams(proc_.get()); 449 params.max_retry_attempts = 0u; 450 PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 1); 451 resolver_.reset(new HostResolverImpl( 452 HostCache::CreateDefaultCache(), 453 limits, 454 params, 455 NULL)); 456 } 457 458 // The Request will not be made until a call to |Resolve()|, and the Job will 459 // not start until released by |proc_->SignalXXX|. 460 Request* CreateRequest(const HostResolver::RequestInfo& info) { 461 Request* req = new Request(info, requests_.size(), resolver_.get(), 462 handler_.get()); 463 requests_.push_back(req); 464 return req; 465 } 466 467 Request* CreateRequest(const std::string& hostname, 468 int port, 469 RequestPriority priority, 470 AddressFamily family) { 471 HostResolver::RequestInfo info(HostPortPair(hostname, port)); 472 info.set_priority(priority); 473 info.set_address_family(family); 474 return CreateRequest(info); 475 } 476 477 Request* CreateRequest(const std::string& hostname, 478 int port, 479 RequestPriority priority) { 480 return CreateRequest(hostname, port, priority, ADDRESS_FAMILY_UNSPECIFIED); 481 } 482 483 Request* CreateRequest(const std::string& hostname, int port) { 484 return CreateRequest(hostname, port, MEDIUM); 485 } 486 487 Request* CreateRequest(const std::string& hostname) { 488 return CreateRequest(hostname, kDefaultPort); 489 } 490 491 virtual void SetUp() OVERRIDE { 492 CreateResolver(); 493 } 494 495 virtual void TearDown() OVERRIDE { 496 if (resolver_.get()) 497 EXPECT_EQ(0u, resolver_->num_running_jobs_for_tests()); 498 EXPECT_FALSE(proc_->HasBlockedRequests()); 499 } 500 501 void set_handler(Handler* handler) { 502 handler_.reset(handler); 503 handler_->test = this; 504 } 505 506 // Friendship is not inherited, so use proxies to access those. 507 size_t num_running_jobs() const { 508 DCHECK(resolver_.get()); 509 return resolver_->num_running_jobs_for_tests(); 510 } 511 512 void set_fallback_to_proctask(bool fallback_to_proctask) { 513 DCHECK(resolver_.get()); 514 resolver_->fallback_to_proctask_ = fallback_to_proctask; 515 } 516 517 scoped_refptr<MockHostResolverProc> proc_; 518 scoped_ptr<HostResolverImpl> resolver_; 519 ScopedVector<Request> requests_; 520 521 scoped_ptr<Handler> handler_; 522 }; 523 524 TEST_F(HostResolverImplTest, AsynchronousLookup) { 525 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); 526 proc_->SignalMultiple(1u); 527 528 Request* req = CreateRequest("just.testing", 80); 529 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 530 EXPECT_EQ(OK, req->WaitForResult()); 531 532 EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80)); 533 534 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); 535 } 536 537 TEST_F(HostResolverImplTest, EmptyListMeansNameNotResolved) { 538 proc_->AddRuleForAllFamilies("just.testing", ""); 539 proc_->SignalMultiple(1u); 540 541 Request* req = CreateRequest("just.testing", 80); 542 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 543 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult()); 544 EXPECT_EQ(0u, req->NumberOfAddresses()); 545 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); 546 } 547 548 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) { 549 proc_->AddRuleForAllFamilies(std::string(), 550 "0.0.0.0"); // Default to failures. 551 proc_->SignalMultiple(1u); 552 553 Request* req = CreateRequest("just.testing", 80); 554 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 555 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult()); 556 557 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); 558 559 // Also test that the error is not cached. 560 EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache()); 561 } 562 563 TEST_F(HostResolverImplTest, AbortedAsynchronousLookup) { 564 Request* req0 = CreateRequest("just.testing", 80); 565 EXPECT_EQ(ERR_IO_PENDING, req0->Resolve()); 566 567 EXPECT_TRUE(proc_->WaitFor(1u)); 568 569 // Resolver is destroyed while job is running on WorkerPool. 570 resolver_.reset(); 571 572 proc_->SignalAll(); 573 574 // To ensure there was no spurious callback, complete with a new resolver. 575 CreateResolver(); 576 Request* req1 = CreateRequest("just.testing", 80); 577 EXPECT_EQ(ERR_IO_PENDING, req1->Resolve()); 578 579 proc_->SignalMultiple(2u); 580 581 EXPECT_EQ(OK, req1->WaitForResult()); 582 583 // This request was canceled. 584 EXPECT_FALSE(req0->completed()); 585 } 586 587 TEST_F(HostResolverImplTest, NumericIPv4Address) { 588 // Stevens says dotted quads with AI_UNSPEC resolve to a single sockaddr_in. 589 Request* req = CreateRequest("127.1.2.3", 5555); 590 EXPECT_EQ(OK, req->Resolve()); 591 592 EXPECT_TRUE(req->HasOneAddress("127.1.2.3", 5555)); 593 } 594 595 TEST_F(HostResolverImplTest, NumericIPv6Address) { 596 // Resolve a plain IPv6 address. Don't worry about [brackets], because 597 // the caller should have removed them. 598 Request* req = CreateRequest("2001:db8::1", 5555); 599 EXPECT_EQ(OK, req->Resolve()); 600 601 EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555)); 602 } 603 604 TEST_F(HostResolverImplTest, EmptyHost) { 605 Request* req = CreateRequest(std::string(), 5555); 606 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); 607 } 608 609 TEST_F(HostResolverImplTest, EmptyDotsHost) { 610 for (int i = 0; i < 16; ++i) { 611 Request* req = CreateRequest(std::string(i, '.'), 5555); 612 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); 613 } 614 } 615 616 TEST_F(HostResolverImplTest, LongHost) { 617 Request* req = CreateRequest(std::string(4097, 'a'), 5555); 618 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); 619 } 620 621 TEST_F(HostResolverImplTest, DeDupeRequests) { 622 // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is 623 // blocked, these should all pile up until we signal it. 624 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve()); 625 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve()); 626 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve()); 627 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve()); 628 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve()); 629 630 proc_->SignalMultiple(2u); // One for "a", one for "b". 631 632 for (size_t i = 0; i < requests_.size(); ++i) { 633 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 634 } 635 } 636 637 TEST_F(HostResolverImplTest, CancelMultipleRequests) { 638 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve()); 639 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 80)->Resolve()); 640 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 81)->Resolve()); 641 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 82)->Resolve()); 642 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve()); 643 644 // Cancel everything except request for ("a", 82). 645 requests_[0]->Cancel(); 646 requests_[1]->Cancel(); 647 requests_[2]->Cancel(); 648 requests_[4]->Cancel(); 649 650 proc_->SignalMultiple(2u); // One for "a", one for "b". 651 652 EXPECT_EQ(OK, requests_[3]->WaitForResult()); 653 } 654 655 TEST_F(HostResolverImplTest, CanceledRequestsReleaseJobSlots) { 656 // Fill up the dispatcher and queue. 657 for (unsigned i = 0; i < kMaxJobs + 1; ++i) { 658 std::string hostname = "a_"; 659 hostname[1] = 'a' + i; 660 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()); 661 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 81)->Resolve()); 662 } 663 664 EXPECT_TRUE(proc_->WaitFor(kMaxJobs)); 665 666 // Cancel all but last two. 667 for (unsigned i = 0; i < requests_.size() - 2; ++i) { 668 requests_[i]->Cancel(); 669 } 670 671 EXPECT_TRUE(proc_->WaitFor(kMaxJobs + 1)); 672 673 proc_->SignalAll(); 674 675 size_t num_requests = requests_.size(); 676 EXPECT_EQ(OK, requests_[num_requests - 1]->WaitForResult()); 677 EXPECT_EQ(OK, requests_[num_requests - 2]->result()); 678 } 679 680 TEST_F(HostResolverImplTest, CancelWithinCallback) { 681 struct MyHandler : public Handler { 682 virtual void Handle(Request* req) OVERRIDE { 683 // Port 80 is the first request that the callback will be invoked for. 684 // While we are executing within that callback, cancel the other requests 685 // in the job and start another request. 686 if (req->index() == 0) { 687 // Once "a:80" completes, it will cancel "a:81" and "a:82". 688 requests()[1]->Cancel(); 689 requests()[2]->Cancel(); 690 } 691 } 692 }; 693 set_handler(new MyHandler()); 694 695 for (size_t i = 0; i < 4; ++i) { 696 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; 697 } 698 699 proc_->SignalMultiple(2u); // One for "a". One for "finalrequest". 700 701 EXPECT_EQ(OK, requests_[0]->WaitForResult()); 702 703 Request* final_request = CreateRequest("finalrequest", 70); 704 EXPECT_EQ(ERR_IO_PENDING, final_request->Resolve()); 705 EXPECT_EQ(OK, final_request->WaitForResult()); 706 EXPECT_TRUE(requests_[3]->completed()); 707 } 708 709 TEST_F(HostResolverImplTest, DeleteWithinCallback) { 710 struct MyHandler : public Handler { 711 virtual void Handle(Request* req) OVERRIDE { 712 EXPECT_EQ("a", req->info().hostname()); 713 EXPECT_EQ(80, req->info().port()); 714 715 DeleteResolver(); 716 717 // Quit after returning from OnCompleted (to give it a chance at 718 // incorrectly running the cancelled tasks). 719 base::MessageLoop::current()->PostTask(FROM_HERE, 720 base::MessageLoop::QuitClosure()); 721 } 722 }; 723 set_handler(new MyHandler()); 724 725 for (size_t i = 0; i < 4; ++i) { 726 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; 727 } 728 729 proc_->SignalMultiple(1u); // One for "a". 730 731 // |MyHandler| will send quit message once all the requests have finished. 732 base::MessageLoop::current()->Run(); 733 } 734 735 TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) { 736 struct MyHandler : public Handler { 737 virtual void Handle(Request* req) OVERRIDE { 738 EXPECT_EQ("a", req->info().hostname()); 739 EXPECT_EQ(80, req->info().port()); 740 741 DeleteResolver(); 742 743 // Quit after returning from OnCompleted (to give it a chance at 744 // incorrectly running the cancelled tasks). 745 base::MessageLoop::current()->PostTask(FROM_HERE, 746 base::MessageLoop::QuitClosure()); 747 } 748 }; 749 set_handler(new MyHandler()); 750 751 // This test assumes that the Jobs will be Aborted in order ["a", "b"] 752 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve()); 753 // HostResolverImpl will be deleted before later Requests can complete. 754 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 81)->Resolve()); 755 // Job for 'b' will be aborted before it can complete. 756 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 82)->Resolve()); 757 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b", 83)->Resolve()); 758 759 EXPECT_TRUE(proc_->WaitFor(1u)); 760 761 // Triggering an IP address change. 762 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 763 764 // |MyHandler| will send quit message once all the requests have finished. 765 base::MessageLoop::current()->Run(); 766 767 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result()); 768 EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result()); 769 EXPECT_EQ(ERR_IO_PENDING, requests_[2]->result()); 770 EXPECT_EQ(ERR_IO_PENDING, requests_[3]->result()); 771 // Clean up. 772 proc_->SignalMultiple(requests_.size()); 773 } 774 775 TEST_F(HostResolverImplTest, StartWithinCallback) { 776 struct MyHandler : public Handler { 777 virtual void Handle(Request* req) OVERRIDE { 778 if (req->index() == 0) { 779 // On completing the first request, start another request for "a". 780 // Since caching is disabled, this will result in another async request. 781 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 70)->Resolve()); 782 } 783 } 784 }; 785 set_handler(new MyHandler()); 786 787 // Turn off caching for this host resolver. 788 resolver_.reset(new HostResolverImpl(scoped_ptr<HostCache>(), 789 DefaultLimits(), 790 DefaultParams(proc_.get()), 791 NULL)); 792 793 for (size_t i = 0; i < 4; ++i) { 794 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80 + i)->Resolve()) << i; 795 } 796 797 proc_->SignalMultiple(2u); // One for "a". One for the second "a". 798 799 EXPECT_EQ(OK, requests_[0]->WaitForResult()); 800 ASSERT_EQ(5u, requests_.size()); 801 EXPECT_EQ(OK, requests_.back()->WaitForResult()); 802 803 EXPECT_EQ(2u, proc_->GetCaptureList().size()); 804 } 805 806 TEST_F(HostResolverImplTest, BypassCache) { 807 struct MyHandler : public Handler { 808 virtual void Handle(Request* req) OVERRIDE { 809 if (req->index() == 0) { 810 // On completing the first request, start another request for "a". 811 // Since caching is enabled, this should complete synchronously. 812 std::string hostname = req->info().hostname(); 813 EXPECT_EQ(OK, CreateRequest(hostname, 70)->Resolve()); 814 EXPECT_EQ(OK, CreateRequest(hostname, 75)->ResolveFromCache()); 815 816 // Ok good. Now make sure that if we ask to bypass the cache, it can no 817 // longer service the request synchronously. 818 HostResolver::RequestInfo info(HostPortPair(hostname, 71)); 819 info.set_allow_cached_response(false); 820 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve()); 821 } else if (71 == req->info().port()) { 822 // Test is done. 823 base::MessageLoop::current()->Quit(); 824 } else { 825 FAIL() << "Unexpected request"; 826 } 827 } 828 }; 829 set_handler(new MyHandler()); 830 831 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a", 80)->Resolve()); 832 proc_->SignalMultiple(3u); // Only need two, but be generous. 833 834 // |verifier| will send quit message once all the requests have finished. 835 base::MessageLoop::current()->Run(); 836 EXPECT_EQ(2u, proc_->GetCaptureList().size()); 837 } 838 839 // Test that IP address changes flush the cache. 840 TEST_F(HostResolverImplTest, FlushCacheOnIPAddressChange) { 841 proc_->SignalMultiple(2u); // One before the flush, one after. 842 843 Request* req = CreateRequest("host1", 70); 844 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 845 EXPECT_EQ(OK, req->WaitForResult()); 846 847 req = CreateRequest("host1", 75); 848 EXPECT_EQ(OK, req->Resolve()); // Should complete synchronously. 849 850 // Flush cache by triggering an IP address change. 851 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 852 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 853 854 // Resolve "host1" again -- this time it won't be served from cache, so it 855 // will complete asynchronously. 856 req = CreateRequest("host1", 80); 857 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 858 EXPECT_EQ(OK, req->WaitForResult()); 859 } 860 861 // Test that IP address changes send ERR_NETWORK_CHANGED to pending requests. 862 TEST_F(HostResolverImplTest, AbortOnIPAddressChanged) { 863 Request* req = CreateRequest("host1", 70); 864 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 865 866 EXPECT_TRUE(proc_->WaitFor(1u)); 867 // Triggering an IP address change. 868 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 869 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 870 proc_->SignalAll(); 871 872 EXPECT_EQ(ERR_NETWORK_CHANGED, req->WaitForResult()); 873 EXPECT_EQ(0u, resolver_->GetHostCache()->size()); 874 } 875 876 // Obey pool constraints after IP address has changed. 877 TEST_F(HostResolverImplTest, ObeyPoolConstraintsAfterIPAddressChange) { 878 // Runs at most one job at a time. 879 CreateSerialResolver(); 880 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("a")->Resolve()); 881 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("b")->Resolve()); 882 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("c")->Resolve()); 883 884 EXPECT_TRUE(proc_->WaitFor(1u)); 885 // Triggering an IP address change. 886 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 887 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 888 proc_->SignalMultiple(3u); // Let the false-start go so that we can catch it. 889 890 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->WaitForResult()); 891 892 EXPECT_EQ(1u, num_running_jobs()); 893 894 EXPECT_FALSE(requests_[1]->completed()); 895 EXPECT_FALSE(requests_[2]->completed()); 896 897 EXPECT_EQ(OK, requests_[2]->WaitForResult()); 898 EXPECT_EQ(OK, requests_[1]->result()); 899 } 900 901 // Tests that a new Request made from the callback of a previously aborted one 902 // will not be aborted. 903 TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) { 904 struct MyHandler : public Handler { 905 virtual void Handle(Request* req) OVERRIDE { 906 // Start new request for a different hostname to ensure that the order 907 // of jobs in HostResolverImpl is not stable. 908 std::string hostname; 909 if (req->index() == 0) 910 hostname = "zzz"; 911 else if (req->index() == 1) 912 hostname = "aaa"; 913 else if (req->index() == 2) 914 hostname = "eee"; 915 else 916 return; // A request started from within MyHandler. 917 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname)->Resolve()) << hostname; 918 } 919 }; 920 set_handler(new MyHandler()); 921 922 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("bbb")->Resolve()); 923 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("eee")->Resolve()); 924 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ccc")->Resolve()); 925 926 // Wait until all are blocked; 927 EXPECT_TRUE(proc_->WaitFor(3u)); 928 // Trigger an IP address change. 929 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 930 // This should abort all running jobs. 931 base::MessageLoop::current()->RunUntilIdle(); 932 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[0]->result()); 933 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[1]->result()); 934 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->result()); 935 ASSERT_EQ(6u, requests_.size()); 936 // Unblock all calls to proc. 937 proc_->SignalMultiple(requests_.size()); 938 // Run until the re-started requests finish. 939 EXPECT_EQ(OK, requests_[3]->WaitForResult()); 940 EXPECT_EQ(OK, requests_[4]->WaitForResult()); 941 EXPECT_EQ(OK, requests_[5]->WaitForResult()); 942 // Verify that results of aborted Jobs were not cached. 943 EXPECT_EQ(6u, proc_->GetCaptureList().size()); 944 EXPECT_EQ(3u, resolver_->GetHostCache()->size()); 945 } 946 947 // Tests that when the maximum threads is set to 1, requests are dequeued 948 // in order of priority. 949 TEST_F(HostResolverImplTest, HigherPriorityRequestsStartedFirst) { 950 CreateSerialResolver(); 951 952 // Note that at this point the MockHostResolverProc is blocked, so any 953 // requests we make will not complete. 954 CreateRequest("req0", 80, LOW); 955 CreateRequest("req1", 80, MEDIUM); 956 CreateRequest("req2", 80, MEDIUM); 957 CreateRequest("req3", 80, LOW); 958 CreateRequest("req4", 80, HIGHEST); 959 CreateRequest("req5", 80, LOW); 960 CreateRequest("req6", 80, LOW); 961 CreateRequest("req5", 80, HIGHEST); 962 963 for (size_t i = 0; i < requests_.size(); ++i) { 964 EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; 965 } 966 967 // Unblock the resolver thread so the requests can run. 968 proc_->SignalMultiple(requests_.size()); // More than needed. 969 970 // Wait for all the requests to complete succesfully. 971 for (size_t i = 0; i < requests_.size(); ++i) { 972 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 973 } 974 975 // Since we have restricted to a single concurrent thread in the jobpool, 976 // the requests should complete in order of priority (with the exception 977 // of the first request, which gets started right away, since there is 978 // nothing outstanding). 979 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); 980 ASSERT_EQ(7u, capture_list.size()); 981 982 EXPECT_EQ("req0", capture_list[0].hostname); 983 EXPECT_EQ("req4", capture_list[1].hostname); 984 EXPECT_EQ("req5", capture_list[2].hostname); 985 EXPECT_EQ("req1", capture_list[3].hostname); 986 EXPECT_EQ("req2", capture_list[4].hostname); 987 EXPECT_EQ("req3", capture_list[5].hostname); 988 EXPECT_EQ("req6", capture_list[6].hostname); 989 } 990 991 // Try cancelling a job which has not started yet. 992 TEST_F(HostResolverImplTest, CancelPendingRequest) { 993 CreateSerialResolver(); 994 995 CreateRequest("req0", 80, LOWEST); 996 CreateRequest("req1", 80, HIGHEST); // Will cancel. 997 CreateRequest("req2", 80, MEDIUM); 998 CreateRequest("req3", 80, LOW); 999 CreateRequest("req4", 80, HIGHEST); // Will cancel. 1000 CreateRequest("req5", 80, LOWEST); // Will cancel. 1001 CreateRequest("req6", 80, MEDIUM); 1002 1003 // Start all of the requests. 1004 for (size_t i = 0; i < requests_.size(); ++i) { 1005 EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; 1006 } 1007 1008 // Cancel some requests 1009 requests_[1]->Cancel(); 1010 requests_[4]->Cancel(); 1011 requests_[5]->Cancel(); 1012 1013 // Unblock the resolver thread so the requests can run. 1014 proc_->SignalMultiple(requests_.size()); // More than needed. 1015 1016 // Wait for all the requests to complete succesfully. 1017 for (size_t i = 0; i < requests_.size(); ++i) { 1018 if (!requests_[i]->pending()) 1019 continue; // Don't wait for the requests we cancelled. 1020 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1021 } 1022 1023 // Verify that they called out the the resolver proc (which runs on the 1024 // resolver thread) in the expected order. 1025 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); 1026 ASSERT_EQ(4u, capture_list.size()); 1027 1028 EXPECT_EQ("req0", capture_list[0].hostname); 1029 EXPECT_EQ("req2", capture_list[1].hostname); 1030 EXPECT_EQ("req6", capture_list[2].hostname); 1031 EXPECT_EQ("req3", capture_list[3].hostname); 1032 } 1033 1034 // Test that when too many requests are enqueued, old ones start to be aborted. 1035 TEST_F(HostResolverImplTest, QueueOverflow) { 1036 CreateSerialResolver(); 1037 1038 // Allow only 3 queued jobs. 1039 const size_t kMaxPendingJobs = 3u; 1040 resolver_->SetMaxQueuedJobs(kMaxPendingJobs); 1041 1042 // Note that at this point the MockHostResolverProc is blocked, so any 1043 // requests we make will not complete. 1044 1045 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req0", 80, LOWEST)->Resolve()); 1046 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req1", 80, HIGHEST)->Resolve()); 1047 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req2", 80, MEDIUM)->Resolve()); 1048 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req3", 80, MEDIUM)->Resolve()); 1049 1050 // At this point, there are 3 enqueued jobs. 1051 // Insertion of subsequent requests will cause evictions 1052 // based on priority. 1053 1054 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, 1055 CreateRequest("req4", 80, LOW)->Resolve()); // Evicts itself! 1056 1057 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req5", 80, MEDIUM)->Resolve()); 1058 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[2]->result()); 1059 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req6", 80, HIGHEST)->Resolve()); 1060 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[3]->result()); 1061 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("req7", 80, MEDIUM)->Resolve()); 1062 EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, requests_[5]->result()); 1063 1064 // Unblock the resolver thread so the requests can run. 1065 proc_->SignalMultiple(4u); 1066 1067 // The rest should succeed. 1068 EXPECT_EQ(OK, requests_[7]->WaitForResult()); 1069 EXPECT_EQ(OK, requests_[0]->result()); 1070 EXPECT_EQ(OK, requests_[1]->result()); 1071 EXPECT_EQ(OK, requests_[6]->result()); 1072 1073 // Verify that they called out the the resolver proc (which runs on the 1074 // resolver thread) in the expected order. 1075 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); 1076 ASSERT_EQ(4u, capture_list.size()); 1077 1078 EXPECT_EQ("req0", capture_list[0].hostname); 1079 EXPECT_EQ("req1", capture_list[1].hostname); 1080 EXPECT_EQ("req6", capture_list[2].hostname); 1081 EXPECT_EQ("req7", capture_list[3].hostname); 1082 1083 // Verify that the evicted (incomplete) requests were not cached. 1084 EXPECT_EQ(4u, resolver_->GetHostCache()->size()); 1085 1086 for (size_t i = 0; i < requests_.size(); ++i) { 1087 EXPECT_TRUE(requests_[i]->completed()) << i; 1088 } 1089 } 1090 1091 // Tests that after changing the default AddressFamily to IPV4, requests 1092 // with UNSPECIFIED address family map to IPV4. 1093 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv4) { 1094 CreateSerialResolver(); // To guarantee order of resolutions. 1095 1096 proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1"); 1097 proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2"); 1098 1099 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1100 1101 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED); 1102 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4); 1103 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6); 1104 1105 // Start all of the requests. 1106 for (size_t i = 0; i < requests_.size(); ++i) { 1107 EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; 1108 } 1109 1110 proc_->SignalMultiple(requests_.size()); 1111 1112 // Wait for all the requests to complete. 1113 for (size_t i = 0u; i < requests_.size(); ++i) { 1114 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1115 } 1116 1117 // Since the requests all had the same priority and we limited the thread 1118 // count to 1, they should have completed in the same order as they were 1119 // requested. Moreover, request0 and request1 will have been serviced by 1120 // the same job. 1121 1122 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); 1123 ASSERT_EQ(2u, capture_list.size()); 1124 1125 EXPECT_EQ("h1", capture_list[0].hostname); 1126 EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[0].address_family); 1127 1128 EXPECT_EQ("h1", capture_list[1].hostname); 1129 EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[1].address_family); 1130 1131 // Now check that the correct resolved IP addresses were returned. 1132 EXPECT_TRUE(requests_[0]->HasOneAddress("1.0.0.1", 80)); 1133 EXPECT_TRUE(requests_[1]->HasOneAddress("1.0.0.1", 80)); 1134 EXPECT_TRUE(requests_[2]->HasOneAddress("::2", 80)); 1135 } 1136 1137 // This is the exact same test as SetDefaultAddressFamily_IPv4, except the 1138 // default family is set to IPv6 and the family of requests is flipped where 1139 // specified. 1140 TEST_F(HostResolverImplTest, SetDefaultAddressFamily_IPv6) { 1141 CreateSerialResolver(); // To guarantee order of resolutions. 1142 1143 // Don't use IPv6 replacements here since some systems don't support it. 1144 proc_->AddRule("h1", ADDRESS_FAMILY_IPV4, "1.0.0.1"); 1145 proc_->AddRule("h1", ADDRESS_FAMILY_IPV6, "::2"); 1146 1147 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV6); 1148 1149 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_UNSPECIFIED); 1150 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV6); 1151 CreateRequest("h1", 80, MEDIUM, ADDRESS_FAMILY_IPV4); 1152 1153 // Start all of the requests. 1154 for (size_t i = 0; i < requests_.size(); ++i) { 1155 EXPECT_EQ(ERR_IO_PENDING, requests_[i]->Resolve()) << i; 1156 } 1157 1158 proc_->SignalMultiple(requests_.size()); 1159 1160 // Wait for all the requests to complete. 1161 for (size_t i = 0u; i < requests_.size(); ++i) { 1162 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1163 } 1164 1165 // Since the requests all had the same priority and we limited the thread 1166 // count to 1, they should have completed in the same order as they were 1167 // requested. Moreover, request0 and request1 will have been serviced by 1168 // the same job. 1169 1170 MockHostResolverProc::CaptureList capture_list = proc_->GetCaptureList(); 1171 ASSERT_EQ(2u, capture_list.size()); 1172 1173 EXPECT_EQ("h1", capture_list[0].hostname); 1174 EXPECT_EQ(ADDRESS_FAMILY_IPV6, capture_list[0].address_family); 1175 1176 EXPECT_EQ("h1", capture_list[1].hostname); 1177 EXPECT_EQ(ADDRESS_FAMILY_IPV4, capture_list[1].address_family); 1178 1179 // Now check that the correct resolved IP addresses were returned. 1180 EXPECT_TRUE(requests_[0]->HasOneAddress("::2", 80)); 1181 EXPECT_TRUE(requests_[1]->HasOneAddress("::2", 80)); 1182 EXPECT_TRUE(requests_[2]->HasOneAddress("1.0.0.1", 80)); 1183 } 1184 1185 TEST_F(HostResolverImplTest, ResolveFromCache) { 1186 proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42"); 1187 proc_->SignalMultiple(1u); // Need only one. 1188 1189 HostResolver::RequestInfo info(HostPortPair("just.testing", 80)); 1190 1191 // First hit will miss the cache. 1192 EXPECT_EQ(ERR_DNS_CACHE_MISS, CreateRequest(info)->ResolveFromCache()); 1193 1194 // This time, we fetch normally. 1195 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(info)->Resolve()); 1196 EXPECT_EQ(OK, requests_[1]->WaitForResult()); 1197 1198 // Now we should be able to fetch from the cache. 1199 EXPECT_EQ(OK, CreateRequest(info)->ResolveFromCache()); 1200 EXPECT_TRUE(requests_[2]->HasOneAddress("192.168.1.42", 80)); 1201 } 1202 1203 // Test the retry attempts simulating host resolver proc that takes too long. 1204 TEST_F(HostResolverImplTest, MultipleAttempts) { 1205 // Total number of attempts would be 3 and we want the 3rd attempt to resolve 1206 // the host. First and second attempt will be forced to sleep until they get 1207 // word that a resolution has completed. The 3rd resolution attempt will try 1208 // to get done ASAP, and won't sleep.. 1209 int kAttemptNumberToResolve = 3; 1210 int kTotalAttempts = 3; 1211 1212 scoped_refptr<LookupAttemptHostResolverProc> resolver_proc( 1213 new LookupAttemptHostResolverProc( 1214 NULL, kAttemptNumberToResolve, kTotalAttempts)); 1215 1216 HostResolverImpl::ProcTaskParams params = DefaultParams(resolver_proc.get()); 1217 1218 // Specify smaller interval for unresponsive_delay_ for HostResolverImpl so 1219 // that unit test runs faster. For example, this test finishes in 1.5 secs 1220 // (500ms * 3). 1221 params.unresponsive_delay = base::TimeDelta::FromMilliseconds(500); 1222 1223 resolver_.reset( 1224 new HostResolverImpl(HostCache::CreateDefaultCache(), 1225 DefaultLimits(), 1226 params, 1227 NULL)); 1228 1229 // Resolve "host1". 1230 HostResolver::RequestInfo info(HostPortPair("host1", 70)); 1231 Request* req = CreateRequest(info); 1232 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1233 1234 // Resolve returns -4 to indicate that 3rd attempt has resolved the host. 1235 EXPECT_EQ(-4, req->WaitForResult()); 1236 1237 resolver_proc->WaitForAllAttemptsToFinish( 1238 base::TimeDelta::FromMilliseconds(60000)); 1239 base::MessageLoop::current()->RunUntilIdle(); 1240 1241 EXPECT_EQ(resolver_proc->total_attempts_resolved(), kTotalAttempts); 1242 EXPECT_EQ(resolver_proc->resolved_attempt_number(), kAttemptNumberToResolve); 1243 } 1244 1245 DnsConfig CreateValidDnsConfig() { 1246 IPAddressNumber dns_ip; 1247 bool rv = ParseIPLiteralToNumber("192.168.1.0", &dns_ip); 1248 EXPECT_TRUE(rv); 1249 1250 DnsConfig config; 1251 config.nameservers.push_back(IPEndPoint(dns_ip, dns_protocol::kDefaultPort)); 1252 EXPECT_TRUE(config.IsValid()); 1253 return config; 1254 } 1255 1256 // Specialized fixture for tests of DnsTask. 1257 class HostResolverImplDnsTest : public HostResolverImplTest { 1258 protected: 1259 virtual void SetUp() OVERRIDE { 1260 AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL); 1261 AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL); 1262 AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK); 1263 AddDnsRule("ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK); 1264 AddDnsRule("4ok", dns_protocol::kTypeA, MockDnsClientRule::OK); 1265 AddDnsRule("4ok", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY); 1266 AddDnsRule("6ok", dns_protocol::kTypeA, MockDnsClientRule::EMPTY); 1267 AddDnsRule("6ok", dns_protocol::kTypeAAAA, MockDnsClientRule::OK); 1268 AddDnsRule("4nx", dns_protocol::kTypeA, MockDnsClientRule::OK); 1269 AddDnsRule("4nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL); 1270 CreateResolver(); 1271 } 1272 1273 void CreateResolver() { 1274 resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(), 1275 DefaultLimits(), 1276 DefaultParams(proc_.get()), 1277 NULL)); 1278 // Disable IPv6 support probing. 1279 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_UNSPECIFIED); 1280 resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_)); 1281 } 1282 1283 // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply. 1284 void AddDnsRule(const std::string& prefix, 1285 uint16 qtype, 1286 MockDnsClientRule::Result result) { 1287 dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result)); 1288 } 1289 1290 void ChangeDnsConfig(const DnsConfig& config) { 1291 NetworkChangeNotifier::SetDnsConfig(config); 1292 // Notification is delivered asynchronously. 1293 base::MessageLoop::current()->RunUntilIdle(); 1294 } 1295 1296 MockDnsClientRuleList dns_rules_; 1297 }; 1298 1299 // TODO(szym): Test AbortAllInProgressJobs due to DnsConfig change. 1300 1301 // TODO(cbentzel): Test a mix of requests with different HostResolverFlags. 1302 1303 // Test successful and fallback resolutions in HostResolverImpl::DnsTask. 1304 TEST_F(HostResolverImplDnsTest, DnsTask) { 1305 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1306 1307 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102"); 1308 // All other hostnames will fail in proc_. 1309 1310 // Initially there is no config, so client should not be invoked. 1311 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve()); 1312 proc_->SignalMultiple(requests_.size()); 1313 1314 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult()); 1315 1316 ChangeDnsConfig(CreateValidDnsConfig()); 1317 1318 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve()); 1319 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve()); 1320 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve()); 1321 1322 proc_->SignalMultiple(requests_.size()); 1323 1324 for (size_t i = 1; i < requests_.size(); ++i) 1325 EXPECT_NE(ERR_UNEXPECTED, requests_[i]->WaitForResult()) << i; 1326 1327 EXPECT_EQ(OK, requests_[1]->result()); 1328 // Resolved by MockDnsClient. 1329 EXPECT_TRUE(requests_[1]->HasOneAddress("127.0.0.1", 80)); 1330 // Fallback to ProcTask. 1331 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[2]->result()); 1332 EXPECT_EQ(OK, requests_[3]->result()); 1333 EXPECT_TRUE(requests_[3]->HasOneAddress("192.168.1.102", 80)); 1334 } 1335 1336 // Test successful and failing resolutions in HostResolverImpl::DnsTask when 1337 // fallback to ProcTask is disabled. 1338 TEST_F(HostResolverImplDnsTest, NoFallbackToProcTask) { 1339 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1340 set_fallback_to_proctask(false); 1341 1342 proc_->AddRuleForAllFamilies("nx_succeed", "192.168.1.102"); 1343 // All other hostnames will fail in proc_. 1344 1345 // Set empty DnsConfig. 1346 ChangeDnsConfig(DnsConfig()); 1347 // Initially there is no config, so client should not be invoked. 1348 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve()); 1349 // There is no config, so fallback to ProcTask must work. 1350 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_succeed", 80)->Resolve()); 1351 proc_->SignalMultiple(requests_.size()); 1352 1353 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[0]->WaitForResult()); 1354 EXPECT_EQ(OK, requests_[1]->WaitForResult()); 1355 EXPECT_TRUE(requests_[1]->HasOneAddress("192.168.1.102", 80)); 1356 1357 ChangeDnsConfig(CreateValidDnsConfig()); 1358 1359 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_abort", 80)->Resolve()); 1360 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve()); 1361 1362 // Simulate the case when the preference or policy has disabled the DNS client 1363 // causing AbortDnsTasks. 1364 resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_)); 1365 ChangeDnsConfig(CreateValidDnsConfig()); 1366 1367 // First request is resolved by MockDnsClient, others should fail due to 1368 // disabled fallback to ProcTask. 1369 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok_fail", 80)->Resolve()); 1370 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_fail", 80)->Resolve()); 1371 proc_->SignalMultiple(requests_.size()); 1372 1373 // Aborted due to Network Change. 1374 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[2]->WaitForResult()); 1375 EXPECT_EQ(ERR_NETWORK_CHANGED, requests_[3]->WaitForResult()); 1376 // Resolved by MockDnsClient. 1377 EXPECT_EQ(OK, requests_[4]->WaitForResult()); 1378 EXPECT_TRUE(requests_[4]->HasOneAddress("127.0.0.1", 80)); 1379 // Fallback to ProcTask is disabled. 1380 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[5]->WaitForResult()); 1381 } 1382 1383 // Test behavior of OnDnsTaskFailure when Job is aborted. 1384 TEST_F(HostResolverImplDnsTest, OnDnsTaskFailureAbortedJob) { 1385 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1386 ChangeDnsConfig(CreateValidDnsConfig()); 1387 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve()); 1388 // Abort all jobs here. 1389 CreateResolver(); 1390 proc_->SignalMultiple(requests_.size()); 1391 // Run to completion. 1392 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 1393 // It shouldn't crash during OnDnsTaskFailure callbacks. 1394 EXPECT_EQ(ERR_IO_PENDING, requests_[0]->result()); 1395 1396 // Repeat test with Fallback to ProcTask disabled 1397 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1398 set_fallback_to_proctask(false); 1399 ChangeDnsConfig(CreateValidDnsConfig()); 1400 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("nx_abort", 80)->Resolve()); 1401 // Abort all jobs here. 1402 CreateResolver(); 1403 // Run to completion. 1404 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 1405 // It shouldn't crash during OnDnsTaskFailure callbacks. 1406 EXPECT_EQ(ERR_IO_PENDING, requests_[1]->result()); 1407 } 1408 1409 TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) { 1410 ChangeDnsConfig(CreateValidDnsConfig()); 1411 1412 proc_->AddRuleForAllFamilies("4nx", "192.168.1.101"); 1413 // All other hostnames will fail in proc_. 1414 1415 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve()); 1416 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4ok", 80)->Resolve()); 1417 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("6ok", 80)->Resolve()); 1418 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("4nx", 80)->Resolve()); 1419 1420 proc_->SignalMultiple(requests_.size()); 1421 1422 for (size_t i = 0; i < requests_.size(); ++i) 1423 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1424 1425 EXPECT_EQ(2u, requests_[0]->NumberOfAddresses()); 1426 EXPECT_TRUE(requests_[0]->HasAddress("127.0.0.1", 80)); 1427 EXPECT_TRUE(requests_[0]->HasAddress("::1", 80)); 1428 EXPECT_EQ(1u, requests_[1]->NumberOfAddresses()); 1429 EXPECT_TRUE(requests_[1]->HasAddress("127.0.0.1", 80)); 1430 EXPECT_EQ(1u, requests_[2]->NumberOfAddresses()); 1431 EXPECT_TRUE(requests_[2]->HasAddress("::1", 80)); 1432 EXPECT_EQ(1u, requests_[3]->NumberOfAddresses()); 1433 EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80)); 1434 } 1435 1436 TEST_F(HostResolverImplDnsTest, ServeFromHosts) { 1437 // Initially, use empty HOSTS file. 1438 DnsConfig config = CreateValidDnsConfig(); 1439 ChangeDnsConfig(config); 1440 1441 proc_->AddRuleForAllFamilies(std::string(), 1442 std::string()); // Default to failures. 1443 proc_->SignalMultiple(1u); // For the first request which misses. 1444 1445 Request* req0 = CreateRequest("nx_ipv4", 80); 1446 EXPECT_EQ(ERR_IO_PENDING, req0->Resolve()); 1447 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult()); 1448 1449 IPAddressNumber local_ipv4, local_ipv6; 1450 ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4)); 1451 ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6)); 1452 1453 DnsHosts hosts; 1454 hosts[DnsHostsKey("nx_ipv4", ADDRESS_FAMILY_IPV4)] = local_ipv4; 1455 hosts[DnsHostsKey("nx_ipv6", ADDRESS_FAMILY_IPV6)] = local_ipv6; 1456 hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV4)] = local_ipv4; 1457 hosts[DnsHostsKey("nx_both", ADDRESS_FAMILY_IPV6)] = local_ipv6; 1458 1459 // Update HOSTS file. 1460 config.hosts = hosts; 1461 ChangeDnsConfig(config); 1462 1463 Request* req1 = CreateRequest("nx_ipv4", 80); 1464 EXPECT_EQ(OK, req1->Resolve()); 1465 EXPECT_TRUE(req1->HasOneAddress("127.0.0.1", 80)); 1466 1467 Request* req2 = CreateRequest("nx_ipv6", 80); 1468 EXPECT_EQ(OK, req2->Resolve()); 1469 EXPECT_TRUE(req2->HasOneAddress("::1", 80)); 1470 1471 Request* req3 = CreateRequest("nx_both", 80); 1472 EXPECT_EQ(OK, req3->Resolve()); 1473 EXPECT_TRUE(req3->HasAddress("127.0.0.1", 80) && 1474 req3->HasAddress("::1", 80)); 1475 1476 // Requests with specified AddressFamily. 1477 Request* req4 = CreateRequest("nx_ipv4", 80, MEDIUM, ADDRESS_FAMILY_IPV4); 1478 EXPECT_EQ(OK, req4->Resolve()); 1479 EXPECT_TRUE(req4->HasOneAddress("127.0.0.1", 80)); 1480 1481 Request* req5 = CreateRequest("nx_ipv6", 80, MEDIUM, ADDRESS_FAMILY_IPV6); 1482 EXPECT_EQ(OK, req5->Resolve()); 1483 EXPECT_TRUE(req5->HasOneAddress("::1", 80)); 1484 1485 // Request with upper case. 1486 Request* req6 = CreateRequest("nx_IPV4", 80); 1487 EXPECT_EQ(OK, req6->Resolve()); 1488 EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80)); 1489 } 1490 1491 TEST_F(HostResolverImplDnsTest, BypassDnsTask) { 1492 ChangeDnsConfig(CreateValidDnsConfig()); 1493 1494 proc_->AddRuleForAllFamilies(std::string(), 1495 std::string()); // Default to failures. 1496 1497 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve()); 1498 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve()); 1499 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve()); 1500 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve()); 1501 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve()); 1502 1503 proc_->SignalMultiple(requests_.size()); 1504 1505 for (size_t i = 0; i < 2; ++i) 1506 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i; 1507 1508 for (size_t i = 2; i < requests_.size(); ++i) 1509 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1510 } 1511 1512 TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) { 1513 ChangeDnsConfig(CreateValidDnsConfig()); 1514 1515 proc_->AddRuleForAllFamilies(std::string(), 1516 std::string()); // Default to failures. 1517 1518 // Check that DnsTask works. 1519 Request* req = CreateRequest("ok_1", 80); 1520 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1521 EXPECT_EQ(OK, req->WaitForResult()); 1522 1523 for (unsigned i = 0; i < 20; ++i) { 1524 // Use custom names to require separate Jobs. 1525 std::string hostname = base::StringPrintf("nx_%u", i); 1526 // Ensure fallback to ProcTask succeeds. 1527 proc_->AddRuleForAllFamilies(hostname, "192.168.1.101"); 1528 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i; 1529 } 1530 1531 proc_->SignalMultiple(requests_.size()); 1532 1533 for (size_t i = 0; i < requests_.size(); ++i) 1534 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1535 1536 ASSERT_FALSE(proc_->HasBlockedRequests()); 1537 1538 // DnsTask should be disabled by now. 1539 req = CreateRequest("ok_2", 80); 1540 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1541 proc_->SignalMultiple(1u); 1542 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult()); 1543 1544 // Check that it is re-enabled after DNS change. 1545 ChangeDnsConfig(CreateValidDnsConfig()); 1546 req = CreateRequest("ok_3", 80); 1547 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1548 EXPECT_EQ(OK, req->WaitForResult()); 1549 } 1550 1551 TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) { 1552 ChangeDnsConfig(CreateValidDnsConfig()); 1553 1554 // |proc_| defaults to successes. 1555 1556 // 20 failures interleaved with 20 successes. 1557 for (unsigned i = 0; i < 40; ++i) { 1558 // Use custom names to require separate Jobs. 1559 std::string hostname = (i % 2) == 0 ? base::StringPrintf("nx_%u", i) 1560 : base::StringPrintf("ok_%u", i); 1561 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i; 1562 } 1563 1564 proc_->SignalMultiple(requests_.size()); 1565 1566 for (size_t i = 0; i < requests_.size(); ++i) 1567 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; 1568 1569 // Make |proc_| default to failures. 1570 proc_->AddRuleForAllFamilies(std::string(), std::string()); 1571 1572 // DnsTask should still be enabled. 1573 Request* req = CreateRequest("ok_last", 80); 1574 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1575 EXPECT_EQ(OK, req->WaitForResult()); 1576 } 1577 1578 // Confirm that resolving "localhost" is unrestricted even if there are no 1579 // global IPv6 address. See SystemHostResolverCall for rationale. 1580 // Test both the DnsClient and system host resolver paths. 1581 TEST_F(HostResolverImplDnsTest, DualFamilyLocalhost) { 1582 // Use regular SystemHostResolverCall! 1583 scoped_refptr<HostResolverProc> proc(new SystemHostResolverProc()); 1584 resolver_.reset(new HostResolverImpl(HostCache::CreateDefaultCache(), 1585 DefaultLimits(), 1586 DefaultParams(proc.get()), 1587 NULL)); 1588 resolver_->SetDnsClient(CreateMockDnsClient(DnsConfig(), dns_rules_)); 1589 resolver_->SetDefaultAddressFamily(ADDRESS_FAMILY_IPV4); 1590 1591 // Get the expected output. 1592 AddressList addrlist; 1593 int rv = proc->Resolve("localhost", ADDRESS_FAMILY_UNSPECIFIED, 0, &addrlist, 1594 NULL); 1595 if (rv != OK) 1596 return; 1597 1598 for (unsigned i = 0; i < addrlist.size(); ++i) 1599 LOG(WARNING) << addrlist[i].ToString(); 1600 1601 bool saw_ipv4 = AddressListContains(addrlist, "127.0.0.1", 0); 1602 bool saw_ipv6 = AddressListContains(addrlist, "::1", 0); 1603 if (!saw_ipv4 && !saw_ipv6) 1604 return; 1605 1606 HostResolver::RequestInfo info(HostPortPair("localhost", 80)); 1607 info.set_address_family(ADDRESS_FAMILY_UNSPECIFIED); 1608 info.set_host_resolver_flags(HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6); 1609 1610 // Try without DnsClient. 1611 ChangeDnsConfig(DnsConfig()); 1612 Request* req = CreateRequest(info); 1613 // It is resolved via getaddrinfo, so expect asynchronous result. 1614 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); 1615 EXPECT_EQ(OK, req->WaitForResult()); 1616 1617 EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80)); 1618 EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80)); 1619 1620 // Configure DnsClient with dual-host HOSTS file. 1621 DnsConfig config = CreateValidDnsConfig(); 1622 DnsHosts hosts; 1623 IPAddressNumber local_ipv4, local_ipv6; 1624 ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4)); 1625 ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6)); 1626 if (saw_ipv4) 1627 hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV4)] = local_ipv4; 1628 if (saw_ipv6) 1629 hosts[DnsHostsKey("localhost", ADDRESS_FAMILY_IPV6)] = local_ipv6; 1630 config.hosts = hosts; 1631 1632 ChangeDnsConfig(config); 1633 req = CreateRequest(info); 1634 // Expect synchronous resolution from DnsHosts. 1635 EXPECT_EQ(OK, req->Resolve()); 1636 1637 EXPECT_EQ(saw_ipv4, req->HasAddress("127.0.0.1", 80)); 1638 EXPECT_EQ(saw_ipv6, req->HasAddress("::1", 80)); 1639 } 1640 1641 } // namespace net 1642