123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131 |
- // Copyright (c) 2012 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 "net/dns/host_cache.h"
- #include <algorithm>
- #include <iterator>
- #include <map>
- #include <ostream>
- #include <string>
- #include <type_traits>
- #include <unordered_set>
- #include <utility>
- #include <vector>
- #include "base/bind.h"
- #include "base/check_op.h"
- #include "base/metrics/field_trial.h"
- #include "base/metrics/histogram_macros.h"
- #include "base/numerics/safe_conversions.h"
- #include "base/stl_util.h"
- #include "base/strings/string_number_conversions.h"
- #include "base/strings/string_piece.h"
- #include "base/time/default_tick_clock.h"
- #include "base/trace_event/trace_event.h"
- #include "base/value_iterators.h"
- #include "net/base/address_family.h"
- #include "net/base/ip_endpoint.h"
- #include "net/base/trace_constants.h"
- #include "net/dns/host_resolver.h"
- #include "net/dns/https_record_rdata.h"
- #include "net/dns/public/dns_protocol.h"
- #include "net/dns/public/host_resolver_source.h"
- #include "net/log/net_log.h"
- #include "third_party/abseil-cpp/absl/types/optional.h"
- #include "third_party/abseil-cpp/absl/types/variant.h"
- #include "url/scheme_host_port.h"
- namespace net {
- namespace {
- #define CACHE_HISTOGRAM_TIME(name, time) \
- UMA_HISTOGRAM_LONG_TIMES("DNS.HostCache." name, time)
- #define CACHE_HISTOGRAM_COUNT(name, count) \
- UMA_HISTOGRAM_COUNTS_1000("DNS.HostCache." name, count)
- #define CACHE_HISTOGRAM_ENUM(name, value, max) \
- UMA_HISTOGRAM_ENUMERATION("DNS.HostCache." name, value, max)
- // String constants for dictionary keys.
- const char kSchemeKey[] = "scheme";
- const char kHostnameKey[] = "hostname";
- const char kPortKey[] = "port";
- const char kDnsQueryTypeKey[] = "dns_query_type";
- const char kFlagsKey[] = "flags";
- const char kHostResolverSourceKey[] = "host_resolver_source";
- const char kSecureKey[] = "secure";
- const char kNetworkIsolationKeyKey[] = "network_isolation_key";
- const char kExpirationKey[] = "expiration";
- const char kTtlKey[] = "ttl";
- const char kPinnedKey[] = "pinned";
- const char kNetworkChangesKey[] = "network_changes";
- const char kNetErrorKey[] = "net_error";
- const char kIpEndpointsKey[] = "ip_endpoints";
- const char kEndpointAddressKey[] = "endpoint_address";
- const char kEndpointPortKey[] = "endpoint_port";
- const char kEndpointMetadatasKey[] = "endpoint_metadatas";
- const char kEndpointMetadataWeightKey[] = "endpoint_metadata_weight";
- const char kEndpointMetadataValueKey[] = "endpoint_metadata_value";
- const char kAliasesKey[] = "aliases";
- const char kAddressesKey[] = "addresses";
- const char kTextRecordsKey[] = "text_records";
- const char kHostnameResultsKey[] = "hostname_results";
- const char kHostPortsKey[] = "host_ports";
- const char kCanonicalNamesKey[] = "canonical_names";
- base::Value IpEndpointToValue(const IPEndPoint& endpoint) {
- base::Value::Dict dictionary;
- dictionary.Set(kEndpointAddressKey, endpoint.ToStringWithoutPort());
- dictionary.Set(kEndpointPortKey, endpoint.port());
- return base::Value(std::move(dictionary));
- }
- absl::optional<IPEndPoint> IpEndpointFromValue(const base::Value& value) {
- if (!value.is_dict())
- return absl::nullopt;
- const base::Value::Dict& dict = value.GetDict();
- const std::string* ip_str = dict.FindString(kEndpointAddressKey);
- absl::optional<int> port = dict.FindInt(kEndpointPortKey);
- if (!ip_str || !port ||
- !base::IsValueInRangeForNumericType<uint16_t>(port.value())) {
- return absl::nullopt;
- }
- IPAddress ip;
- if (!ip.AssignFromIPLiteral(*ip_str))
- return absl::nullopt;
- return IPEndPoint(ip, base::checked_cast<uint16_t>(port.value()));
- }
- base::Value EndpointMetadataPairToValue(
- const std::pair<HttpsRecordPriority, ConnectionEndpointMetadata>& pair) {
- base::Value::Dict dictionary;
- dictionary.Set(kEndpointMetadataWeightKey, pair.first);
- dictionary.Set(kEndpointMetadataValueKey, pair.second.ToValue());
- return base::Value(std::move(dictionary));
- }
- absl::optional<std::pair<HttpsRecordPriority, ConnectionEndpointMetadata>>
- EndpointMetadataPairFromValue(const base::Value& value) {
- if (!value.is_dict())
- return absl::nullopt;
- const base::Value::Dict& dict = value.GetDict();
- absl::optional<int> priority = dict.FindInt(kEndpointMetadataWeightKey);
- const base::Value* metadata_value = dict.Find(kEndpointMetadataValueKey);
- if (!priority || !base::IsValueInRangeForNumericType<HttpsRecordPriority>(
- priority.value())) {
- return absl::nullopt;
- }
- if (!metadata_value)
- return absl::nullopt;
- absl::optional<ConnectionEndpointMetadata> metadata =
- ConnectionEndpointMetadata::FromValue(*metadata_value);
- if (!metadata)
- return absl::nullopt;
- return std::make_pair(
- base::checked_cast<HttpsRecordPriority>(priority.value()),
- std::move(metadata).value());
- }
- bool IPEndPointsFromLegacyAddressListValue(
- const base::Value::List& value,
- absl::optional<std::vector<IPEndPoint>>* ip_endpoints) {
- ip_endpoints->emplace();
- for (const auto& it : value) {
- IPAddress address;
- const std::string* addr_string = it.GetIfString();
- if (!addr_string || !address.AssignFromIPLiteral(*addr_string)) {
- return false;
- }
- ip_endpoints->value().emplace_back(address, 0);
- }
- return true;
- }
- template <typename T>
- void MergeLists(absl::optional<T>* target, const absl::optional<T>& source) {
- if (target->has_value() && source) {
- target->value().insert(target->value().end(), source.value().begin(),
- source.value().end());
- } else if (source) {
- *target = source;
- }
- }
- template <typename T>
- void MergeContainers(absl::optional<T>& target,
- const absl::optional<T>& source) {
- if (target.has_value() && source.has_value()) {
- target->insert(source->begin(), source->end());
- } else if (source) {
- target = source;
- }
- }
- // Used to reject empty and IP literal (whether or not surrounded by brackets)
- // hostnames.
- bool IsValidHostname(base::StringPiece hostname) {
- if (hostname.empty())
- return false;
- IPAddress ip_address;
- if (ip_address.AssignFromIPLiteral(hostname) ||
- ParseURLHostnameToAddress(hostname, &ip_address)) {
- return false;
- }
- return true;
- }
- const std::string& GetHostname(
- const absl::variant<url::SchemeHostPort, std::string>& host) {
- const std::string* hostname;
- if (absl::holds_alternative<url::SchemeHostPort>(host)) {
- hostname = &absl::get<url::SchemeHostPort>(host).host();
- } else {
- DCHECK(absl::holds_alternative<std::string>(host));
- hostname = &absl::get<std::string>(host);
- }
- DCHECK(IsValidHostname(*hostname));
- return *hostname;
- }
- } // namespace
- // Used in histograms; do not modify existing values.
- enum HostCache::SetOutcome : int {
- SET_INSERT = 0,
- SET_UPDATE_VALID = 1,
- SET_UPDATE_STALE = 2,
- MAX_SET_OUTCOME
- };
- // Used in histograms; do not modify existing values.
- enum HostCache::LookupOutcome : int {
- LOOKUP_MISS_ABSENT = 0,
- LOOKUP_MISS_STALE = 1,
- LOOKUP_HIT_VALID = 2,
- LOOKUP_HIT_STALE = 3,
- MAX_LOOKUP_OUTCOME
- };
- // Used in histograms; do not modify existing values.
- enum HostCache::EraseReason : int {
- ERASE_EVICT = 0,
- ERASE_CLEAR = 1,
- ERASE_DESTRUCT = 2,
- MAX_ERASE_REASON
- };
- HostCache::Key::Key(absl::variant<url::SchemeHostPort, std::string> host,
- DnsQueryType dns_query_type,
- HostResolverFlags host_resolver_flags,
- HostResolverSource host_resolver_source,
- const NetworkIsolationKey& network_isolation_key)
- : host(std::move(host)),
- dns_query_type(dns_query_type),
- host_resolver_flags(host_resolver_flags),
- host_resolver_source(host_resolver_source),
- network_isolation_key(network_isolation_key) {
- DCHECK(IsValidHostname(GetHostname(this->host)));
- if (absl::holds_alternative<url::SchemeHostPort>(this->host))
- DCHECK(absl::get<url::SchemeHostPort>(this->host).IsValid());
- }
- HostCache::Key::Key() = default;
- HostCache::Key::Key(const Key& key) = default;
- HostCache::Key::Key(Key&& key) = default;
- HostCache::Key::~Key() = default;
- HostCache::Entry::Entry(int error,
- Source source,
- absl::optional<base::TimeDelta> ttl)
- : error_(error), source_(source), ttl_(ttl.value_or(base::Seconds(-1))) {
- // If |ttl| has a value, must not be negative.
- DCHECK_GE(ttl.value_or(base::TimeDelta()), base::TimeDelta());
- DCHECK_NE(OK, error_);
- // host_cache.h defines its own `HttpsRecordPriority` due to
- // https_record_rdata.h not being allowed in the same places, but the types
- // should still be the same thing.
- static_assert(std::is_same<net::HttpsRecordPriority,
- HostCache::Entry::HttpsRecordPriority>::value,
- "`net::HttpsRecordPriority` and "
- "`HostCache::Entry::HttpsRecordPriority` must be same type");
- }
- HostCache::Entry::Entry(const Entry& entry) = default;
- HostCache::Entry::Entry(Entry&& entry) = default;
- HostCache::Entry::~Entry() = default;
- absl::optional<std::vector<HostResolverEndpointResult>>
- HostCache::Entry::GetEndpoints() const {
- if (!ip_endpoints_.has_value())
- return absl::nullopt;
- std::vector<HostResolverEndpointResult> endpoints;
- if (ip_endpoints_.value().empty())
- return endpoints;
- absl::optional<std::vector<ConnectionEndpointMetadata>> metadatas =
- GetMetadatas();
- if (metadatas.has_value() && canonical_names_ &&
- (canonical_names_->size() == 1)) {
- // Currently Chrome uses HTTPS records only when A and AAAA records are at
- // the same canonical name and that matches the HTTPS target name.
- for (ConnectionEndpointMetadata& metadata : metadatas.value()) {
- if (canonical_names_->find(metadata.target_name) ==
- canonical_names_->end()) {
- continue;
- }
- endpoints.emplace_back();
- endpoints.back().ip_endpoints = ip_endpoints_.value();
- endpoints.back().metadata = std::move(metadata);
- }
- }
- // Add a final non-protocol endpoint at the end.
- endpoints.emplace_back();
- endpoints.back().ip_endpoints = ip_endpoints_.value();
- return endpoints;
- }
- absl::optional<std::vector<ConnectionEndpointMetadata>>
- HostCache::Entry::GetMetadatas() const {
- if (!endpoint_metadatas_.has_value())
- return absl::nullopt;
- std::vector<ConnectionEndpointMetadata> metadatas;
- HttpsRecordPriority last_priority = 0;
- for (const auto& metadata : endpoint_metadatas_.value()) {
- // Ensure metadatas are iterated in priority order.
- DCHECK_GE(metadata.first, last_priority);
- last_priority = metadata.first;
- metadatas.push_back(metadata.second);
- }
- return metadatas;
- }
- absl::optional<base::TimeDelta> HostCache::Entry::GetOptionalTtl() const {
- if (has_ttl())
- return ttl();
- else
- return absl::nullopt;
- }
- // static
- HostCache::Entry HostCache::Entry::MergeEntries(Entry front, Entry back) {
- // Only expected to merge OK or ERR_NAME_NOT_RESOLVED results.
- DCHECK(front.error() == OK || front.error() == ERR_NAME_NOT_RESOLVED);
- DCHECK(back.error() == OK || back.error() == ERR_NAME_NOT_RESOLVED);
- // Build results in |front| to preserve unmerged fields.
- front.error_ =
- front.error() == OK || back.error() == OK ? OK : ERR_NAME_NOT_RESOLVED;
- MergeLists(&front.ip_endpoints_, back.ip_endpoints_);
- MergeContainers(front.endpoint_metadatas_, back.endpoint_metadatas_);
- MergeContainers(front.aliases_, back.aliases_);
- MergeLists(&front.text_records_, back.text_records());
- MergeLists(&front.hostnames_, back.hostnames());
- MergeLists(&front.https_record_compatibility_,
- back.https_record_compatibility_);
- MergeContainers(front.canonical_names_, back.canonical_names_);
- // Only expected to merge entries from same source.
- DCHECK_EQ(front.source(), back.source());
- if (front.has_ttl() && back.has_ttl()) {
- front.ttl_ = std::min(front.ttl(), back.ttl());
- } else if (back.has_ttl()) {
- front.ttl_ = back.ttl();
- }
- front.expires_ = std::min(front.expires(), back.expires());
- front.network_changes_ =
- std::max(front.network_changes(), back.network_changes());
- front.total_hits_ = front.total_hits_ + back.total_hits_;
- front.stale_hits_ = front.stale_hits_ + back.stale_hits_;
- return front;
- }
- HostCache::Entry HostCache::Entry::CopyWithDefaultPort(uint16_t port) const {
- Entry copy(*this);
- if (copy.ip_endpoints_) {
- for (IPEndPoint& endpoint : copy.ip_endpoints_.value()) {
- if (endpoint.port() == 0)
- endpoint = IPEndPoint(endpoint.address(), port);
- }
- }
- if (copy.hostnames_) {
- for (HostPortPair& hostname : copy.hostnames_.value()) {
- if (hostname.port() == 0)
- hostname = HostPortPair(hostname.host(), port);
- }
- }
- return copy;
- }
- HostCache::Entry& HostCache::Entry::operator=(const Entry& entry) = default;
- HostCache::Entry& HostCache::Entry::operator=(Entry&& entry) = default;
- HostCache::Entry::Entry(int error,
- std::vector<IPEndPoint> ip_endpoints,
- std::set<std::string> aliases,
- Source source,
- absl::optional<base::TimeDelta> ttl)
- : error_(error),
- ip_endpoints_(std::move(ip_endpoints)),
- aliases_(std::move(aliases)),
- source_(source),
- ttl_(ttl ? ttl.value() : base::Seconds(-1)) {
- DCHECK(!ttl || ttl.value() >= base::TimeDelta());
- }
- HostCache::Entry::Entry(const HostCache::Entry& entry,
- base::TimeTicks now,
- base::TimeDelta ttl,
- int network_changes)
- : error_(entry.error()),
- ip_endpoints_(entry.ip_endpoints_),
- endpoint_metadatas_(entry.endpoint_metadatas_),
- aliases_(base::OptionalFromPtr(entry.aliases())),
- text_records_(entry.text_records()),
- hostnames_(entry.hostnames()),
- https_record_compatibility_(entry.https_record_compatibility_),
- source_(entry.source()),
- pinning_(entry.pinning()),
- canonical_names_(entry.canonical_names()),
- ttl_(entry.ttl()),
- expires_(now + ttl),
- network_changes_(network_changes) {}
- HostCache::Entry::Entry(
- int error,
- absl::optional<std::vector<IPEndPoint>> ip_endpoints,
- absl::optional<
- std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>>
- endpoint_metadatas,
- absl::optional<std::set<std::string>> aliases,
- absl::optional<std::vector<std::string>>&& text_records,
- absl::optional<std::vector<HostPortPair>>&& hostnames,
- absl::optional<std::vector<bool>>&& https_record_compatibility,
- Source source,
- base::TimeTicks expires,
- int network_changes)
- : error_(error),
- ip_endpoints_(std::move(ip_endpoints)),
- endpoint_metadatas_(std::move(endpoint_metadatas)),
- aliases_(std::move(aliases)),
- text_records_(std::move(text_records)),
- hostnames_(std::move(hostnames)),
- https_record_compatibility_(std::move(https_record_compatibility)),
- source_(source),
- expires_(expires),
- network_changes_(network_changes) {}
- void HostCache::Entry::PrepareForCacheInsertion() {
- https_record_compatibility_.reset();
- }
- bool HostCache::Entry::IsStale(base::TimeTicks now, int network_changes) const {
- EntryStaleness stale;
- stale.expired_by = now - expires_;
- stale.network_changes = network_changes - network_changes_;
- stale.stale_hits = stale_hits_;
- return stale.is_stale();
- }
- void HostCache::Entry::CountHit(bool hit_is_stale) {
- ++total_hits_;
- if (hit_is_stale)
- ++stale_hits_;
- }
- void HostCache::Entry::GetStaleness(base::TimeTicks now,
- int network_changes,
- EntryStaleness* out) const {
- DCHECK(out);
- out->expired_by = now - expires_;
- out->network_changes = network_changes - network_changes_;
- out->stale_hits = stale_hits_;
- }
- base::Value HostCache::Entry::NetLogParams() const {
- return base::Value(GetAsValue(false /* include_staleness */));
- }
- base::Value::Dict HostCache::Entry::GetAsValue(bool include_staleness) const {
- base::Value::Dict entry_dict;
- if (include_staleness) {
- // The kExpirationKey value is using TimeTicks instead of Time used if
- // |include_staleness| is false, so it cannot be used to deserialize.
- // This is ok as it is used only for netlog.
- entry_dict.Set(kExpirationKey, NetLog::TickCountToString(expires()));
- entry_dict.Set(kTtlKey, base::saturated_cast<int>(ttl().InMilliseconds()));
- entry_dict.Set(kNetworkChangesKey, network_changes());
- // The "pinned" status is meaningful only if "network_changes" is also
- // preserved.
- if (pinning())
- entry_dict.Set(kPinnedKey, *pinning());
- } else {
- // Convert expiration time in TimeTicks to Time for serialization, using a
- // string because base::Value doesn't handle 64-bit integers.
- base::Time expiration_time =
- base::Time::Now() - (base::TimeTicks::Now() - expires());
- entry_dict.Set(kExpirationKey,
- base::NumberToString(expiration_time.ToInternalValue()));
- }
- if (error() != OK) {
- entry_dict.Set(kNetErrorKey, error());
- } else {
- if (ip_endpoints_) {
- base::Value::List ip_endpoints_list;
- for (const IPEndPoint& ip_endpoint : ip_endpoints_.value()) {
- ip_endpoints_list.Append(IpEndpointToValue(ip_endpoint));
- }
- entry_dict.Set(kIpEndpointsKey, std::move(ip_endpoints_list));
- }
- if (endpoint_metadatas_) {
- base::Value::List endpoint_metadatas_list;
- for (const auto& endpoint_metadata_pair : endpoint_metadatas_.value()) {
- endpoint_metadatas_list.Append(
- EndpointMetadataPairToValue(endpoint_metadata_pair));
- }
- entry_dict.Set(kEndpointMetadatasKey, std::move(endpoint_metadatas_list));
- }
- if (aliases()) {
- base::Value::List alias_list;
- for (const std::string& alias : *aliases()) {
- alias_list.Append(alias);
- }
- entry_dict.Set(kAliasesKey, std::move(alias_list));
- }
- if (text_records()) {
- // Append all resolved text records.
- base::Value::List text_list_value;
- for (const std::string& text_record : text_records().value()) {
- text_list_value.Append(text_record);
- }
- entry_dict.Set(kTextRecordsKey, std::move(text_list_value));
- }
- if (hostnames()) {
- // Append all the resolved hostnames.
- base::Value::List hostnames_value;
- base::Value::List host_ports_value;
- for (const HostPortPair& hostname : hostnames().value()) {
- hostnames_value.Append(hostname.host());
- host_ports_value.Append(hostname.port());
- }
- entry_dict.Set(kHostnameResultsKey, std::move(hostnames_value));
- entry_dict.Set(kHostPortsKey, std::move(host_ports_value));
- }
- if (canonical_names()) {
- base::Value::List canonical_names_list;
- for (const std::string& canonical_name : canonical_names().value()) {
- canonical_names_list.Append(canonical_name);
- }
- entry_dict.Set(kCanonicalNamesKey, std::move(canonical_names_list));
- }
- }
- return entry_dict;
- }
- // static
- const HostCache::EntryStaleness HostCache::kNotStale = {base::Seconds(-1), 0,
- 0};
- HostCache::HostCache(size_t max_entries)
- : max_entries_(max_entries),
- tick_clock_(base::DefaultTickClock::GetInstance()) {}
- HostCache::~HostCache() {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- }
- const std::pair<const HostCache::Key, HostCache::Entry>*
- HostCache::Lookup(const Key& key, base::TimeTicks now, bool ignore_secure) {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- if (caching_is_disabled())
- return nullptr;
- auto* result = LookupInternalIgnoringFields(key, now, ignore_secure);
- if (!result)
- return nullptr;
- auto* entry = &result->second;
- if (entry->IsStale(now, network_changes_))
- return nullptr;
- entry->CountHit(/* hit_is_stale= */ false);
- return result;
- }
- const std::pair<const HostCache::Key, HostCache::Entry>* HostCache::LookupStale(
- const Key& key,
- base::TimeTicks now,
- HostCache::EntryStaleness* stale_out,
- bool ignore_secure) {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- if (caching_is_disabled())
- return nullptr;
- auto* result = LookupInternalIgnoringFields(key, now, ignore_secure);
- if (!result)
- return nullptr;
- auto* entry = &result->second;
- bool is_stale = entry->IsStale(now, network_changes_);
- entry->CountHit(/* hit_is_stale= */ is_stale);
- if (stale_out)
- entry->GetStaleness(now, network_changes_, stale_out);
- return result;
- }
- // static
- std::pair<const HostCache::Key, HostCache::Entry>*
- HostCache::GetLessStaleMoreSecureResult(
- base::TimeTicks now,
- std::pair<const HostCache::Key, HostCache::Entry>* result1,
- std::pair<const HostCache::Key, HostCache::Entry>* result2) {
- // Prefer a non-null result if possible.
- if (!result1 && !result2)
- return nullptr;
- if (result1 && !result2)
- return result1;
- if (!result1 && result2)
- return result2;
- // Both result1 are result2 are non-null.
- EntryStaleness staleness1, staleness2;
- result1->second.GetStaleness(now, 0, &staleness1);
- result2->second.GetStaleness(now, 0, &staleness2);
- if (staleness1.network_changes == staleness2.network_changes) {
- // Exactly one of the results should be secure.
- DCHECK(result1->first.secure != result2->first.secure);
- // If the results have the same number of network changes, prefer a
- // non-expired result.
- if (staleness1.expired_by.is_negative() &&
- staleness2.expired_by >= base::TimeDelta()) {
- return result1;
- }
- if (staleness1.expired_by >= base::TimeDelta() &&
- staleness2.expired_by.is_negative()) {
- return result2;
- }
- // Both results are equally stale, so prefer a secure result.
- return (result1->first.secure) ? result1 : result2;
- }
- // Prefer the result with the fewest network changes.
- return (staleness1.network_changes < staleness2.network_changes) ? result1
- : result2;
- }
- std::pair<const HostCache::Key, HostCache::Entry>*
- HostCache::LookupInternalIgnoringFields(const Key& initial_key,
- base::TimeTicks now,
- bool ignore_secure) {
- std::pair<const HostCache::Key, HostCache::Entry>* preferred_result =
- LookupInternal(initial_key);
- if (ignore_secure) {
- Key effective_key = initial_key;
- effective_key.secure = !initial_key.secure;
- preferred_result = GetLessStaleMoreSecureResult(
- now, preferred_result, LookupInternal(effective_key));
- }
- return preferred_result;
- }
- std::pair<const HostCache::Key, HostCache::Entry>* HostCache::LookupInternal(
- const Key& key) {
- auto it = entries_.find(key);
- return (it != entries_.end()) ? &*it : nullptr;
- }
- void HostCache::Set(const Key& key,
- const Entry& entry,
- base::TimeTicks now,
- base::TimeDelta ttl) {
- TRACE_EVENT0(NetTracingCategory(), "HostCache::Set");
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- if (caching_is_disabled())
- return;
- bool has_active_pin = false;
- bool result_changed = false;
- auto it = entries_.find(key);
- if (it != entries_.end()) {
- has_active_pin = HasActivePin(it->second);
- // TODO(juliatuttle): Remember some old metadata (hit count or frequency or
- // something like that) if it's useful for better eviction algorithms?
- result_changed = entry.error() == OK && !it->second.ContentsEqual(entry);
- entries_.erase(it);
- } else {
- result_changed = true;
- // This loop almost always runs at most once, for total runtime
- // O(max_entries_). It only runs more than once if the cache was over-full
- // due to pinned entries, and this is the first call to Set() after
- // Invalidate(). The amortized cost remains O(size()) per call to Set().
- while (size() >= max_entries_ && EvictOneEntry(now)) {
- }
- }
- Entry entry_for_cache(entry, now, ttl, network_changes_);
- entry_for_cache.set_pinning(entry.pinning().value_or(has_active_pin));
- entry_for_cache.PrepareForCacheInsertion();
- AddEntry(key, std::move(entry_for_cache));
- if (delegate_ && result_changed)
- delegate_->ScheduleWrite();
- }
- const HostCache::Key* HostCache::GetMatchingKeyForTesting(
- base::StringPiece hostname,
- HostCache::Entry::Source* source_out,
- HostCache::EntryStaleness* stale_out) const {
- for (const EntryMap::value_type& entry : entries_) {
- if (GetHostname(entry.first.host) == hostname) {
- if (source_out != nullptr)
- *source_out = entry.second.source();
- if (stale_out != nullptr) {
- entry.second.GetStaleness(tick_clock_->NowTicks(), network_changes_,
- stale_out);
- }
- return &entry.first;
- }
- }
- return nullptr;
- }
- void HostCache::AddEntry(const Key& key, Entry&& entry) {
- DCHECK_EQ(0u, entries_.count(key));
- DCHECK(entry.pinning().has_value());
- entries_.emplace(key, std::move(entry));
- }
- void HostCache::Invalidate() {
- ++network_changes_;
- }
- void HostCache::set_persistence_delegate(PersistenceDelegate* delegate) {
- // A PersistenceDelegate shouldn't be added if there already was one, and
- // shouldn't be removed (by setting to nullptr) if it wasn't previously there.
- DCHECK_NE(delegate == nullptr, delegate_ == nullptr);
- delegate_ = delegate;
- }
- void HostCache::clear() {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- // Don't bother scheduling a write if there's nothing to clear.
- if (size() == 0)
- return;
- entries_.clear();
- if (delegate_)
- delegate_->ScheduleWrite();
- }
- void HostCache::ClearForHosts(
- const base::RepeatingCallback<bool(const std::string&)>& host_filter) {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- if (host_filter.is_null()) {
- clear();
- return;
- }
- bool changed = false;
- for (auto it = entries_.begin(); it != entries_.end();) {
- auto next_it = std::next(it);
- if (host_filter.Run(GetHostname(it->first.host))) {
- entries_.erase(it);
- changed = true;
- }
- it = next_it;
- }
- if (delegate_ && changed)
- delegate_->ScheduleWrite();
- }
- void HostCache::GetList(base::Value::List& entry_list,
- bool include_staleness,
- SerializationType serialization_type) const {
- entry_list.clear();
- for (const auto& pair : entries_) {
- const Key& key = pair.first;
- const Entry& entry = pair.second;
- base::Value network_isolation_key_value;
- if (serialization_type == SerializationType::kRestorable) {
- // Don't save entries associated with ephemeral NetworkIsolationKeys.
- if (!key.network_isolation_key.ToValue(&network_isolation_key_value))
- continue;
- } else {
- // ToValue() fails for transient NIKs, since they should never be
- // serialized to disk in a restorable format, so use ToDebugString() when
- // serializing for debugging instead of for restoring from disk.
- network_isolation_key_value =
- base::Value(key.network_isolation_key.ToDebugString());
- }
- base::Value::Dict entry_dict = entry.GetAsValue(include_staleness);
- const auto* host = absl::get_if<url::SchemeHostPort>(&key.host);
- if (host) {
- entry_dict.Set(kSchemeKey, host->scheme());
- entry_dict.Set(kHostnameKey, host->host());
- entry_dict.Set(kPortKey, host->port());
- } else {
- entry_dict.Set(kHostnameKey, absl::get<std::string>(key.host));
- }
- entry_dict.Set(kDnsQueryTypeKey,
- base::strict_cast<int>(key.dns_query_type));
- entry_dict.Set(kFlagsKey, key.host_resolver_flags);
- entry_dict.Set(kHostResolverSourceKey,
- base::strict_cast<int>(key.host_resolver_source));
- entry_dict.Set(kNetworkIsolationKeyKey,
- std::move(network_isolation_key_value));
- entry_dict.Set(kSecureKey, key.secure);
- entry_list.Append(std::move(entry_dict));
- }
- }
- bool HostCache::RestoreFromListValue(const base::Value::List& old_cache) {
- // Reset the restore size to 0.
- restore_size_ = 0;
- for (const auto& entry : old_cache) {
- // If the cache is already full, don't bother prioritizing what to evict,
- // just stop restoring.
- if (size() == max_entries_)
- break;
- if (!entry.is_dict())
- return false;
- const base::Value::Dict& entry_dict = entry.GetDict();
- const std::string* hostname_ptr = entry_dict.FindString(kHostnameKey);
- if (!hostname_ptr || !IsValidHostname(*hostname_ptr)) {
- return false;
- }
- // Use presence of scheme to determine host type.
- const std::string* scheme_ptr = entry_dict.FindString(kSchemeKey);
- absl::variant<url::SchemeHostPort, std::string> host;
- if (scheme_ptr) {
- absl::optional<int> port = entry_dict.FindInt(kPortKey);
- if (!port || !base::IsValueInRangeForNumericType<uint16_t>(port.value()))
- return false;
- url::SchemeHostPort scheme_host_port(*scheme_ptr, *hostname_ptr,
- port.value());
- if (!scheme_host_port.IsValid())
- return false;
- host = std::move(scheme_host_port);
- } else {
- host = *hostname_ptr;
- }
- const std::string* expiration_ptr = entry_dict.FindString(kExpirationKey);
- absl::optional<int> maybe_flags = entry_dict.FindInt(kFlagsKey);
- if (expiration_ptr == nullptr || !maybe_flags.has_value())
- return false;
- std::string expiration(*expiration_ptr);
- HostResolverFlags flags = maybe_flags.value();
- absl::optional<int> maybe_dns_query_type =
- entry_dict.FindInt(kDnsQueryTypeKey);
- if (!maybe_dns_query_type.has_value())
- return false;
- DnsQueryType dns_query_type =
- static_cast<DnsQueryType>(maybe_dns_query_type.value());
- // HostResolverSource is optional.
- int host_resolver_source =
- entry_dict.FindInt(kHostResolverSourceKey)
- .value_or(base::strict_cast<int>(HostResolverSource::ANY));
- const base::Value* network_isolation_key_value =
- entry_dict.Find(kNetworkIsolationKeyKey);
- NetworkIsolationKey network_isolation_key;
- if (!network_isolation_key_value ||
- network_isolation_key_value->type() == base::Value::Type::STRING ||
- !NetworkIsolationKey::FromValue(*network_isolation_key_value,
- &network_isolation_key)) {
- return false;
- }
- bool secure = entry_dict.FindBool(kSecureKey).value_or(false);
- int error = OK;
- const base::Value::List* ip_endpoints_list = nullptr;
- const base::Value::List* endpoint_metadatas_list = nullptr;
- const base::Value::List* aliases_list = nullptr;
- const base::Value::List* legacy_addresses_list = nullptr;
- const base::Value::List* text_records_list = nullptr;
- const base::Value::List* hostname_records_list = nullptr;
- const base::Value::List* host_ports_list = nullptr;
- const base::Value::List* canonical_names_list = nullptr;
- absl::optional<int> maybe_error = entry_dict.FindInt(kNetErrorKey);
- absl::optional<bool> maybe_pinned = entry_dict.FindBool(kPinnedKey);
- if (maybe_error.has_value()) {
- error = maybe_error.value();
- } else {
- ip_endpoints_list = entry_dict.FindList(kIpEndpointsKey);
- endpoint_metadatas_list = entry_dict.FindList(kEndpointMetadatasKey);
- aliases_list = entry_dict.FindList(kAliasesKey);
- legacy_addresses_list = entry_dict.FindList(kAddressesKey);
- text_records_list = entry_dict.FindList(kTextRecordsKey);
- hostname_records_list = entry_dict.FindList(kHostnameResultsKey);
- host_ports_list = entry_dict.FindList(kHostPortsKey);
- canonical_names_list = entry_dict.FindList(kCanonicalNamesKey);
- if ((hostname_records_list == nullptr && host_ports_list != nullptr) ||
- (hostname_records_list != nullptr && host_ports_list == nullptr)) {
- return false;
- }
- }
- int64_t time_internal;
- if (!base::StringToInt64(expiration, &time_internal))
- return false;
- base::TimeTicks expiration_time =
- tick_clock_->NowTicks() -
- (base::Time::Now() - base::Time::FromInternalValue(time_internal));
- absl::optional<std::vector<IPEndPoint>> ip_endpoints;
- if (ip_endpoints_list) {
- ip_endpoints.emplace();
- for (const base::Value& ip_endpoint_value : *ip_endpoints_list) {
- absl::optional<IPEndPoint> ip_endpoint =
- IpEndpointFromValue(ip_endpoint_value);
- if (!ip_endpoint)
- return false;
- ip_endpoints->push_back(std::move(ip_endpoint).value());
- }
- }
- absl::optional<
- std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>>
- endpoint_metadatas;
- if (endpoint_metadatas_list) {
- endpoint_metadatas.emplace();
- for (const base::Value& endpoint_metadata_value :
- *endpoint_metadatas_list) {
- absl::optional<
- std::pair<HttpsRecordPriority, ConnectionEndpointMetadata>>
- pair = EndpointMetadataPairFromValue(endpoint_metadata_value);
- if (!pair)
- return false;
- endpoint_metadatas->insert(std::move(pair).value());
- }
- }
- absl::optional<std::set<std::string>> aliases;
- if (aliases_list) {
- aliases.emplace();
- for (const base::Value& alias_value : *aliases_list) {
- if (!alias_value.is_string())
- return false;
- aliases->insert(alias_value.GetString());
- }
- }
- // `addresses` field was supported until M105. We keep reading this field
- // for backward compatibility for several milestones.
- if (legacy_addresses_list) {
- if (ip_endpoints)
- return false;
- if (!IPEndPointsFromLegacyAddressListValue(*legacy_addresses_list,
- &ip_endpoints)) {
- return false;
- }
- }
- absl::optional<std::vector<std::string>> text_records;
- if (text_records_list) {
- text_records.emplace();
- for (const base::Value& value : *text_records_list) {
- if (!value.is_string())
- return false;
- text_records.value().push_back(value.GetString());
- }
- }
- absl::optional<std::vector<HostPortPair>> hostname_records;
- if (hostname_records_list) {
- DCHECK(host_ports_list);
- if (hostname_records_list->size() != host_ports_list->size()) {
- return false;
- }
- hostname_records.emplace();
- for (size_t i = 0; i < hostname_records_list->size(); ++i) {
- if (!(*hostname_records_list)[i].is_string() ||
- !(*host_ports_list)[i].is_int() ||
- !base::IsValueInRangeForNumericType<uint16_t>(
- (*host_ports_list)[i].GetInt())) {
- return false;
- }
- hostname_records.value().emplace_back(
- (*hostname_records_list)[i].GetString(),
- base::checked_cast<uint16_t>((*host_ports_list)[i].GetInt()));
- }
- }
- absl::optional<std::set<std::string>> canonical_names;
- if (canonical_names_list) {
- canonical_names = std::set<std::string>();
- for (const auto& item : *canonical_names_list) {
- const std::string* name = item.GetIfString();
- if (!name)
- return false;
- canonical_names->insert(*name);
- }
- }
- // We do not intend to serialize experimental results with the host cache.
- absl::optional<std::vector<bool>> experimental_results;
- // Assume an empty endpoints list and an empty aliases if we have an address
- // type and no results.
- if (IsAddressType(dns_query_type) && !text_records && !hostname_records) {
- if (!ip_endpoints) {
- ip_endpoints.emplace();
- }
- if (!aliases) {
- aliases.emplace();
- }
- }
- Key key(std::move(host), dns_query_type, flags,
- static_cast<HostResolverSource>(host_resolver_source),
- network_isolation_key);
- key.secure = secure;
- // If the key is already in the cache, assume it's more recent and don't
- // replace the entry.
- auto found = entries_.find(key);
- if (found == entries_.end()) {
- Entry new_entry(error, std::move(ip_endpoints),
- std::move(endpoint_metadatas), std::move(aliases),
- std::move(text_records), std::move(hostname_records),
- std::move(experimental_results), Entry::SOURCE_UNKNOWN,
- expiration_time, network_changes_ - 1);
- new_entry.set_pinning(maybe_pinned.value_or(false));
- new_entry.set_canonical_names(std::move(canonical_names));
- AddEntry(key, std::move(new_entry));
- restore_size_++;
- }
- }
- return true;
- }
- size_t HostCache::size() const {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- return entries_.size();
- }
- size_t HostCache::max_entries() const {
- DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- return max_entries_;
- }
- // static
- std::unique_ptr<HostCache> HostCache::CreateDefaultCache() {
- #if defined(ENABLE_BUILT_IN_DNS)
- const size_t kDefaultMaxEntries = 1000;
- #else
- const size_t kDefaultMaxEntries = 100;
- #endif
- return std::make_unique<HostCache>(kDefaultMaxEntries);
- }
- bool HostCache::EvictOneEntry(base::TimeTicks now) {
- DCHECK_LT(0u, entries_.size());
- absl::optional<net::HostCache::EntryMap::iterator> oldest_it;
- for (auto it = entries_.begin(); it != entries_.end(); ++it) {
- const Entry& entry = it->second;
- if (HasActivePin(entry)) {
- continue;
- }
- if (!oldest_it) {
- oldest_it = it;
- continue;
- }
- const Entry& oldest = (*oldest_it)->second;
- if ((entry.expires() < oldest.expires()) &&
- (entry.IsStale(now, network_changes_) ||
- !oldest.IsStale(now, network_changes_))) {
- oldest_it = it;
- }
- }
- if (oldest_it) {
- entries_.erase(*oldest_it);
- return true;
- }
- return false;
- }
- bool HostCache::HasActivePin(const Entry& entry) {
- return entry.pinning().value_or(false) &&
- entry.network_changes() == network_changes();
- }
- } // namespace net
- // Debug logging support
- std::ostream& operator<<(std::ostream& out,
- const net::HostCache::EntryStaleness& s) {
- return out << "EntryStaleness{" << s.expired_by << ", " << s.network_changes
- << ", " << s.stale_hits << "}";
- }
|