mock_host_resolver.cc 53 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562
  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. #include "net/dns/mock_host_resolver.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <string>
  8. #include <utility>
  9. #include <vector>
  10. #include "base/bind.h"
  11. #include "base/callback_helpers.h"
  12. #include "base/check_op.h"
  13. #include "base/location.h"
  14. #include "base/logging.h"
  15. #include "base/memory/ptr_util.h"
  16. #include "base/memory/raw_ptr.h"
  17. #include "base/memory/ref_counted.h"
  18. #include "base/no_destructor.h"
  19. #include "base/notreached.h"
  20. #include "base/stl_util.h"
  21. #include "base/strings/pattern.h"
  22. #include "base/strings/string_piece.h"
  23. #include "base/strings/string_split.h"
  24. #include "base/strings/string_util.h"
  25. #include "base/task/single_thread_task_runner.h"
  26. #include "base/threading/platform_thread.h"
  27. #include "base/threading/thread_task_runner_handle.h"
  28. #include "base/time/default_tick_clock.h"
  29. #include "base/time/tick_clock.h"
  30. #include "base/time/time.h"
  31. #include "build/build_config.h"
  32. #include "net/base/address_family.h"
  33. #include "net/base/address_list.h"
  34. #include "net/base/host_port_pair.h"
  35. #include "net/base/ip_address.h"
  36. #include "net/base/ip_endpoint.h"
  37. #include "net/base/net_errors.h"
  38. #include "net/base/net_export.h"
  39. #include "net/base/network_isolation_key.h"
  40. #include "net/base/test_completion_callback.h"
  41. #include "net/dns/dns_alias_utility.h"
  42. #include "net/dns/dns_util.h"
  43. #include "net/dns/host_cache.h"
  44. #include "net/dns/host_resolver.h"
  45. #include "net/dns/host_resolver_manager.h"
  46. #include "net/dns/host_resolver_results.h"
  47. #include "net/dns/https_record_rdata.h"
  48. #include "net/dns/public/dns_query_type.h"
  49. #include "net/dns/public/host_resolver_source.h"
  50. #include "net/dns/public/mdns_listener_update_type.h"
  51. #include "net/dns/public/resolve_error_info.h"
  52. #include "net/dns/public/secure_dns_policy.h"
  53. #include "net/log/net_log_with_source.h"
  54. #include "net/url_request/url_request_context.h"
  55. #include "third_party/abseil-cpp/absl/types/optional.h"
  56. #include "third_party/abseil-cpp/absl/types/variant.h"
  57. #include "url/scheme_host_port.h"
  58. #if BUILDFLAG(IS_WIN)
  59. #include "net/base/winsock_init.h"
  60. #endif
  61. namespace net {
  62. namespace {
  63. // Cache size for the MockCachingHostResolver.
  64. const unsigned kMaxCacheEntries = 100;
  65. // TTL for the successful resolutions. Failures are not cached.
  66. const unsigned kCacheEntryTTLSeconds = 60;
  67. base::StringPiece GetScheme(const HostResolver::Host& endpoint) {
  68. DCHECK(absl::holds_alternative<url::SchemeHostPort>(endpoint));
  69. return absl::get<url::SchemeHostPort>(endpoint).scheme();
  70. }
  71. // In HostPortPair format (no brackets around IPv6 literals) purely for
  72. // compatibility with IPAddress::AssignFromIPLiteral().
  73. base::StringPiece GetHostname(const HostResolver::Host& endpoint) {
  74. if (absl::holds_alternative<url::SchemeHostPort>(endpoint)) {
  75. base::StringPiece hostname =
  76. absl::get<url::SchemeHostPort>(endpoint).host();
  77. if (hostname.size() >= 2 && hostname.front() == '[' &&
  78. hostname.back() == ']') {
  79. return hostname.substr(1, hostname.size() - 2);
  80. }
  81. return hostname;
  82. }
  83. DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
  84. return absl::get<HostPortPair>(endpoint).host();
  85. }
  86. uint16_t GetPort(const HostResolver::Host& endpoint) {
  87. if (absl::holds_alternative<url::SchemeHostPort>(endpoint))
  88. return absl::get<url::SchemeHostPort>(endpoint).port();
  89. DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
  90. return absl::get<HostPortPair>(endpoint).port();
  91. }
  92. absl::variant<url::SchemeHostPort, std::string> GetCacheHost(
  93. const HostResolver::Host& endpoint) {
  94. if (absl::holds_alternative<url::SchemeHostPort>(endpoint))
  95. return absl::get<url::SchemeHostPort>(endpoint);
  96. DCHECK(absl::holds_alternative<HostPortPair>(endpoint));
  97. return absl::get<HostPortPair>(endpoint).host();
  98. }
  99. absl::optional<HostCache::Entry> CreateCacheEntry(
  100. const std::vector<HostResolverEndpointResult>& endpoint_results,
  101. const std::set<std::string>& aliases) {
  102. absl::optional<std::vector<net::IPEndPoint>> ip_endpoints;
  103. std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
  104. endpoint_metadatas;
  105. for (const auto& endpoint_result : endpoint_results) {
  106. if (!ip_endpoints) {
  107. ip_endpoints = endpoint_result.ip_endpoints;
  108. } else {
  109. // TODO(crbug.com/1264933): Support caching different IP endpoints
  110. // resutls.
  111. CHECK(*ip_endpoints == endpoint_result.ip_endpoints)
  112. << "Currently caching MockHostResolver only supports same IP "
  113. "endpoints results.";
  114. }
  115. if (!endpoint_result.metadata.supported_protocol_alpns.empty()) {
  116. endpoint_metadatas.emplace(/*priority=*/1, endpoint_result.metadata);
  117. }
  118. }
  119. DCHECK(ip_endpoints);
  120. auto endpoint_entry = HostCache::Entry(OK, *ip_endpoints, aliases,
  121. HostCache::Entry::SOURCE_UNKNOWN);
  122. if (endpoint_metadatas.empty()) {
  123. return endpoint_entry;
  124. }
  125. return HostCache::Entry::MergeEntries(
  126. HostCache::Entry(OK, std::move(endpoint_metadatas),
  127. HostCache::Entry::SOURCE_UNKNOWN),
  128. endpoint_entry);
  129. }
  130. } // namespace
  131. int ParseAddressList(base::StringPiece host_list,
  132. std::vector<net::IPEndPoint>* ip_endpoints) {
  133. ip_endpoints->clear();
  134. for (const base::StringPiece& address : base::SplitStringPiece(
  135. host_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
  136. IPAddress ip_address;
  137. if (!ip_address.AssignFromIPLiteral(address)) {
  138. LOG(WARNING) << "Not a supported IP literal: " << address;
  139. return ERR_UNEXPECTED;
  140. }
  141. ip_endpoints->push_back(IPEndPoint(ip_address, 0));
  142. }
  143. return OK;
  144. }
  145. class MockHostResolverBase::RequestImpl
  146. : public HostResolver::ResolveHostRequest {
  147. public:
  148. RequestImpl(Host request_endpoint,
  149. const NetworkIsolationKey& network_isolation_key,
  150. const absl::optional<ResolveHostParameters>& optional_parameters,
  151. base::WeakPtr<MockHostResolverBase> resolver)
  152. : request_endpoint_(std::move(request_endpoint)),
  153. network_isolation_key_(network_isolation_key),
  154. parameters_(optional_parameters ? optional_parameters.value()
  155. : ResolveHostParameters()),
  156. priority_(parameters_.initial_priority),
  157. host_resolver_flags_(ParametersToHostResolverFlags(parameters_)),
  158. resolve_error_info_(ResolveErrorInfo(ERR_IO_PENDING)),
  159. resolver_(resolver) {}
  160. RequestImpl(const RequestImpl&) = delete;
  161. RequestImpl& operator=(const RequestImpl&) = delete;
  162. ~RequestImpl() override {
  163. if (id_ > 0) {
  164. if (resolver_)
  165. resolver_->DetachRequest(id_);
  166. id_ = 0;
  167. resolver_ = nullptr;
  168. }
  169. }
  170. void DetachFromResolver() {
  171. id_ = 0;
  172. resolver_ = nullptr;
  173. }
  174. int Start(CompletionOnceCallback callback) override {
  175. DCHECK(callback);
  176. // Start() may only be called once per request.
  177. DCHECK_EQ(0u, id_);
  178. DCHECK(!complete_);
  179. DCHECK(!callback_);
  180. // Parent HostResolver must still be alive to call Start().
  181. DCHECK(resolver_);
  182. int rv = resolver_->Resolve(this);
  183. DCHECK(!complete_);
  184. if (rv == ERR_IO_PENDING) {
  185. DCHECK_GT(id_, 0u);
  186. callback_ = std::move(callback);
  187. } else {
  188. DCHECK_EQ(0u, id_);
  189. complete_ = true;
  190. }
  191. return rv;
  192. }
  193. const AddressList* GetAddressResults() const override {
  194. DCHECK(complete_);
  195. return base::OptionalOrNullptr(address_results_);
  196. }
  197. const std::vector<HostResolverEndpointResult>* GetEndpointResults()
  198. const override {
  199. DCHECK(complete_);
  200. return base::OptionalOrNullptr(endpoint_results_);
  201. }
  202. const absl::optional<std::vector<std::string>>& GetTextResults()
  203. const override {
  204. DCHECK(complete_);
  205. static const base::NoDestructor<absl::optional<std::vector<std::string>>>
  206. nullopt_result;
  207. return *nullopt_result;
  208. }
  209. const absl::optional<std::vector<HostPortPair>>& GetHostnameResults()
  210. const override {
  211. DCHECK(complete_);
  212. static const base::NoDestructor<absl::optional<std::vector<HostPortPair>>>
  213. nullopt_result;
  214. return *nullopt_result;
  215. }
  216. const std::set<std::string>* GetDnsAliasResults() const override {
  217. DCHECK(complete_);
  218. return base::OptionalOrNullptr(fixed_up_dns_alias_results_);
  219. }
  220. net::ResolveErrorInfo GetResolveErrorInfo() const override {
  221. DCHECK(complete_);
  222. return resolve_error_info_;
  223. }
  224. const absl::optional<HostCache::EntryStaleness>& GetStaleInfo()
  225. const override {
  226. DCHECK(complete_);
  227. return staleness_;
  228. }
  229. void ChangeRequestPriority(RequestPriority priority) override {
  230. priority_ = priority;
  231. }
  232. void SetError(int error) {
  233. // Should only be called before request is marked completed.
  234. DCHECK(!complete_);
  235. resolve_error_info_ = ResolveErrorInfo(error);
  236. }
  237. // Sets `endpoint_results_`, `fixed_up_dns_alias_results_`,
  238. // `address_results_` and `staleness_` after fixing them up.
  239. // Also sets `error` to OK.
  240. void SetEndpointResults(
  241. std::vector<HostResolverEndpointResult> endpoint_results,
  242. std::set<std::string> aliases,
  243. absl::optional<HostCache::EntryStaleness> staleness) {
  244. DCHECK(!complete_);
  245. DCHECK(!endpoint_results_);
  246. DCHECK(!parameters_.is_speculative);
  247. endpoint_results_ = std::move(endpoint_results);
  248. for (auto& result : *endpoint_results_) {
  249. result.ip_endpoints = FixupEndPoints(result.ip_endpoints);
  250. }
  251. fixed_up_dns_alias_results_ = FixupAliases(aliases);
  252. // `HostResolver` implementations are expected to provide an `AddressList`
  253. // result whenever `HostResolverEndpointResult` is also available.
  254. address_results_ = EndpointResultToAddressList(
  255. *endpoint_results_, *fixed_up_dns_alias_results_);
  256. staleness_ = std::move(staleness);
  257. SetError(OK);
  258. }
  259. void OnAsyncCompleted(size_t id, int error) {
  260. DCHECK_EQ(id_, id);
  261. id_ = 0;
  262. // Check that error information has been set and that the top-level error
  263. // code is valid.
  264. DCHECK(resolve_error_info_.error != ERR_IO_PENDING);
  265. DCHECK(error == OK || error == ERR_NAME_NOT_RESOLVED ||
  266. error == ERR_DNS_NAME_HTTPS_ONLY);
  267. DCHECK(!complete_);
  268. complete_ = true;
  269. DCHECK(callback_);
  270. std::move(callback_).Run(error);
  271. }
  272. const Host& request_endpoint() const { return request_endpoint_; }
  273. const NetworkIsolationKey& network_isolation_key() const {
  274. return network_isolation_key_;
  275. }
  276. const ResolveHostParameters& parameters() const { return parameters_; }
  277. int host_resolver_flags() const { return host_resolver_flags_; }
  278. size_t id() { return id_; }
  279. RequestPriority priority() const { return priority_; }
  280. void set_id(size_t id) {
  281. DCHECK_GT(id, 0u);
  282. DCHECK_EQ(0u, id_);
  283. id_ = id;
  284. }
  285. bool complete() { return complete_; }
  286. // Similar get GetAddressResults() and GetResolveErrorInfo(), but only exposed
  287. // through the HostResolver::ResolveHostRequest interface, and don't have the
  288. // DCHECKs that `complete_` is true.
  289. const absl::optional<AddressList>& address_results() const {
  290. return address_results_;
  291. }
  292. ResolveErrorInfo resolve_error_info() const { return resolve_error_info_; }
  293. private:
  294. std::vector<IPEndPoint> FixupEndPoints(
  295. const std::vector<IPEndPoint>& endpoints) {
  296. std::vector<IPEndPoint> corrected;
  297. for (const IPEndPoint& endpoint : endpoints) {
  298. DCHECK_NE(endpoint.GetFamily(), ADDRESS_FAMILY_UNSPECIFIED);
  299. if (parameters_.dns_query_type == DnsQueryType::UNSPECIFIED ||
  300. parameters_.dns_query_type ==
  301. AddressFamilyToDnsQueryType(endpoint.GetFamily())) {
  302. if (endpoint.port() == 0) {
  303. corrected.emplace_back(endpoint.address(),
  304. GetPort(request_endpoint_));
  305. } else {
  306. corrected.push_back(endpoint);
  307. }
  308. }
  309. }
  310. return corrected;
  311. }
  312. std::set<std::string> FixupAliases(const std::set<std::string> aliases) {
  313. if (aliases.empty())
  314. return std::set<std::string>{std::string(GetHostname(request_endpoint_))};
  315. return aliases;
  316. }
  317. const Host request_endpoint_;
  318. const NetworkIsolationKey network_isolation_key_;
  319. const ResolveHostParameters parameters_;
  320. RequestPriority priority_;
  321. int host_resolver_flags_;
  322. absl::optional<AddressList> address_results_;
  323. absl::optional<std::vector<HostResolverEndpointResult>> endpoint_results_;
  324. absl::optional<std::set<std::string>> fixed_up_dns_alias_results_;
  325. absl::optional<HostCache::EntryStaleness> staleness_;
  326. ResolveErrorInfo resolve_error_info_;
  327. // Used while stored with the resolver for async resolution. Otherwise 0.
  328. size_t id_ = 0;
  329. CompletionOnceCallback callback_;
  330. // Use a WeakPtr as the resolver may be destroyed while there are still
  331. // outstanding request objects.
  332. base::WeakPtr<MockHostResolverBase> resolver_;
  333. bool complete_ = false;
  334. };
  335. class MockHostResolverBase::ProbeRequestImpl
  336. : public HostResolver::ProbeRequest {
  337. public:
  338. explicit ProbeRequestImpl(base::WeakPtr<MockHostResolverBase> resolver)
  339. : resolver_(std::move(resolver)) {}
  340. ProbeRequestImpl(const ProbeRequestImpl&) = delete;
  341. ProbeRequestImpl& operator=(const ProbeRequestImpl&) = delete;
  342. ~ProbeRequestImpl() override {
  343. if (resolver_) {
  344. resolver_->state_->ClearDohProbeRequestIfMatching(this);
  345. }
  346. }
  347. int Start() override {
  348. DCHECK(resolver_);
  349. resolver_->state_->set_doh_probe_request(this);
  350. return ERR_IO_PENDING;
  351. }
  352. private:
  353. base::WeakPtr<MockHostResolverBase> resolver_;
  354. };
  355. class MockHostResolverBase::MdnsListenerImpl
  356. : public HostResolver::MdnsListener {
  357. public:
  358. MdnsListenerImpl(const HostPortPair& host,
  359. DnsQueryType query_type,
  360. base::WeakPtr<MockHostResolverBase> resolver)
  361. : host_(host), query_type_(query_type), resolver_(resolver) {
  362. DCHECK_NE(DnsQueryType::UNSPECIFIED, query_type_);
  363. DCHECK(resolver_);
  364. }
  365. ~MdnsListenerImpl() override {
  366. if (resolver_)
  367. resolver_->RemoveCancelledListener(this);
  368. }
  369. int Start(Delegate* delegate) override {
  370. DCHECK(delegate);
  371. DCHECK(!delegate_);
  372. DCHECK(resolver_);
  373. delegate_ = delegate;
  374. resolver_->AddListener(this);
  375. return OK;
  376. }
  377. void TriggerAddressResult(MdnsListenerUpdateType update_type,
  378. IPEndPoint address) {
  379. delegate_->OnAddressResult(update_type, query_type_, std::move(address));
  380. }
  381. void TriggerTextResult(MdnsListenerUpdateType update_type,
  382. std::vector<std::string> text_records) {
  383. delegate_->OnTextResult(update_type, query_type_, std::move(text_records));
  384. }
  385. void TriggerHostnameResult(MdnsListenerUpdateType update_type,
  386. HostPortPair host) {
  387. delegate_->OnHostnameResult(update_type, query_type_, std::move(host));
  388. }
  389. void TriggerUnhandledResult(MdnsListenerUpdateType update_type) {
  390. delegate_->OnUnhandledResult(update_type, query_type_);
  391. }
  392. const HostPortPair& host() const { return host_; }
  393. DnsQueryType query_type() const { return query_type_; }
  394. private:
  395. const HostPortPair host_;
  396. const DnsQueryType query_type_;
  397. raw_ptr<Delegate> delegate_ = nullptr;
  398. // Use a WeakPtr as the resolver may be destroyed while there are still
  399. // outstanding listener objects.
  400. base::WeakPtr<MockHostResolverBase> resolver_;
  401. };
  402. MockHostResolverBase::RuleResolver::RuleKey::RuleKey() = default;
  403. MockHostResolverBase::RuleResolver::RuleKey::~RuleKey() = default;
  404. MockHostResolverBase::RuleResolver::RuleKey::RuleKey(const RuleKey&) = default;
  405. MockHostResolverBase::RuleResolver::RuleKey&
  406. MockHostResolverBase::RuleResolver::RuleKey::operator=(const RuleKey&) =
  407. default;
  408. MockHostResolverBase::RuleResolver::RuleKey::RuleKey(RuleKey&&) = default;
  409. MockHostResolverBase::RuleResolver::RuleKey&
  410. MockHostResolverBase::RuleResolver::RuleKey::operator=(RuleKey&&) = default;
  411. MockHostResolverBase::RuleResolver::RuleResult::RuleResult() = default;
  412. MockHostResolverBase::RuleResolver::RuleResult::RuleResult(
  413. std::vector<HostResolverEndpointResult> endpoints,
  414. std::set<std::string> aliases)
  415. : endpoints(std::move(endpoints)), aliases(std::move(aliases)) {}
  416. MockHostResolverBase::RuleResolver::RuleResult::~RuleResult() = default;
  417. MockHostResolverBase::RuleResolver::RuleResult::RuleResult(const RuleResult&) =
  418. default;
  419. MockHostResolverBase::RuleResolver::RuleResult&
  420. MockHostResolverBase::RuleResolver::RuleResult::operator=(const RuleResult&) =
  421. default;
  422. MockHostResolverBase::RuleResolver::RuleResult::RuleResult(RuleResult&&) =
  423. default;
  424. MockHostResolverBase::RuleResolver::RuleResult&
  425. MockHostResolverBase::RuleResolver::RuleResult::operator=(RuleResult&&) =
  426. default;
  427. MockHostResolverBase::RuleResolver::RuleResolver(
  428. absl::optional<RuleResultOrError> default_result)
  429. : default_result_(std::move(default_result)) {}
  430. MockHostResolverBase::RuleResolver::~RuleResolver() = default;
  431. MockHostResolverBase::RuleResolver::RuleResolver(const RuleResolver&) = default;
  432. MockHostResolverBase::RuleResolver&
  433. MockHostResolverBase::RuleResolver::operator=(const RuleResolver&) = default;
  434. MockHostResolverBase::RuleResolver::RuleResolver(RuleResolver&&) = default;
  435. MockHostResolverBase::RuleResolver&
  436. MockHostResolverBase::RuleResolver::operator=(RuleResolver&&) = default;
  437. const MockHostResolverBase::RuleResolver::RuleResultOrError&
  438. MockHostResolverBase::RuleResolver::Resolve(
  439. const Host& request_endpoint,
  440. DnsQueryTypeSet request_types,
  441. HostResolverSource request_source) const {
  442. for (const auto& rule : rules_) {
  443. const RuleKey& key = rule.first;
  444. const RuleResultOrError& result = rule.second;
  445. if (absl::holds_alternative<RuleKey::NoScheme>(key.scheme) &&
  446. absl::holds_alternative<url::SchemeHostPort>(request_endpoint)) {
  447. continue;
  448. }
  449. if (key.port.has_value() && key.port.value() != GetPort(request_endpoint)) {
  450. continue;
  451. }
  452. DCHECK(!key.query_type.has_value() ||
  453. key.query_type.value() != DnsQueryType::UNSPECIFIED);
  454. if (key.query_type.has_value() &&
  455. !request_types.Has(key.query_type.value())) {
  456. continue;
  457. }
  458. if (key.query_source.has_value() &&
  459. request_source != key.query_source.value()) {
  460. continue;
  461. }
  462. if (absl::holds_alternative<RuleKey::Scheme>(key.scheme) &&
  463. (!absl::holds_alternative<url::SchemeHostPort>(request_endpoint) ||
  464. GetScheme(request_endpoint) !=
  465. absl::get<RuleKey::Scheme>(key.scheme))) {
  466. continue;
  467. }
  468. if (!base::MatchPattern(GetHostname(request_endpoint),
  469. key.hostname_pattern)) {
  470. continue;
  471. }
  472. return result;
  473. }
  474. if (default_result_)
  475. return default_result_.value();
  476. NOTREACHED() << "Request " << GetHostname(request_endpoint)
  477. << " did not match any MockHostResolver rules.";
  478. static const RuleResultOrError kUnexpected = ERR_UNEXPECTED;
  479. return kUnexpected;
  480. }
  481. void MockHostResolverBase::RuleResolver::ClearRules() {
  482. rules_.clear();
  483. }
  484. // static
  485. MockHostResolverBase::RuleResolver::RuleResultOrError
  486. MockHostResolverBase::RuleResolver::GetLocalhostResult() {
  487. HostResolverEndpointResult endpoint;
  488. endpoint.ip_endpoints = {IPEndPoint(IPAddress::IPv4Localhost(), /*port=*/0)};
  489. return RuleResult(std::vector{endpoint});
  490. }
  491. void MockHostResolverBase::RuleResolver::AddRule(RuleKey key,
  492. RuleResultOrError result) {
  493. // Literals are always resolved to themselves by MockHostResolverBase,
  494. // consequently we do not support remapping them.
  495. IPAddress ip_address;
  496. DCHECK(!ip_address.AssignFromIPLiteral(key.hostname_pattern));
  497. CHECK(rules_.emplace(std::move(key), std::move(result)).second)
  498. << "Duplicate rule key";
  499. }
  500. void MockHostResolverBase::RuleResolver::AddRule(RuleKey key,
  501. base::StringPiece ip_literal) {
  502. std::vector<HostResolverEndpointResult> endpoints;
  503. endpoints.emplace_back();
  504. CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK);
  505. AddRule(std::move(key), RuleResult(std::move(endpoints)));
  506. }
  507. void MockHostResolverBase::RuleResolver::AddRule(
  508. base::StringPiece hostname_pattern,
  509. RuleResultOrError result) {
  510. RuleKey key;
  511. key.hostname_pattern = std::string(hostname_pattern);
  512. AddRule(std::move(key), std::move(result));
  513. }
  514. void MockHostResolverBase::RuleResolver::AddRule(
  515. base::StringPiece hostname_pattern,
  516. base::StringPiece ip_literal) {
  517. std::vector<HostResolverEndpointResult> endpoints;
  518. endpoints.emplace_back();
  519. CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK);
  520. AddRule(hostname_pattern, RuleResult(std::move(endpoints)));
  521. }
  522. void MockHostResolverBase::RuleResolver::AddRule(
  523. base::StringPiece hostname_pattern,
  524. Error error) {
  525. RuleKey key;
  526. key.hostname_pattern = std::string(hostname_pattern);
  527. AddRule(std::move(key), error);
  528. }
  529. void MockHostResolverBase::RuleResolver::AddIPLiteralRule(
  530. base::StringPiece hostname_pattern,
  531. base::StringPiece ip_literal,
  532. base::StringPiece canonical_name) {
  533. RuleKey key;
  534. key.hostname_pattern = std::string(hostname_pattern);
  535. std::set<std::string> aliases;
  536. if (!canonical_name.empty())
  537. aliases.emplace(canonical_name);
  538. std::vector<HostResolverEndpointResult> endpoints;
  539. endpoints.emplace_back();
  540. CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK);
  541. AddRule(std::move(key), RuleResult(std::move(endpoints), std::move(aliases)));
  542. }
  543. void MockHostResolverBase::RuleResolver::AddIPLiteralRuleWithDnsAliases(
  544. base::StringPiece hostname_pattern,
  545. base::StringPiece ip_literal,
  546. std::vector<std::string> dns_aliases) {
  547. std::vector<HostResolverEndpointResult> endpoints;
  548. endpoints.emplace_back();
  549. CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK);
  550. AddRule(hostname_pattern,
  551. RuleResult(std::move(endpoints),
  552. std::set(dns_aliases.begin(), dns_aliases.end())));
  553. }
  554. void MockHostResolverBase::RuleResolver::AddIPLiteralRuleWithDnsAliases(
  555. base::StringPiece hostname_pattern,
  556. base::StringPiece ip_literal,
  557. std::set<std::string> dns_aliases) {
  558. std::vector<std::string> aliases_vector;
  559. base::ranges::move(dns_aliases, std::back_inserter(aliases_vector));
  560. AddIPLiteralRuleWithDnsAliases(hostname_pattern, ip_literal,
  561. std::move(aliases_vector));
  562. }
  563. void MockHostResolverBase::RuleResolver::AddSimulatedFailure(
  564. base::StringPiece hostname_pattern) {
  565. AddRule(hostname_pattern, ERR_NAME_NOT_RESOLVED);
  566. }
  567. void MockHostResolverBase::RuleResolver::AddSimulatedTimeoutFailure(
  568. base::StringPiece hostname_pattern) {
  569. AddRule(hostname_pattern, ERR_DNS_TIMED_OUT);
  570. }
  571. void MockHostResolverBase::RuleResolver::AddRuleWithFlags(
  572. base::StringPiece host_pattern,
  573. base::StringPiece ip_literal,
  574. HostResolverFlags /*flags*/,
  575. std::vector<std::string> dns_aliases) {
  576. std::vector<HostResolverEndpointResult> endpoints;
  577. endpoints.emplace_back();
  578. CHECK_EQ(ParseAddressList(ip_literal, &endpoints[0].ip_endpoints), OK);
  579. AddRule(host_pattern,
  580. RuleResult(std::move(endpoints),
  581. std::set(dns_aliases.begin(), dns_aliases.end())));
  582. }
  583. MockHostResolverBase::State::State() = default;
  584. MockHostResolverBase::State::~State() = default;
  585. MockHostResolverBase::~MockHostResolverBase() {
  586. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  587. // Sanity check that pending requests are always cleaned up, by waiting for
  588. // completion, manually cancelling, or calling OnShutdown().
  589. DCHECK(!state_->has_pending_requests());
  590. }
  591. void MockHostResolverBase::OnShutdown() {
  592. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  593. // Cancel all pending requests.
  594. for (auto& request : state_->mutable_requests()) {
  595. request.second->DetachFromResolver();
  596. }
  597. state_->mutable_requests().clear();
  598. // Prevent future requests by clearing resolution rules and the cache.
  599. rule_resolver_.ClearRules();
  600. cache_ = nullptr;
  601. state_->ClearDohProbeRequest();
  602. }
  603. std::unique_ptr<HostResolver::ResolveHostRequest>
  604. MockHostResolverBase::CreateRequest(
  605. url::SchemeHostPort host,
  606. NetworkIsolationKey network_isolation_key,
  607. NetLogWithSource net_log,
  608. absl::optional<ResolveHostParameters> optional_parameters) {
  609. return std::make_unique<RequestImpl>(std::move(host), network_isolation_key,
  610. optional_parameters, AsWeakPtr());
  611. }
  612. std::unique_ptr<HostResolver::ResolveHostRequest>
  613. MockHostResolverBase::CreateRequest(
  614. const HostPortPair& host,
  615. const NetworkIsolationKey& network_isolation_key,
  616. const NetLogWithSource& source_net_log,
  617. const absl::optional<ResolveHostParameters>& optional_parameters) {
  618. return std::make_unique<RequestImpl>(host, network_isolation_key,
  619. optional_parameters, AsWeakPtr());
  620. }
  621. std::unique_ptr<HostResolver::ProbeRequest>
  622. MockHostResolverBase::CreateDohProbeRequest() {
  623. return std::make_unique<ProbeRequestImpl>(AsWeakPtr());
  624. }
  625. std::unique_ptr<HostResolver::MdnsListener>
  626. MockHostResolverBase::CreateMdnsListener(const HostPortPair& host,
  627. DnsQueryType query_type) {
  628. return std::make_unique<MdnsListenerImpl>(host, query_type, AsWeakPtr());
  629. }
  630. HostCache* MockHostResolverBase::GetHostCache() {
  631. return cache_.get();
  632. }
  633. int MockHostResolverBase::LoadIntoCache(
  634. const Host& endpoint,
  635. const NetworkIsolationKey& network_isolation_key,
  636. const absl::optional<ResolveHostParameters>& optional_parameters) {
  637. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  638. DCHECK(cache_);
  639. ResolveHostParameters parameters =
  640. optional_parameters.value_or(ResolveHostParameters());
  641. std::vector<HostResolverEndpointResult> endpoints;
  642. std::set<std::string> aliases;
  643. absl::optional<HostCache::EntryStaleness> stale_info;
  644. int rv = ResolveFromIPLiteralOrCache(
  645. endpoint, network_isolation_key, parameters.dns_query_type,
  646. ParametersToHostResolverFlags(parameters), parameters.source,
  647. parameters.cache_usage, &endpoints, &aliases, &stale_info);
  648. if (rv != ERR_DNS_CACHE_MISS) {
  649. // Request already in cache (or IP literal). No need to load it.
  650. return rv;
  651. }
  652. // Just like the real resolver, refuse to do anything with invalid
  653. // hostnames.
  654. if (!IsValidDNSDomain(GetHostname(endpoint)))
  655. return ERR_NAME_NOT_RESOLVED;
  656. RequestImpl request(endpoint, network_isolation_key, optional_parameters,
  657. AsWeakPtr());
  658. return DoSynchronousResolution(request);
  659. }
  660. void MockHostResolverBase::ResolveAllPending() {
  661. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  662. DCHECK(ondemand_mode_);
  663. for (auto& [id, request] : state_->mutable_requests()) {
  664. base::ThreadTaskRunnerHandle::Get()->PostTask(
  665. FROM_HERE,
  666. base::BindOnce(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
  667. }
  668. }
  669. size_t MockHostResolverBase::last_id() {
  670. if (!has_pending_requests())
  671. return 0;
  672. return state_->mutable_requests().rbegin()->first;
  673. }
  674. void MockHostResolverBase::ResolveNow(size_t id) {
  675. auto it = state_->mutable_requests().find(id);
  676. if (it == state_->mutable_requests().end())
  677. return; // was canceled
  678. RequestImpl* req = it->second;
  679. state_->mutable_requests().erase(it);
  680. int error = DoSynchronousResolution(*req);
  681. req->OnAsyncCompleted(id, error);
  682. }
  683. void MockHostResolverBase::DetachRequest(size_t id) {
  684. auto it = state_->mutable_requests().find(id);
  685. CHECK(it != state_->mutable_requests().end());
  686. state_->mutable_requests().erase(it);
  687. }
  688. base::StringPiece MockHostResolverBase::request_host(size_t id) {
  689. DCHECK(request(id));
  690. return GetHostname(request(id)->request_endpoint());
  691. }
  692. RequestPriority MockHostResolverBase::request_priority(size_t id) {
  693. DCHECK(request(id));
  694. return request(id)->priority();
  695. }
  696. const NetworkIsolationKey& MockHostResolverBase::request_network_isolation_key(
  697. size_t id) {
  698. DCHECK(request(id));
  699. return request(id)->network_isolation_key();
  700. }
  701. void MockHostResolverBase::ResolveOnlyRequestNow() {
  702. DCHECK_EQ(1u, state_->mutable_requests().size());
  703. ResolveNow(state_->mutable_requests().begin()->first);
  704. }
  705. void MockHostResolverBase::TriggerMdnsListeners(
  706. const HostPortPair& host,
  707. DnsQueryType query_type,
  708. MdnsListenerUpdateType update_type,
  709. const IPEndPoint& address_result) {
  710. for (auto* listener : listeners_) {
  711. if (listener->host() == host && listener->query_type() == query_type)
  712. listener->TriggerAddressResult(update_type, address_result);
  713. }
  714. }
  715. void MockHostResolverBase::TriggerMdnsListeners(
  716. const HostPortPair& host,
  717. DnsQueryType query_type,
  718. MdnsListenerUpdateType update_type,
  719. const std::vector<std::string>& text_result) {
  720. for (auto* listener : listeners_) {
  721. if (listener->host() == host && listener->query_type() == query_type)
  722. listener->TriggerTextResult(update_type, text_result);
  723. }
  724. }
  725. void MockHostResolverBase::TriggerMdnsListeners(
  726. const HostPortPair& host,
  727. DnsQueryType query_type,
  728. MdnsListenerUpdateType update_type,
  729. const HostPortPair& host_result) {
  730. for (auto* listener : listeners_) {
  731. if (listener->host() == host && listener->query_type() == query_type)
  732. listener->TriggerHostnameResult(update_type, host_result);
  733. }
  734. }
  735. void MockHostResolverBase::TriggerMdnsListeners(
  736. const HostPortPair& host,
  737. DnsQueryType query_type,
  738. MdnsListenerUpdateType update_type) {
  739. for (auto* listener : listeners_) {
  740. if (listener->host() == host && listener->query_type() == query_type)
  741. listener->TriggerUnhandledResult(update_type);
  742. }
  743. }
  744. MockHostResolverBase::RequestImpl* MockHostResolverBase::request(size_t id) {
  745. RequestMap::iterator request = state_->mutable_requests().find(id);
  746. CHECK(request != state_->mutable_requests().end());
  747. CHECK_EQ(request->second->id(), id);
  748. return (*request).second;
  749. }
  750. // start id from 1 to distinguish from NULL RequestHandle
  751. MockHostResolverBase::MockHostResolverBase(bool use_caching,
  752. int cache_invalidation_num,
  753. RuleResolver rule_resolver)
  754. : rule_resolver_(std::move(rule_resolver)),
  755. initial_cache_invalidation_num_(cache_invalidation_num),
  756. tick_clock_(base::DefaultTickClock::GetInstance()),
  757. state_(base::MakeRefCounted<State>()) {
  758. if (use_caching)
  759. cache_ = std::make_unique<HostCache>(kMaxCacheEntries);
  760. else
  761. DCHECK_GE(0, cache_invalidation_num);
  762. }
  763. int MockHostResolverBase::Resolve(RequestImpl* request) {
  764. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  765. last_request_priority_ = request->parameters().initial_priority;
  766. last_request_network_isolation_key_ = request->network_isolation_key();
  767. last_secure_dns_policy_ = request->parameters().secure_dns_policy;
  768. state_->IncrementNumResolve();
  769. std::vector<HostResolverEndpointResult> endpoints;
  770. std::set<std::string> aliases;
  771. absl::optional<HostCache::EntryStaleness> stale_info;
  772. // TODO(crbug.com/1264933): Allow caching `ConnectionEndpoint` results.
  773. int rv = ResolveFromIPLiteralOrCache(
  774. request->request_endpoint(), request->network_isolation_key(),
  775. request->parameters().dns_query_type, request->host_resolver_flags(),
  776. request->parameters().source, request->parameters().cache_usage,
  777. &endpoints, &aliases, &stale_info);
  778. if (rv == OK && !request->parameters().is_speculative) {
  779. request->SetEndpointResults(std::move(endpoints), std::move(aliases),
  780. std::move(stale_info));
  781. } else {
  782. request->SetError(rv);
  783. }
  784. if (rv != ERR_DNS_CACHE_MISS ||
  785. request->parameters().source == HostResolverSource::LOCAL_ONLY) {
  786. return SquashErrorCode(rv);
  787. }
  788. // Just like the real resolver, refuse to do anything with invalid
  789. // hostnames.
  790. if (!IsValidDNSDomain(GetHostname(request->request_endpoint()))) {
  791. request->SetError(ERR_NAME_NOT_RESOLVED);
  792. return ERR_NAME_NOT_RESOLVED;
  793. }
  794. if (synchronous_mode_)
  795. return DoSynchronousResolution(*request);
  796. // Store the request for asynchronous resolution
  797. size_t id = next_request_id_++;
  798. request->set_id(id);
  799. state_->mutable_requests()[id] = request;
  800. if (!ondemand_mode_) {
  801. base::ThreadTaskRunnerHandle::Get()->PostTask(
  802. FROM_HERE,
  803. base::BindOnce(&MockHostResolverBase::ResolveNow, AsWeakPtr(), id));
  804. }
  805. return ERR_IO_PENDING;
  806. }
  807. int MockHostResolverBase::ResolveFromIPLiteralOrCache(
  808. const Host& endpoint,
  809. const NetworkIsolationKey& network_isolation_key,
  810. DnsQueryType dns_query_type,
  811. HostResolverFlags flags,
  812. HostResolverSource source,
  813. HostResolver::ResolveHostParameters::CacheUsage cache_usage,
  814. std::vector<HostResolverEndpointResult>* out_endpoints,
  815. std::set<std::string>* out_aliases,
  816. absl::optional<HostCache::EntryStaleness>* out_stale_info) {
  817. DCHECK(out_endpoints);
  818. DCHECK(out_aliases);
  819. DCHECK(out_stale_info);
  820. out_endpoints->clear();
  821. out_aliases->clear();
  822. *out_stale_info = absl::nullopt;
  823. IPAddress ip_address;
  824. if (ip_address.AssignFromIPLiteral(GetHostname(endpoint))) {
  825. const DnsQueryType desired_address_query =
  826. AddressFamilyToDnsQueryType(GetAddressFamily(ip_address));
  827. DCHECK_NE(desired_address_query, DnsQueryType::UNSPECIFIED);
  828. // This matches the behavior HostResolverImpl.
  829. if (dns_query_type != DnsQueryType::UNSPECIFIED &&
  830. dns_query_type != desired_address_query) {
  831. return ERR_NAME_NOT_RESOLVED;
  832. }
  833. *out_endpoints = std::vector<HostResolverEndpointResult>(1);
  834. (*out_endpoints)[0].ip_endpoints.emplace_back(ip_address,
  835. GetPort(endpoint));
  836. if (flags & HOST_RESOLVER_CANONNAME)
  837. *out_aliases = {ip_address.ToString()};
  838. return OK;
  839. }
  840. std::vector<IPEndPoint> localhost_endpoints;
  841. // Immediately resolve any "localhost" or recognized similar names.
  842. if (IsAddressType(dns_query_type) &&
  843. ResolveLocalHostname(GetHostname(endpoint), &localhost_endpoints)) {
  844. *out_endpoints = std::vector<HostResolverEndpointResult>(1);
  845. (*out_endpoints)[0].ip_endpoints = localhost_endpoints;
  846. return OK;
  847. }
  848. int rv = ERR_DNS_CACHE_MISS;
  849. bool cache_allowed =
  850. cache_usage == HostResolver::ResolveHostParameters::CacheUsage::ALLOWED ||
  851. cache_usage ==
  852. HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED;
  853. if (cache_.get() && cache_allowed) {
  854. // Local-only requests search the cache for non-local-only results.
  855. HostResolverSource effective_source =
  856. source == HostResolverSource::LOCAL_ONLY ? HostResolverSource::ANY
  857. : source;
  858. HostCache::Key key(GetCacheHost(endpoint), dns_query_type, flags,
  859. effective_source, network_isolation_key);
  860. const std::pair<const HostCache::Key, HostCache::Entry>* cache_result;
  861. HostCache::EntryStaleness stale_info = HostCache::kNotStale;
  862. if (cache_usage ==
  863. HostResolver::ResolveHostParameters::CacheUsage::STALE_ALLOWED) {
  864. cache_result = cache_->LookupStale(key, tick_clock_->NowTicks(),
  865. &stale_info, true /* ignore_secure */);
  866. } else {
  867. cache_result = cache_->Lookup(key, tick_clock_->NowTicks(),
  868. true /* ignore_secure */);
  869. }
  870. if (cache_result) {
  871. rv = cache_result->second.error();
  872. if (rv == OK) {
  873. *out_endpoints = std::vector<HostResolverEndpointResult>(1);
  874. (*out_endpoints)[0].ip_endpoints = *cache_result->second.ip_endpoints();
  875. if (cache_result->second.aliases()) {
  876. const auto& aliasess = *cache_result->second.aliases();
  877. *out_aliases =
  878. std::set<std::string>(aliasess.begin(), aliasess.end());
  879. }
  880. *out_stale_info = std::move(stale_info);
  881. }
  882. auto cache_invalidation_iterator = cache_invalidation_nums_.find(key);
  883. if (cache_invalidation_iterator != cache_invalidation_nums_.end()) {
  884. DCHECK_LE(1, cache_invalidation_iterator->second);
  885. cache_invalidation_iterator->second--;
  886. if (cache_invalidation_iterator->second == 0) {
  887. HostCache::Entry new_entry(cache_result->second);
  888. cache_->Set(key, new_entry, tick_clock_->NowTicks(),
  889. base::TimeDelta());
  890. cache_invalidation_nums_.erase(cache_invalidation_iterator);
  891. }
  892. }
  893. }
  894. }
  895. return rv;
  896. }
  897. int MockHostResolverBase::DoSynchronousResolution(RequestImpl& request) {
  898. state_->IncrementNumNonLocalResolves();
  899. const RuleResolver::RuleResultOrError& result = rule_resolver_.Resolve(
  900. request.request_endpoint(), request.parameters().dns_query_type,
  901. request.parameters().source);
  902. int error = ERR_UNEXPECTED;
  903. absl::optional<HostCache::Entry> cache_entry;
  904. if (absl::holds_alternative<RuleResolver::RuleResult>(result)) {
  905. const auto& rule_result = absl::get<RuleResolver::RuleResult>(result);
  906. const auto& endpoint_results = rule_result.endpoints;
  907. const auto& aliases = rule_result.aliases;
  908. request.SetEndpointResults(endpoint_results, aliases,
  909. /*staleness=*/absl::nullopt);
  910. // TODO(crbug.com/1264933): Change `error` on empty results?
  911. error = OK;
  912. if (cache_.get()) {
  913. cache_entry = CreateCacheEntry(endpoint_results, aliases);
  914. }
  915. } else {
  916. DCHECK(absl::holds_alternative<RuleResolver::ErrorResult>(result));
  917. error = absl::get<RuleResolver::ErrorResult>(result);
  918. request.SetError(error);
  919. if (cache_.get()) {
  920. cache_entry.emplace(error, HostCache::Entry::SOURCE_UNKNOWN);
  921. }
  922. }
  923. if (cache_.get() && cache_entry.has_value()) {
  924. HostCache::Key key(
  925. GetCacheHost(request.request_endpoint()),
  926. request.parameters().dns_query_type, request.host_resolver_flags(),
  927. request.parameters().source, request.network_isolation_key());
  928. // Storing a failure with TTL 0 so that it overwrites previous value.
  929. base::TimeDelta ttl;
  930. if (error == OK) {
  931. ttl = base::Seconds(kCacheEntryTTLSeconds);
  932. if (initial_cache_invalidation_num_ > 0)
  933. cache_invalidation_nums_[key] = initial_cache_invalidation_num_;
  934. }
  935. cache_->Set(key, cache_entry.value(), tick_clock_->NowTicks(), ttl);
  936. }
  937. return SquashErrorCode(error);
  938. }
  939. void MockHostResolverBase::AddListener(MdnsListenerImpl* listener) {
  940. listeners_.insert(listener);
  941. }
  942. void MockHostResolverBase::RemoveCancelledListener(MdnsListenerImpl* listener) {
  943. listeners_.erase(listener);
  944. }
  945. MockHostResolverFactory::MockHostResolverFactory(
  946. MockHostResolverBase::RuleResolver rules,
  947. bool use_caching,
  948. int cache_invalidation_num)
  949. : rules_(std::move(rules)),
  950. use_caching_(use_caching),
  951. cache_invalidation_num_(cache_invalidation_num) {}
  952. MockHostResolverFactory::~MockHostResolverFactory() = default;
  953. std::unique_ptr<HostResolver> MockHostResolverFactory::CreateResolver(
  954. HostResolverManager* manager,
  955. base::StringPiece host_mapping_rules,
  956. bool enable_caching) {
  957. DCHECK(host_mapping_rules.empty());
  958. // Explicit new to access private constructor.
  959. auto resolver = base::WrapUnique(new MockHostResolverBase(
  960. enable_caching && use_caching_, cache_invalidation_num_, rules_));
  961. return resolver;
  962. }
  963. std::unique_ptr<HostResolver> MockHostResolverFactory::CreateStandaloneResolver(
  964. NetLog* net_log,
  965. const HostResolver::ManagerOptions& options,
  966. base::StringPiece host_mapping_rules,
  967. bool enable_caching) {
  968. return CreateResolver(nullptr, host_mapping_rules, enable_caching);
  969. }
  970. //-----------------------------------------------------------------------------
  971. RuleBasedHostResolverProc::Rule::Rule(ResolverType resolver_type,
  972. base::StringPiece host_pattern,
  973. AddressFamily address_family,
  974. HostResolverFlags host_resolver_flags,
  975. base::StringPiece replacement,
  976. std::vector<std::string> dns_aliases,
  977. int latency_ms)
  978. : resolver_type(resolver_type),
  979. host_pattern(host_pattern),
  980. address_family(address_family),
  981. host_resolver_flags(host_resolver_flags),
  982. replacement(replacement),
  983. dns_aliases(std::move(dns_aliases)),
  984. latency_ms(latency_ms) {
  985. DCHECK(this->dns_aliases != std::vector<std::string>({""}));
  986. }
  987. RuleBasedHostResolverProc::Rule::Rule(const Rule& other) = default;
  988. RuleBasedHostResolverProc::Rule::~Rule() = default;
  989. RuleBasedHostResolverProc::RuleBasedHostResolverProc(
  990. scoped_refptr<HostResolverProc> previous,
  991. bool allow_fallback)
  992. : HostResolverProc(std::move(previous), allow_fallback) {}
  993. void RuleBasedHostResolverProc::AddRule(base::StringPiece host_pattern,
  994. base::StringPiece replacement) {
  995. AddRuleForAddressFamily(host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
  996. replacement);
  997. }
  998. void RuleBasedHostResolverProc::AddRuleForAddressFamily(
  999. base::StringPiece host_pattern,
  1000. AddressFamily address_family,
  1001. base::StringPiece replacement) {
  1002. DCHECK(!replacement.empty());
  1003. HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY;
  1004. Rule rule(Rule::kResolverTypeSystem, host_pattern, address_family, flags,
  1005. replacement, {} /* dns_aliases */, 0);
  1006. AddRuleInternal(rule);
  1007. }
  1008. void RuleBasedHostResolverProc::AddRuleWithFlags(
  1009. base::StringPiece host_pattern,
  1010. base::StringPiece replacement,
  1011. HostResolverFlags flags,
  1012. std::vector<std::string> dns_aliases) {
  1013. DCHECK(!replacement.empty());
  1014. Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
  1015. flags, replacement, std::move(dns_aliases), 0);
  1016. AddRuleInternal(rule);
  1017. }
  1018. void RuleBasedHostResolverProc::AddIPLiteralRule(
  1019. base::StringPiece host_pattern,
  1020. base::StringPiece ip_literal,
  1021. base::StringPiece canonical_name) {
  1022. // Literals are always resolved to themselves by HostResolverImpl,
  1023. // consequently we do not support remapping them.
  1024. IPAddress ip_address;
  1025. DCHECK(!ip_address.AssignFromIPLiteral(host_pattern));
  1026. HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY;
  1027. std::vector<std::string> aliases;
  1028. if (!canonical_name.empty()) {
  1029. flags |= HOST_RESOLVER_CANONNAME;
  1030. aliases.emplace_back(canonical_name);
  1031. }
  1032. Rule rule(Rule::kResolverTypeIPLiteral, host_pattern,
  1033. ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal, std::move(aliases),
  1034. 0);
  1035. AddRuleInternal(rule);
  1036. }
  1037. void RuleBasedHostResolverProc::AddIPLiteralRuleWithDnsAliases(
  1038. base::StringPiece host_pattern,
  1039. base::StringPiece ip_literal,
  1040. std::vector<std::string> dns_aliases) {
  1041. // Literals are always resolved to themselves by HostResolverImpl,
  1042. // consequently we do not support remapping them.
  1043. IPAddress ip_address;
  1044. DCHECK(!ip_address.AssignFromIPLiteral(host_pattern));
  1045. HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY;
  1046. if (!dns_aliases.empty())
  1047. flags |= HOST_RESOLVER_CANONNAME;
  1048. Rule rule(Rule::kResolverTypeIPLiteral, host_pattern,
  1049. ADDRESS_FAMILY_UNSPECIFIED, flags, ip_literal,
  1050. std::move(dns_aliases), 0);
  1051. AddRuleInternal(rule);
  1052. }
  1053. void RuleBasedHostResolverProc::AddRuleWithLatency(
  1054. base::StringPiece host_pattern,
  1055. base::StringPiece replacement,
  1056. int latency_ms) {
  1057. DCHECK(!replacement.empty());
  1058. HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY;
  1059. Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
  1060. flags, replacement, /*dns_aliases=*/{}, latency_ms);
  1061. AddRuleInternal(rule);
  1062. }
  1063. void RuleBasedHostResolverProc::AllowDirectLookup(
  1064. base::StringPiece host_pattern) {
  1065. HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY;
  1066. Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
  1067. flags, std::string(), /*dns_aliases=*/{}, 0);
  1068. AddRuleInternal(rule);
  1069. }
  1070. void RuleBasedHostResolverProc::AddSimulatedFailure(
  1071. base::StringPiece host_pattern,
  1072. HostResolverFlags flags) {
  1073. Rule rule(Rule::kResolverTypeFail, host_pattern, ADDRESS_FAMILY_UNSPECIFIED,
  1074. flags, std::string(), /*dns_aliases=*/{}, 0);
  1075. AddRuleInternal(rule);
  1076. }
  1077. void RuleBasedHostResolverProc::AddSimulatedTimeoutFailure(
  1078. base::StringPiece host_pattern,
  1079. HostResolverFlags flags) {
  1080. Rule rule(Rule::kResolverTypeFailTimeout, host_pattern,
  1081. ADDRESS_FAMILY_UNSPECIFIED, flags, std::string(),
  1082. /*dns_aliases=*/{}, 0);
  1083. AddRuleInternal(rule);
  1084. }
  1085. void RuleBasedHostResolverProc::ClearRules() {
  1086. CHECK(modifications_allowed_);
  1087. base::AutoLock lock(rule_lock_);
  1088. rules_.clear();
  1089. }
  1090. void RuleBasedHostResolverProc::DisableModifications() {
  1091. modifications_allowed_ = false;
  1092. }
  1093. RuleBasedHostResolverProc::RuleList RuleBasedHostResolverProc::GetRules() {
  1094. RuleList rv;
  1095. {
  1096. base::AutoLock lock(rule_lock_);
  1097. rv = rules_;
  1098. }
  1099. return rv;
  1100. }
  1101. int RuleBasedHostResolverProc::Resolve(const std::string& host,
  1102. AddressFamily address_family,
  1103. HostResolverFlags host_resolver_flags,
  1104. AddressList* addrlist,
  1105. int* os_error) {
  1106. base::AutoLock lock(rule_lock_);
  1107. RuleList::iterator r;
  1108. for (r = rules_.begin(); r != rules_.end(); ++r) {
  1109. bool matches_address_family =
  1110. r->address_family == ADDRESS_FAMILY_UNSPECIFIED ||
  1111. r->address_family == address_family;
  1112. // Ignore HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6, since it should
  1113. // have no impact on whether a rule matches.
  1114. HostResolverFlags flags =
  1115. host_resolver_flags & ~HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6;
  1116. // Flags match if all of the bitflags in host_resolver_flags are enabled
  1117. // in the rule's host_resolver_flags. However, the rule may have additional
  1118. // flags specified, in which case the flags should still be considered a
  1119. // match.
  1120. bool matches_flags = (r->host_resolver_flags & flags) == flags;
  1121. if (matches_flags && matches_address_family &&
  1122. base::MatchPattern(host, r->host_pattern)) {
  1123. if (r->latency_ms != 0) {
  1124. base::PlatformThread::Sleep(base::Milliseconds(r->latency_ms));
  1125. }
  1126. // Remap to a new host.
  1127. const std::string& effective_host =
  1128. r->replacement.empty() ? host : r->replacement;
  1129. // Apply the resolving function to the remapped hostname.
  1130. switch (r->resolver_type) {
  1131. case Rule::kResolverTypeFail:
  1132. return ERR_NAME_NOT_RESOLVED;
  1133. case Rule::kResolverTypeFailTimeout:
  1134. return ERR_DNS_TIMED_OUT;
  1135. case Rule::kResolverTypeSystem:
  1136. #if BUILDFLAG(IS_WIN)
  1137. EnsureWinsockInit();
  1138. #endif
  1139. return SystemHostResolverCall(effective_host, address_family,
  1140. host_resolver_flags, addrlist,
  1141. os_error);
  1142. case Rule::kResolverTypeIPLiteral: {
  1143. AddressList raw_addr_list;
  1144. std::vector<std::string> aliases;
  1145. aliases = (!r->dns_aliases.empty())
  1146. ? r->dns_aliases
  1147. : std::vector<std::string>({host});
  1148. std::vector<net::IPEndPoint> ip_endpoints;
  1149. int result = ParseAddressList(effective_host, &ip_endpoints);
  1150. // Filter out addresses with the wrong family.
  1151. *addrlist = AddressList();
  1152. for (const auto& address : ip_endpoints) {
  1153. if (address_family == ADDRESS_FAMILY_UNSPECIFIED ||
  1154. address_family == address.GetFamily()) {
  1155. addrlist->push_back(address);
  1156. }
  1157. }
  1158. addrlist->SetDnsAliases(aliases);
  1159. if (result == OK && addrlist->empty())
  1160. return ERR_NAME_NOT_RESOLVED;
  1161. return result;
  1162. }
  1163. default:
  1164. NOTREACHED();
  1165. return ERR_UNEXPECTED;
  1166. }
  1167. }
  1168. }
  1169. return ResolveUsingPrevious(host, address_family, host_resolver_flags,
  1170. addrlist, os_error);
  1171. }
  1172. RuleBasedHostResolverProc::~RuleBasedHostResolverProc() = default;
  1173. void RuleBasedHostResolverProc::AddRuleInternal(const Rule& rule) {
  1174. Rule fixed_rule = rule;
  1175. // SystemResolverProc expects valid DNS addresses.
  1176. // So for kResolverTypeSystem rules:
  1177. // * If the replacement is an IP address, switch to an IP literal rule.
  1178. // * If it's a non-empty invalid domain name, switch to a fail rule (Empty
  1179. // domain names mean use a direct lookup).
  1180. if (fixed_rule.resolver_type == Rule::kResolverTypeSystem) {
  1181. IPAddress ip_address;
  1182. bool valid_address = ip_address.AssignFromIPLiteral(fixed_rule.replacement);
  1183. if (valid_address) {
  1184. fixed_rule.resolver_type = Rule::kResolverTypeIPLiteral;
  1185. } else if (!fixed_rule.replacement.empty() &&
  1186. !IsValidDNSDomain(fixed_rule.replacement)) {
  1187. // TODO(mmenke): Can this be replaced with a DCHECK instead?
  1188. fixed_rule.resolver_type = Rule::kResolverTypeFail;
  1189. }
  1190. }
  1191. CHECK(modifications_allowed_);
  1192. base::AutoLock lock(rule_lock_);
  1193. rules_.push_back(fixed_rule);
  1194. }
  1195. scoped_refptr<RuleBasedHostResolverProc> CreateCatchAllHostResolverProc() {
  1196. auto catchall =
  1197. base::MakeRefCounted<RuleBasedHostResolverProc>(/*previous=*/nullptr,
  1198. /*allow_fallback=*/false);
  1199. // Note that IPv6 lookups fail.
  1200. catchall->AddIPLiteralRule("*", "127.0.0.1", "localhost");
  1201. // Next add a rules-based layer that the test controls.
  1202. return base::MakeRefCounted<RuleBasedHostResolverProc>(
  1203. std::move(catchall), /*allow_fallback=*/false);
  1204. }
  1205. //-----------------------------------------------------------------------------
  1206. // Implementation of ResolveHostRequest that tracks cancellations when the
  1207. // request is destroyed after being started.
  1208. class HangingHostResolver::RequestImpl
  1209. : public HostResolver::ResolveHostRequest,
  1210. public HostResolver::ProbeRequest {
  1211. public:
  1212. explicit RequestImpl(base::WeakPtr<HangingHostResolver> resolver)
  1213. : resolver_(resolver) {}
  1214. RequestImpl(const RequestImpl&) = delete;
  1215. RequestImpl& operator=(const RequestImpl&) = delete;
  1216. ~RequestImpl() override {
  1217. if (is_running_ && resolver_)
  1218. resolver_->state_->IncrementNumCancellations();
  1219. }
  1220. int Start(CompletionOnceCallback callback) override { return Start(); }
  1221. int Start() override {
  1222. DCHECK(resolver_);
  1223. is_running_ = true;
  1224. return ERR_IO_PENDING;
  1225. }
  1226. const AddressList* GetAddressResults() const override { IMMEDIATE_CRASH(); }
  1227. const std::vector<HostResolverEndpointResult>* GetEndpointResults()
  1228. const override {
  1229. IMMEDIATE_CRASH();
  1230. }
  1231. const absl::optional<std::vector<std::string>>& GetTextResults()
  1232. const override {
  1233. IMMEDIATE_CRASH();
  1234. }
  1235. const absl::optional<std::vector<HostPortPair>>& GetHostnameResults()
  1236. const override {
  1237. IMMEDIATE_CRASH();
  1238. }
  1239. const std::set<std::string>* GetDnsAliasResults() const override {
  1240. IMMEDIATE_CRASH();
  1241. }
  1242. net::ResolveErrorInfo GetResolveErrorInfo() const override {
  1243. IMMEDIATE_CRASH();
  1244. }
  1245. const absl::optional<HostCache::EntryStaleness>& GetStaleInfo()
  1246. const override {
  1247. IMMEDIATE_CRASH();
  1248. }
  1249. void ChangeRequestPriority(RequestPriority priority) override {}
  1250. private:
  1251. // Use a WeakPtr as the resolver may be destroyed while there are still
  1252. // outstanding request objects.
  1253. base::WeakPtr<HangingHostResolver> resolver_;
  1254. bool is_running_ = false;
  1255. };
  1256. HangingHostResolver::State::State() = default;
  1257. HangingHostResolver::State::~State() = default;
  1258. HangingHostResolver::HangingHostResolver()
  1259. : state_(base::MakeRefCounted<State>()) {}
  1260. HangingHostResolver::~HangingHostResolver() = default;
  1261. void HangingHostResolver::OnShutdown() {
  1262. shutting_down_ = true;
  1263. }
  1264. std::unique_ptr<HostResolver::ResolveHostRequest>
  1265. HangingHostResolver::CreateRequest(
  1266. url::SchemeHostPort host,
  1267. NetworkIsolationKey network_isolation_key,
  1268. NetLogWithSource net_log,
  1269. absl::optional<ResolveHostParameters> optional_parameters) {
  1270. // TODO(crbug.com/1206799): Propagate scheme and make affect behavior.
  1271. return CreateRequest(HostPortPair::FromSchemeHostPort(host),
  1272. network_isolation_key, net_log, optional_parameters);
  1273. }
  1274. std::unique_ptr<HostResolver::ResolveHostRequest>
  1275. HangingHostResolver::CreateRequest(
  1276. const HostPortPair& host,
  1277. const NetworkIsolationKey& network_isolation_key,
  1278. const NetLogWithSource& source_net_log,
  1279. const absl::optional<ResolveHostParameters>& optional_parameters) {
  1280. last_host_ = host;
  1281. last_network_isolation_key_ = network_isolation_key;
  1282. if (shutting_down_)
  1283. return CreateFailingRequest(ERR_CONTEXT_SHUT_DOWN);
  1284. if (optional_parameters &&
  1285. optional_parameters.value().source == HostResolverSource::LOCAL_ONLY) {
  1286. return CreateFailingRequest(ERR_DNS_CACHE_MISS);
  1287. }
  1288. return std::make_unique<RequestImpl>(weak_ptr_factory_.GetWeakPtr());
  1289. }
  1290. std::unique_ptr<HostResolver::ProbeRequest>
  1291. HangingHostResolver::CreateDohProbeRequest() {
  1292. if (shutting_down_)
  1293. return CreateFailingProbeRequest(ERR_CONTEXT_SHUT_DOWN);
  1294. return std::make_unique<RequestImpl>(weak_ptr_factory_.GetWeakPtr());
  1295. }
  1296. void HangingHostResolver::SetRequestContext(
  1297. URLRequestContext* url_request_context) {}
  1298. //-----------------------------------------------------------------------------
  1299. ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc() = default;
  1300. ScopedDefaultHostResolverProc::ScopedDefaultHostResolverProc(
  1301. HostResolverProc* proc) {
  1302. Init(proc);
  1303. }
  1304. ScopedDefaultHostResolverProc::~ScopedDefaultHostResolverProc() {
  1305. HostResolverProc* old_proc =
  1306. HostResolverProc::SetDefault(previous_proc_.get());
  1307. // The lifetimes of multiple instances must be nested.
  1308. CHECK_EQ(old_proc, current_proc_.get());
  1309. }
  1310. void ScopedDefaultHostResolverProc::Init(HostResolverProc* proc) {
  1311. current_proc_ = proc;
  1312. previous_proc_ = HostResolverProc::SetDefault(current_proc_.get());
  1313. current_proc_->SetLastProc(previous_proc_);
  1314. }
  1315. } // namespace net