OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/dns/host_resolver_impl.h" | 5 #include "net/dns/host_resolver_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
100 | 100 |
101 void AddRule(const std::string& hostname, AddressFamily family, | 101 void AddRule(const std::string& hostname, AddressFamily family, |
102 const AddressList& result) { | 102 const AddressList& result) { |
103 base::AutoLock lock(lock_); | 103 base::AutoLock lock(lock_); |
104 rules_[ResolveKey(hostname, family)] = result; | 104 rules_[ResolveKey(hostname, family)] = result; |
105 } | 105 } |
106 | 106 |
107 void AddRule(const std::string& hostname, AddressFamily family, | 107 void AddRule(const std::string& hostname, AddressFamily family, |
108 const std::string& ip_list) { | 108 const std::string& ip_list) { |
109 AddressList result; | 109 AddressList result; |
110 int rv = ParseAddressList(ip_list, "", &result); | 110 int rv = ParseAddressList(ip_list, std::string(), &result); |
111 DCHECK_EQ(OK, rv); | 111 DCHECK_EQ(OK, rv); |
112 AddRule(hostname, family, result); | 112 AddRule(hostname, family, result); |
113 } | 113 } |
114 | 114 |
115 void AddRuleForAllFamilies(const std::string& hostname, | 115 void AddRuleForAllFamilies(const std::string& hostname, |
116 const std::string& ip_list) { | 116 const std::string& ip_list) { |
117 AddressList result; | 117 AddressList result; |
118 int rv = ParseAddressList(ip_list, "", &result); | 118 int rv = ParseAddressList(ip_list, std::string(), &result); |
119 DCHECK_EQ(OK, rv); | 119 DCHECK_EQ(OK, rv); |
120 AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result); | 120 AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result); |
121 AddRule(hostname, ADDRESS_FAMILY_IPV4, result); | 121 AddRule(hostname, ADDRESS_FAMILY_IPV4, result); |
122 AddRule(hostname, ADDRESS_FAMILY_IPV6, result); | 122 AddRule(hostname, ADDRESS_FAMILY_IPV6, result); |
123 } | 123 } |
124 | 124 |
125 virtual int Resolve(const std::string& hostname, | 125 virtual int Resolve(const std::string& hostname, |
126 AddressFamily address_family, | 126 AddressFamily address_family, |
127 HostResolverFlags host_resolver_flags, | 127 HostResolverFlags host_resolver_flags, |
128 AddressList* addrlist, | 128 AddressList* addrlist, |
129 int* os_error) OVERRIDE { | 129 int* os_error) OVERRIDE { |
130 base::AutoLock lock(lock_); | 130 base::AutoLock lock(lock_); |
131 capture_list_.push_back(ResolveKey(hostname, address_family)); | 131 capture_list_.push_back(ResolveKey(hostname, address_family)); |
132 ++num_requests_waiting_; | 132 ++num_requests_waiting_; |
133 requests_waiting_.Broadcast(); | 133 requests_waiting_.Broadcast(); |
134 while (!num_slots_available_) | 134 while (!num_slots_available_) |
135 slots_available_.Wait(); | 135 slots_available_.Wait(); |
136 DCHECK_GT(num_requests_waiting_, 0u); | 136 DCHECK_GT(num_requests_waiting_, 0u); |
137 --num_slots_available_; | 137 --num_slots_available_; |
138 --num_requests_waiting_; | 138 --num_requests_waiting_; |
139 if (rules_.empty()) { | 139 if (rules_.empty()) { |
140 int rv = ParseAddressList("127.0.0.1", "", addrlist); | 140 int rv = ParseAddressList("127.0.0.1", std::string(), addrlist); |
141 DCHECK_EQ(OK, rv); | 141 DCHECK_EQ(OK, rv); |
142 return OK; | 142 return OK; |
143 } | 143 } |
144 ResolveKey key(hostname, address_family); | 144 ResolveKey key(hostname, address_family); |
145 if (rules_.count(key) == 0) | 145 if (rules_.count(key) == 0) |
146 return ERR_NAME_NOT_RESOLVED; | 146 return ERR_NAME_NOT_RESOLVED; |
147 *addrlist = rules_[key]; | 147 *addrlist = rules_[key]; |
148 return OK; | 148 return OK; |
149 } | 149 } |
150 | 150 |
(...skipping 369 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
520 Request* req = CreateRequest("just.testing", 80); | 520 Request* req = CreateRequest("just.testing", 80); |
521 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); | 521 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); |
522 EXPECT_EQ(OK, req->WaitForResult()); | 522 EXPECT_EQ(OK, req->WaitForResult()); |
523 | 523 |
524 EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80)); | 524 EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80)); |
525 | 525 |
526 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); | 526 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
527 } | 527 } |
528 | 528 |
529 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) { | 529 TEST_F(HostResolverImplTest, FailedAsynchronousLookup) { |
530 proc_->AddRuleForAllFamilies("", "0.0.0.0"); // Default to failures. | 530 proc_->AddRuleForAllFamilies(std::string(), |
| 531 "0.0.0.0"); // Default to failures. |
531 proc_->SignalMultiple(1u); | 532 proc_->SignalMultiple(1u); |
532 | 533 |
533 Request* req = CreateRequest("just.testing", 80); | 534 Request* req = CreateRequest("just.testing", 80); |
534 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); | 535 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); |
535 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult()); | 536 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->WaitForResult()); |
536 | 537 |
537 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); | 538 EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname); |
538 | 539 |
539 // Also test that the error is not cached. | 540 // Also test that the error is not cached. |
540 EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache()); | 541 EXPECT_EQ(ERR_DNS_CACHE_MISS, req->ResolveFromCache()); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
575 TEST_F(HostResolverImplTest, NumericIPv6Address) { | 576 TEST_F(HostResolverImplTest, NumericIPv6Address) { |
576 // Resolve a plain IPv6 address. Don't worry about [brackets], because | 577 // Resolve a plain IPv6 address. Don't worry about [brackets], because |
577 // the caller should have removed them. | 578 // the caller should have removed them. |
578 Request* req = CreateRequest("2001:db8::1", 5555); | 579 Request* req = CreateRequest("2001:db8::1", 5555); |
579 EXPECT_EQ(OK, req->Resolve()); | 580 EXPECT_EQ(OK, req->Resolve()); |
580 | 581 |
581 EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555)); | 582 EXPECT_TRUE(req->HasOneAddress("2001:db8::1", 5555)); |
582 } | 583 } |
583 | 584 |
584 TEST_F(HostResolverImplTest, EmptyHost) { | 585 TEST_F(HostResolverImplTest, EmptyHost) { |
585 Request* req = CreateRequest("", 5555); | 586 Request* req = CreateRequest(std::string(), 5555); |
586 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); | 587 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); |
587 } | 588 } |
588 | 589 |
589 TEST_F(HostResolverImplTest, LongHost) { | 590 TEST_F(HostResolverImplTest, LongHost) { |
590 Request* req = CreateRequest(std::string(4097, 'a'), 5555); | 591 Request* req = CreateRequest(std::string(4097, 'a'), 5555); |
591 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); | 592 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); |
592 } | 593 } |
593 | 594 |
594 TEST_F(HostResolverImplTest, DeDupeRequests) { | 595 TEST_F(HostResolverImplTest, DeDupeRequests) { |
595 // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is | 596 // Start 5 requests, duplicating hosts "a" and "b". Since the resolver_proc is |
(...skipping 741 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1337 EXPECT_TRUE(requests_[2]->HasAddress("::1", 80)); | 1338 EXPECT_TRUE(requests_[2]->HasAddress("::1", 80)); |
1338 EXPECT_EQ(1u, requests_[3]->NumberOfAddresses()); | 1339 EXPECT_EQ(1u, requests_[3]->NumberOfAddresses()); |
1339 EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80)); | 1340 EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80)); |
1340 } | 1341 } |
1341 | 1342 |
1342 TEST_F(HostResolverImplDnsTest, ServeFromHosts) { | 1343 TEST_F(HostResolverImplDnsTest, ServeFromHosts) { |
1343 // Initially, use empty HOSTS file. | 1344 // Initially, use empty HOSTS file. |
1344 DnsConfig config = CreateValidDnsConfig(); | 1345 DnsConfig config = CreateValidDnsConfig(); |
1345 ChangeDnsConfig(config); | 1346 ChangeDnsConfig(config); |
1346 | 1347 |
1347 proc_->AddRuleForAllFamilies("", ""); // Default to failures. | 1348 proc_->AddRuleForAllFamilies(std::string(), |
| 1349 std::string()); // Default to failures. |
1348 proc_->SignalMultiple(1u); // For the first request which misses. | 1350 proc_->SignalMultiple(1u); // For the first request which misses. |
1349 | 1351 |
1350 Request* req0 = CreateRequest("er_ipv4", 80); | 1352 Request* req0 = CreateRequest("er_ipv4", 80); |
1351 EXPECT_EQ(ERR_IO_PENDING, req0->Resolve()); | 1353 EXPECT_EQ(ERR_IO_PENDING, req0->Resolve()); |
1352 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult()); | 1354 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req0->WaitForResult()); |
1353 | 1355 |
1354 IPAddressNumber local_ipv4, local_ipv6; | 1356 IPAddressNumber local_ipv4, local_ipv6; |
1355 ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4)); | 1357 ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &local_ipv4)); |
1356 ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6)); | 1358 ASSERT_TRUE(ParseIPLiteralToNumber("::1", &local_ipv6)); |
1357 | 1359 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1389 | 1391 |
1390 // Request with upper case. | 1392 // Request with upper case. |
1391 Request* req6 = CreateRequest("er_IPV4", 80); | 1393 Request* req6 = CreateRequest("er_IPV4", 80); |
1392 EXPECT_EQ(OK, req6->Resolve()); | 1394 EXPECT_EQ(OK, req6->Resolve()); |
1393 EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80)); | 1395 EXPECT_TRUE(req6->HasOneAddress("127.0.0.1", 80)); |
1394 } | 1396 } |
1395 | 1397 |
1396 TEST_F(HostResolverImplDnsTest, BypassDnsTask) { | 1398 TEST_F(HostResolverImplDnsTest, BypassDnsTask) { |
1397 ChangeDnsConfig(CreateValidDnsConfig()); | 1399 ChangeDnsConfig(CreateValidDnsConfig()); |
1398 | 1400 |
1399 proc_->AddRuleForAllFamilies("", ""); // Default to failures. | 1401 proc_->AddRuleForAllFamilies(std::string(), |
| 1402 std::string()); // Default to failures. |
1400 | 1403 |
1401 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve()); | 1404 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve()); |
1402 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve()); | 1405 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve()); |
1403 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve()); | 1406 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal", 80)->Resolve()); |
1404 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve()); | 1407 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("oklocal.", 80)->Resolve()); |
1405 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve()); | 1408 EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok", 80)->Resolve()); |
1406 | 1409 |
1407 proc_->SignalMultiple(requests_.size()); | 1410 proc_->SignalMultiple(requests_.size()); |
1408 | 1411 |
1409 for (size_t i = 0; i < 2; ++i) | 1412 for (size_t i = 0; i < 2; ++i) |
1410 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i; | 1413 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, requests_[i]->WaitForResult()) << i; |
1411 | 1414 |
1412 for (size_t i = 2; i < requests_.size(); ++i) | 1415 for (size_t i = 2; i < requests_.size(); ++i) |
1413 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; | 1416 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; |
1414 } | 1417 } |
1415 | 1418 |
1416 TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) { | 1419 TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) { |
1417 ChangeDnsConfig(CreateValidDnsConfig()); | 1420 ChangeDnsConfig(CreateValidDnsConfig()); |
1418 | 1421 |
1419 proc_->AddRuleForAllFamilies("", ""); // Default to failures. | 1422 proc_->AddRuleForAllFamilies(std::string(), |
| 1423 std::string()); // Default to failures. |
1420 | 1424 |
1421 // Check that DnsTask works. | 1425 // Check that DnsTask works. |
1422 Request* req = CreateRequest("ok_1", 80); | 1426 Request* req = CreateRequest("ok_1", 80); |
1423 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); | 1427 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); |
1424 EXPECT_EQ(OK, req->WaitForResult()); | 1428 EXPECT_EQ(OK, req->WaitForResult()); |
1425 | 1429 |
1426 for (unsigned i = 0; i < 20; ++i) { | 1430 for (unsigned i = 0; i < 20; ++i) { |
1427 // Use custom names to require separate Jobs. | 1431 // Use custom names to require separate Jobs. |
1428 std::string hostname = base::StringPrintf("err_%u", i); | 1432 std::string hostname = base::StringPrintf("err_%u", i); |
1429 // Ensure fallback to ProcTask succeeds. | 1433 // Ensure fallback to ProcTask succeeds. |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1463 : base::StringPrintf("ok_%u", i); | 1467 : base::StringPrintf("ok_%u", i); |
1464 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i; | 1468 EXPECT_EQ(ERR_IO_PENDING, CreateRequest(hostname, 80)->Resolve()) << i; |
1465 } | 1469 } |
1466 | 1470 |
1467 proc_->SignalMultiple(requests_.size()); | 1471 proc_->SignalMultiple(requests_.size()); |
1468 | 1472 |
1469 for (size_t i = 0; i < requests_.size(); ++i) | 1473 for (size_t i = 0; i < requests_.size(); ++i) |
1470 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; | 1474 EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; |
1471 | 1475 |
1472 // Make |proc_| default to failures. | 1476 // Make |proc_| default to failures. |
1473 proc_->AddRuleForAllFamilies("", ""); | 1477 proc_->AddRuleForAllFamilies(std::string(), std::string()); |
1474 | 1478 |
1475 // DnsTask should still be enabled. | 1479 // DnsTask should still be enabled. |
1476 Request* req = CreateRequest("ok_last", 80); | 1480 Request* req = CreateRequest("ok_last", 80); |
1477 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); | 1481 EXPECT_EQ(ERR_IO_PENDING, req->Resolve()); |
1478 EXPECT_EQ(OK, req->WaitForResult()); | 1482 EXPECT_EQ(OK, req->WaitForResult()); |
1479 } | 1483 } |
1480 | 1484 |
1481 } // namespace net | 1485 } // namespace net |
OLD | NEW |