| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "services/proxy_resolver/host_resolver_mojo.h" |
| |
| #include <memory> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/callback_helpers.h" |
| #include "base/time/time.h" |
| #include "mojo/public/cpp/bindings/receiver.h" |
| #include "net/base/address_family.h" |
| #include "net/base/address_list.h" |
| #include "net/base/completion_once_callback.h" |
| #include "net/base/ip_address.h" |
| #include "net/base/net_errors.h" |
| #include "net/base/network_isolation_key.h" |
| #include "net/dns/host_resolver_source.h" |
| #include "net/dns/public/dns_query_type.h" |
| |
| namespace proxy_resolver { |
| namespace { |
| |
| // Default TTL for successful host resolutions. |
| constexpr auto kCacheEntryTTL = base::TimeDelta::FromSeconds(5); |
| |
| // Default TTL for unsuccessful host resolutions. |
| constexpr auto kNegativeCacheEntryTTL = base::TimeDelta(); |
| |
| net::HostCache::Key CacheKeyForRequest( |
| const std::string& hostname, |
| const net::NetworkIsolationKey& network_isolation_key, |
| net::ProxyResolveDnsOperation operation) { |
| net::DnsQueryType dns_query_type = net::DnsQueryType::UNSPECIFIED; |
| if (operation == net::ProxyResolveDnsOperation::MY_IP_ADDRESS || |
| operation == net::ProxyResolveDnsOperation::DNS_RESOLVE) { |
| dns_query_type = net::DnsQueryType::A; |
| } |
| |
| return net::HostCache::Key( |
| hostname, dns_query_type, 0 /* host_resolver_flags */, |
| net::HostResolverSource::ANY, network_isolation_key); |
| } |
| |
| } // namespace |
| |
| class HostResolverMojo::RequestImpl : public ProxyHostResolver::Request, |
| public mojom::HostResolverRequestClient { |
| public: |
| RequestImpl(const std::string& hostname, |
| net::ProxyResolveDnsOperation operation, |
| const net::NetworkIsolationKey& network_isolation_key, |
| base::WeakPtr<net::HostCache> host_cache, |
| Impl* impl) |
| : hostname_(hostname), |
| operation_(operation), |
| network_isolation_key_(network_isolation_key), |
| host_cache_(std::move(host_cache)), |
| impl_(impl) {} |
| |
| ~RequestImpl() override = default; |
| |
| // ProxyHostResolver::Request override |
| int Start(net::CompletionOnceCallback callback) override { |
| DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); |
| DVLOG(1) << "Resolve " << hostname_; |
| |
| int cached_result = ResolveFromCacheInternal(); |
| if (cached_result != net::ERR_DNS_CACHE_MISS) { |
| DVLOG(1) << "Resolved " << hostname_ << " from cache"; |
| return cached_result; |
| } |
| |
| callback_ = std::move(callback); |
| impl_->ResolveDns(hostname_, operation_, network_isolation_key_, |
| receiver_.BindNewPipeAndPassRemote()); |
| receiver_.set_disconnect_handler( |
| base::BindOnce(&RequestImpl::OnDisconnect, base::Unretained(this))); |
| return net::ERR_IO_PENDING; |
| } |
| |
| const std::vector<net::IPAddress>& GetResults() const override { |
| return results_; |
| } |
| |
| // mojom::HostResolverRequestClient override |
| void ReportResult(int32_t error, |
| const std::vector<net::IPAddress>& result) override { |
| DCHECK_CALLED_ON_VALID_THREAD(thread_checker_); |
| |
| if (error == net::OK) |
| results_ = result; |
| if (host_cache_) { |
| base::TimeDelta ttl = |
| error == net::OK ? kCacheEntryTTL : kNegativeCacheEntryTTL; |
| net::HostCache::Entry entry( |
| error, net::AddressList::CreateFromIPAddressList(result, {}), |
| net::HostCache::Entry::SOURCE_UNKNOWN, ttl); |
| host_cache_->Set( |
| CacheKeyForRequest(hostname_, network_isolation_key_, operation_), |
| entry, base::TimeTicks::Now(), ttl); |
| } |
| receiver_.reset(); |
| std::move(callback_).Run(error); |
| } |
| |
| private: |
| int ResolveFromCacheInternal() { |
| DCHECK(host_cache_); |
| |
| net::HostCache::Key key = |
| CacheKeyForRequest(hostname_, network_isolation_key_, operation_); |
| const std::pair<const net::HostCache::Key, net::HostCache::Entry>* |
| cache_result = host_cache_->Lookup(key, base::TimeTicks::Now()); |
| if (!cache_result) |
| return net::ERR_DNS_CACHE_MISS; |
| |
| results_ = AddressListToAddresses(cache_result->second.addresses().value()); |
| return cache_result->second.error(); |
| } |
| |
| void OnDisconnect() { ReportResult(net::ERR_FAILED, {} /* result */); } |
| |
| static std::vector<net::IPAddress> AddressListToAddresses( |
| net::AddressList address_list) { |
| std::vector<net::IPAddress> result; |
| for (net::IPEndPoint endpoint : address_list.endpoints()) { |
| result.push_back(endpoint.address()); |
| } |
| return result; |
| } |
| |
| const std::string hostname_; |
| const net::ProxyResolveDnsOperation operation_; |
| const net::NetworkIsolationKey network_isolation_key_; |
| |
| mojo::Receiver<mojom::HostResolverRequestClient> receiver_{this}; |
| net::CompletionOnceCallback callback_; |
| |
| base::WeakPtr<net::HostCache> host_cache_; |
| Impl* const impl_; |
| std::vector<net::IPAddress> results_; |
| |
| THREAD_CHECKER(thread_checker_); |
| }; |
| |
| HostResolverMojo::HostResolverMojo(Impl* impl) |
| : impl_(impl), |
| host_cache_(net::HostCache::CreateDefaultCache()), |
| host_cache_weak_factory_(host_cache_.get()) {} |
| |
| HostResolverMojo::~HostResolverMojo() = default; |
| |
| std::unique_ptr<ProxyHostResolver::Request> HostResolverMojo::CreateRequest( |
| const std::string& hostname, |
| net::ProxyResolveDnsOperation operation, |
| const net::NetworkIsolationKey& network_isolation_key) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| return std::make_unique<RequestImpl>( |
| hostname, operation, network_isolation_key, |
| host_cache_weak_factory_.GetWeakPtr(), impl_); |
| } |
| |
| } // namespace proxy_resolver |