netwerk/dns/nsDNSService2.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et tw=80 : */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsDNSService2.h"
   8 #include "nsIDNSRecord.h"
   9 #include "nsIDNSListener.h"
  10 #include "nsIDNSByTypeRecord.h"
  11 #include "nsICancelable.h"
  12 #include "nsIPrefBranch.h"
  13 #include "nsIOService.h"
  14 #include "nsIXPConnect.h"
  15 #include "nsProxyRelease.h"
  16 #include "nsReadableUtils.h"
  17 #include "nsString.h"
  18 #include "nsCRT.h"
  19 #include "nsNetCID.h"
  20 #include "nsError.h"
  21 #include "nsDNSPrefetch.h"
  22 #include "nsThreadUtils.h"
  23 #include "nsIProtocolProxyService.h"
  24 #include "nsIObliviousHttp.h"
  25 #include "prsystem.h"
  26 #include "prnetdb.h"
  27 #include "prmon.h"
  28 #include "prio.h"
  29 #include "nsCharSeparatedTokenizer.h"
  30 #include "nsNetAddr.h"
  31 #include "nsProxyRelease.h"
  32 #include "nsQueryObject.h"
  33 #include "nsIObserverService.h"
  34 #include "nsINetworkLinkService.h"
  35 #include "DNSAdditionalInfo.h"
  36 #include "TRRService.h"
  37
  38 #include "mozilla/Attributes.h"
  39 #include "mozilla/ClearOnShutdown.h"
  40 #include "mozilla/net/NeckoCommon.h"
  41 #include "mozilla/net/ChildDNSService.h"
  42 #include "mozilla/net/DNSListenerProxy.h"
  43 #include "mozilla/Services.h"
  44 #include "mozilla/StaticPrefs_network.h"
  45 #include "mozilla/StaticPtr.h"
  46 #include "mozilla/SyncRunnable.h"
  47 #include "mozilla/TextUtils.h"
  48 #include "mozilla/Utf8.h"
  49
  50 using namespace mozilla;
  51 using namespace mozilla::net;
  52
  53 static const char kPrefDnsCacheEntries[] = "network.dnsCacheEntries";
  54 static const char kPrefDnsCacheExpiration[] = "network.dnsCacheExpiration";
  55 static const char kPrefDnsCacheGrace[] =
  56     "network.dnsCacheExpirationGracePeriod";
  57 static const char kPrefIPv4OnlyDomains[] = "network.dns.ipv4OnlyDomains";
  58 static const char kPrefBlockDotOnion[] = "network.dns.blockDotOnion";
  59 static const char kPrefDnsLocalDomains[] = "network.dns.localDomains";
  60 static const char kPrefDnsForceResolve[] = "network.dns.forceResolve";
  61 static const char kPrefDnsOfflineLocalhost[] = "network.dns.offline-localhost";
  62 static const char kPrefDnsNotifyResolution[] = "network.dns.notifyResolution";
  63
  64 //-----------------------------------------------------------------------------
  65
  66 class nsDNSRecord : public nsIDNSAddrRecord {
  67  public:
  68   NS_DECL_THREADSAFE_ISUPPORTS
  69   NS_DECL_NSIDNSRECORD
  70   NS_DECL_NSIDNSADDRRECORD
  71
  72   explicit nsDNSRecord(nsHostRecord* hostRecord) {
  73     mHostRecord = do_QueryObject(hostRecord);
  74   }
  75
  76  private:
  77   virtual ~nsDNSRecord() = default;
  78
  79   RefPtr<AddrHostRecord> mHostRecord;
  80   // Since mIter is holding a weak reference to the NetAddr array we must
  81   // make sure it is not released. So we also keep a RefPtr to the AddrInfo
  82   // which is immutable.
  83   RefPtr<AddrInfo> mAddrInfo;
  84   nsTArray<NetAddr>::const_iterator mIter;
  85   const NetAddr* iter() {
  86     if (!mIter.GetArray()) {
  87       return nullptr;
  88     }
  89     if (mIter.GetArray()->end() == mIter) {
  90       return nullptr;
  91     }
  92     return &*mIter;
  93   }
  94
  95   int mIterGenCnt = -1;  // the generation count of
  96                          // mHostRecord->addr_info when we
  97                          // start iterating
  98   bool mDone = false;
  99 };
 100
 101 NS_IMPL_ISUPPORTS(nsDNSRecord, nsIDNSRecord, nsIDNSAddrRecord)
 102
 103 NS_IMETHODIMP
 104 nsDNSRecord::GetCanonicalName(nsACString& result) {
 105   // this method should only be called if we have a CNAME
 106   NS_ENSURE_TRUE(mHostRecord->flags & nsHostResolver::RES_CANON_NAME,
 107                  NS_ERROR_NOT_AVAILABLE);
 108
 109   MutexAutoLock lock(mHostRecord->addr_info_lock);
 110
 111   // if the record is for an IP address literal, then the canonical
 112   // host name is the IP address literal.
 113   if (!mHostRecord->addr_info) {
 114     result = mHostRecord->host;
 115     return NS_OK;
 116   }
 117
 118   if (mHostRecord->addr_info->CanonicalHostname().IsEmpty()) {
 119     result = mHostRecord->addr_info->Hostname();
 120   } else {
 121     result = mHostRecord->addr_info->CanonicalHostname();
 122   }
 123   return NS_OK;
 124 }
 125
 126 NS_IMETHODIMP
 127 nsDNSRecord::IsTRR(bool* retval) {
 128   MutexAutoLock lock(mHostRecord->addr_info_lock);
 129   if (mHostRecord->addr_info) {
 130     *retval = mHostRecord->addr_info->IsTRR();
 131   } else {
 132     *retval = false;
 133   }
 134   return NS_OK;
 135 }
 136
 137 NS_IMETHODIMP
 138 nsDNSRecord::ResolvedInSocketProcess(bool* retval) {
 139   *retval = false;
 140   return NS_OK;
 141 }
 142
 143 NS_IMETHODIMP
 144 nsDNSRecord::GetTrrFetchDuration(double* aTime) {
 145   MutexAutoLock lock(mHostRecord->addr_info_lock);
 146   if (mHostRecord->addr_info && mHostRecord->addr_info->IsTRR()) {
 147     *aTime = mHostRecord->addr_info->GetTrrFetchDuration();
 148   } else {
 149     *aTime = 0;
 150   }
 151   return NS_OK;
 152 }
 153
 154 NS_IMETHODIMP
 155 nsDNSRecord::GetTrrFetchDurationNetworkOnly(double* aTime) {
 156   MutexAutoLock lock(mHostRecord->addr_info_lock);
 157   if (mHostRecord->addr_info && mHostRecord->addr_info->IsTRR()) {
 158     *aTime = mHostRecord->addr_info->GetTrrFetchDurationNetworkOnly();
 159   } else {
 160     *aTime = 0;
 161   }
 162   return NS_OK;
 163 }
 164
 165 NS_IMETHODIMP
 166 nsDNSRecord::GetNextAddr(uint16_t port, NetAddr* addr) {
 167   if (mDone) {
 168     return NS_ERROR_NOT_AVAILABLE;
 169   }
 170
 171   mHostRecord->addr_info_lock.Lock();
 172   if (mHostRecord->addr_info) {
 173     if (mIterGenCnt != mHostRecord->addr_info_gencnt) {
 174       // mHostRecord->addr_info has changed, restart the iteration.
 175       mIter = nsTArray<NetAddr>::const_iterator();
 176       mIterGenCnt = mHostRecord->addr_info_gencnt;
 177       // Make sure to hold a RefPtr to the AddrInfo so we can iterate through
 178       // the NetAddr array.
 179       mAddrInfo = mHostRecord->addr_info;
 180     }
 181
 182     bool startedFresh = !iter();
 183
 184     do {
 185       if (!iter()) {
 186         mIter = mAddrInfo->Addresses().begin();
 187       } else {
 188         mIter++;
 189       }
 190     } while (iter() && mHostRecord->Blocklisted(iter()));
 191
 192     if (!iter() && startedFresh) {
 193       // If everything was blocklisted we want to reset the blocklist (and
 194       // likely relearn it) and return the first address. That is better
 195       // than nothing.
 196       mHostRecord->ResetBlocklist();
 197       mIter = mAddrInfo->Addresses().begin();
 198     }
 199
 200     if (iter()) {
 201       *addr = *mIter;
 202     }
 203
 204     mHostRecord->addr_info_lock.Unlock();
 205
 206     if (!iter()) {
 207       mDone = true;
 208       mIter = nsTArray<NetAddr>::const_iterator();
 209       mAddrInfo = nullptr;
 210       mIterGenCnt = -1;
 211       return NS_ERROR_NOT_AVAILABLE;
 212     }
 213   } else {
 214     mHostRecord->addr_info_lock.Unlock();
 215
 216     if (!mHostRecord->addr) {
 217       // Both mHostRecord->addr_info and mHostRecord->addr are null.
 218       // This can happen if mHostRecord->addr_info expired and the
 219       // attempt to reresolve it failed.
 220       return NS_ERROR_NOT_AVAILABLE;
 221     }
 222     memcpy(addr, mHostRecord->addr.get(), sizeof(NetAddr));
 223     mDone = true;
 224   }
 225
 226   // set given port
 227   port = htons(port);
 228   if (addr->raw.family == AF_INET) {
 229     addr->inet.port = port;
 230   } else if (addr->raw.family == AF_INET6) {
 231     addr->inet6.port = port;
 232   }
 233
 234   return NS_OK;
 235 }
 236
 237 NS_IMETHODIMP
 238 nsDNSRecord::GetAddresses(nsTArray<NetAddr>& aAddressArray) {
 239   if (mDone) {
 240     return NS_ERROR_NOT_AVAILABLE;
 241   }
 242
 243   mHostRecord->addr_info_lock.Lock();
 244   if (mHostRecord->addr_info) {
 245     for (const auto& address : mHostRecord->addr_info->Addresses()) {
 246       if (mHostRecord->Blocklisted(&address)) {
 247         continue;
 248       }
 249       NetAddr* addr = aAddressArray.AppendElement(address);
 250       if (addr->raw.family == AF_INET) {
 251         addr->inet.port = 0;
 252       } else if (addr->raw.family == AF_INET6) {
 253         addr->inet6.port = 0;
 254       }
 255     }
 256     mHostRecord->addr_info_lock.Unlock();
 257   } else {
 258     mHostRecord->addr_info_lock.Unlock();
 259
 260     if (!mHostRecord->addr) {
 261       return NS_ERROR_NOT_AVAILABLE;
 262     }
 263     NetAddr* addr = aAddressArray.AppendElement(NetAddr());
 264     memcpy(addr, mHostRecord->addr.get(), sizeof(NetAddr));
 265     if (addr->raw.family == AF_INET) {
 266       addr->inet.port = 0;
 267     } else if (addr->raw.family == AF_INET6) {
 268       addr->inet6.port = 0;
 269     }
 270   }
 271   return NS_OK;
 272 }
 273
 274 NS_IMETHODIMP
 275 nsDNSRecord::GetScriptableNextAddr(uint16_t port, nsINetAddr** result) {
 276   NetAddr addr;
 277   nsresult rv = GetNextAddr(port, &addr);
 278   if (NS_FAILED(rv)) {
 279     return rv;
 280   }
 281
 282   RefPtr<nsNetAddr> netaddr = new nsNetAddr(&addr);
 283   netaddr.forget(result);
 284
 285   return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 nsDNSRecord::GetNextAddrAsString(nsACString& result) {
 290   NetAddr addr;
 291   nsresult rv = GetNextAddr(0, &addr);
 292   if (NS_FAILED(rv)) {
 293     return rv;
 294   }
 295
 296   char buf[kIPv6CStrBufSize];
 297   if (addr.ToStringBuffer(buf, sizeof(buf))) {
 298     result.Assign(buf);
 299     return NS_OK;
 300   }
 301   NS_ERROR("NetAddrToString failed unexpectedly");
 302   return NS_ERROR_FAILURE;  // conversion failed for some reason
 303 }
 304
 305 NS_IMETHODIMP
 306 nsDNSRecord::HasMore(bool* result) {
 307   if (mDone) {
 308     *result = false;
 309     return NS_OK;
 310   }
 311
 312   nsTArray<NetAddr>::const_iterator iterCopy = mIter;
 313   int iterGenCntCopy = mIterGenCnt;
 314
 315   NetAddr addr;
 316   *result = NS_SUCCEEDED(GetNextAddr(0, &addr));
 317
 318   mIter = iterCopy;
 319   mIterGenCnt = iterGenCntCopy;
 320   mDone = false;
 321
 322   return NS_OK;
 323 }
 324
 325 NS_IMETHODIMP
 326 nsDNSRecord::Rewind() {
 327   mIter = nsTArray<NetAddr>::const_iterator();
 328   mIterGenCnt = -1;
 329   mDone = false;
 330   return NS_OK;
 331 }
 332
 333 NS_IMETHODIMP
 334 nsDNSRecord::ReportUnusable(uint16_t aPort) {
 335   // right now we don't use the port in the blocklist
 336
 337   MutexAutoLock lock(mHostRecord->addr_info_lock);
 338
 339   // Check that we are using a real addr_info (as opposed to a single
 340   // constant address), and that the generation count is valid. Otherwise,
 341   // ignore the report.
 342
 343   if (mHostRecord->addr_info && mIterGenCnt == mHostRecord->addr_info_gencnt &&
 344       iter()) {
 345     mHostRecord->ReportUnusable(iter());
 346   }
 347
 348   return NS_OK;
 349 }
 350
 351 NS_IMETHODIMP
 352 nsDNSRecord::GetEffectiveTRRMode(nsIRequest::TRRMode* aMode) {
 353   *aMode = mHostRecord->EffectiveTRRMode();
 354   return NS_OK;
 355 }
 356
 357 NS_IMETHODIMP nsDNSRecord::GetTrrSkipReason(
 358     nsITRRSkipReason::value* aTrrSkipReason) {
 359   *aTrrSkipReason = mHostRecord->TrrSkipReason();
 360   return NS_OK;
 361 }
 362
 363 NS_IMETHODIMP
 364 nsDNSRecord::GetTtl(uint32_t* aTtl) { return mHostRecord->GetTtl(aTtl); }
 365
 366 class nsDNSByTypeRecord : public nsIDNSByTypeRecord,
 367                           public nsIDNSTXTRecord,
 368                           public nsIDNSHTTPSSVCRecord {
 369  public:
 370   NS_DECL_THREADSAFE_ISUPPORTS
 371   NS_DECL_NSIDNSRECORD
 372   NS_DECL_NSIDNSBYTYPERECORD
 373   NS_DECL_NSIDNSTXTRECORD
 374   NS_DECL_NSIDNSHTTPSSVCRECORD
 375
 376   explicit nsDNSByTypeRecord(nsHostRecord* hostRecord) {
 377     mHostRecord = do_QueryObject(hostRecord);
 378   }
 379
 380  private:
 381   virtual ~nsDNSByTypeRecord() = default;
 382   RefPtr<TypeHostRecord> mHostRecord;
 383 };
 384
 385 NS_IMPL_ISUPPORTS(nsDNSByTypeRecord, nsIDNSRecord, nsIDNSByTypeRecord,
 386                   nsIDNSTXTRecord, nsIDNSHTTPSSVCRecord)
 387
 388 NS_IMETHODIMP
 389 nsDNSByTypeRecord::GetType(uint32_t* aType) {
 390   *aType = mHostRecord->GetType();
 391   return NS_OK;
 392 }
 393
 394 NS_IMETHODIMP
 395 nsDNSByTypeRecord::GetRecords(CopyableTArray<nsCString>& aRecords) {
 396   // deep copy
 397   return mHostRecord->GetRecords(aRecords);
 398 }
 399
 400 NS_IMETHODIMP
 401 nsDNSByTypeRecord::GetRecordsAsOneString(nsACString& aRecords) {
 402   // deep copy
 403   return mHostRecord->GetRecordsAsOneString(aRecords);
 404 }
 405
 406 NS_IMETHODIMP
 407 nsDNSByTypeRecord::GetRecords(nsTArray<RefPtr<nsISVCBRecord>>& aRecords) {
 408   return mHostRecord->GetRecords(aRecords);
 409 }
 410
 411 NS_IMETHODIMP
 412 nsDNSByTypeRecord::GetServiceModeRecord(bool aNoHttp2, bool aNoHttp3,
 413                                         nsISVCBRecord** aRecord) {
 414   return mHostRecord->GetServiceModeRecord(aNoHttp2, aNoHttp3, aRecord);
 415 }
 416
 417 NS_IMETHODIMP
 418 nsDNSByTypeRecord::GetAllRecordsWithEchConfig(
 419     bool aNoHttp2, bool aNoHttp3, bool* aAllRecordsHaveEchConfig,
 420     bool* aAllRecordsInH3ExcludedList,
 421     nsTArray<RefPtr<nsISVCBRecord>>& aResult) {
 422   return mHostRecord->GetAllRecordsWithEchConfig(
 423       aNoHttp2, aNoHttp3, aAllRecordsHaveEchConfig, aAllRecordsInH3ExcludedList,
 424       aResult);
 425 }
 426
 427 NS_IMETHODIMP
 428 nsDNSByTypeRecord::GetHasIPAddresses(bool* aResult) {
 429   return mHostRecord->GetHasIPAddresses(aResult);
 430 }
 431
 432 NS_IMETHODIMP
 433 nsDNSByTypeRecord::GetAllRecordsExcluded(bool* aResult) {
 434   return mHostRecord->GetAllRecordsExcluded(aResult);
 435 }
 436
 437 NS_IMETHODIMP
 438 nsDNSByTypeRecord::GetResults(mozilla::net::TypeRecordResultType* aResults) {
 439   *aResults = mHostRecord->GetResults();
 440   return NS_OK;
 441 }
 442
 443 NS_IMETHODIMP
 444 nsDNSByTypeRecord::GetTtl(uint32_t* aTtl) { return mHostRecord->GetTtl(aTtl); }
 445
 446 //-----------------------------------------------------------------------------
 447
 448 class nsDNSAsyncRequest final : public nsResolveHostCallback,
 449                                 public nsICancelable {
 450  public:
 451   NS_DECL_THREADSAFE_ISUPPORTS
 452   NS_DECL_NSICANCELABLE
 453
 454   nsDNSAsyncRequest(nsHostResolver* res, const nsACString& host,
 455                     const nsACString& trrServer, uint16_t type,
 456                     const OriginAttributes& attrs, nsIDNSListener* listener,
 457                     nsIDNSService::DNSFlags flags, uint16_t af)
 458       : mResolver(res),
 459         mHost(host),
 460         mTrrServer(trrServer),
 461         mType(type),
 462         mOriginAttributes(attrs),
 463         mListener(listener),
 464         mFlags(flags),
 465         mAF(af) {}
 466
 467   void OnResolveHostComplete(nsHostResolver*, nsHostRecord*, nsresult) override;
 468   // Returns TRUE if the DNS listener arg is the same as the member listener
 469   // Used in Cancellations to remove DNS requests associated with a
 470   // particular hostname and nsIDNSListener
 471   bool EqualsAsyncListener(nsIDNSListener* aListener) override;
 472
 473   size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const override;
 474
 475   RefPtr<nsHostResolver> mResolver;
 476   nsCString mHost;       // hostname we're resolving
 477   nsCString mTrrServer;  // A trr server to be used.
 478   uint16_t mType = 0;
 479   const OriginAttributes
 480       mOriginAttributes;  // The originAttributes for this resolving
 481   nsCOMPtr<nsIDNSListener> mListener;
 482   nsIDNSService::DNSFlags mFlags = nsIDNSService::RESOLVE_DEFAULT_FLAGS;
 483   uint16_t mAF = 0;
 484
 485  private:
 486   virtual ~nsDNSAsyncRequest() = default;
 487 };
 488
 489 NS_IMPL_ISUPPORTS(nsDNSAsyncRequest, nsICancelable)
 490
 491 void nsDNSAsyncRequest::OnResolveHostComplete(nsHostResolver* resolver,
 492                                               nsHostRecord* hostRecord,
 493                                               nsresult status) {
 494   // need to have an owning ref when we issue the callback to enable
 495   // the caller to be able to addref/release multiple times without
 496   // destroying the record prematurely.
 497   nsCOMPtr<nsIDNSRecord> rec;
 498   if (NS_SUCCEEDED(status) ||
 499       mFlags & nsIDNSService::RESOLVE_WANT_RECORD_ON_ERROR) {
 500     MOZ_ASSERT(hostRecord, "no host record");
 501     if (hostRecord->type != nsDNSService::RESOLVE_TYPE_DEFAULT) {
 502       rec = new nsDNSByTypeRecord(hostRecord);
 503     } else {
 504       rec = new nsDNSRecord(hostRecord);
 505     }
 506   }
 507
 508   mListener->OnLookupComplete(this, rec, status);
 509   mListener = nullptr;
 510 }
 511
 512 bool nsDNSAsyncRequest::EqualsAsyncListener(nsIDNSListener* aListener) {
 513   uintptr_t originalListenerAddr = reinterpret_cast<uintptr_t>(mListener.get());
 514   RefPtr<DNSListenerProxy> wrapper = do_QueryObject(mListener);
 515   if (wrapper) {
 516     originalListenerAddr = wrapper->GetOriginalListenerAddress();
 517   }
 518
 519   uintptr_t listenerAddr = reinterpret_cast<uintptr_t>(aListener);
 520   return (listenerAddr == originalListenerAddr);
 521 }
 522
 523 size_t nsDNSAsyncRequest::SizeOfIncludingThis(MallocSizeOf mallocSizeOf) const {
 524   size_t n = mallocSizeOf(this);
 525
 526   // The following fields aren't measured.
 527   // - mHost, because it's a non-owning pointer
 528   // - mResolver, because it's a non-owning pointer
 529   // - mListener, because it's a non-owning pointer
 530
 531   return n;
 532 }
 533
 534 NS_IMETHODIMP
 535 nsDNSAsyncRequest::Cancel(nsresult reason) {
 536   NS_ENSURE_ARG(NS_FAILED(reason));
 537   MOZ_DIAGNOSTIC_ASSERT(mResolver, "mResolver should not be null");
 538   mResolver->DetachCallback(mHost, mTrrServer, mType, mOriginAttributes, mFlags,
 539                             mAF, this, reason);
 540   return NS_OK;
 541 }
 542
 543 //-----------------------------------------------------------------------------
 544
 545 class nsDNSSyncRequest : public nsResolveHostCallback {
 546   NS_DECL_THREADSAFE_ISUPPORTS
 547  public:
 548   explicit nsDNSSyncRequest(PRMonitor* mon) : mMonitor(mon) {}
 549
 550   void OnResolveHostComplete(nsHostResolver*, nsHostRecord*, nsresult) override;
 551   bool EqualsAsyncListener(nsIDNSListener* aListener) override;
 552   size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const override;
 553
 554   bool mDone = false;
 555   nsresult mStatus = NS_OK;
 556   RefPtr<nsHostRecord> mHostRecord;
 557
 558  private:
 559   virtual ~nsDNSSyncRequest() = default;
 560
 561   PRMonitor* mMonitor = nullptr;
 562 };
 563
 564 NS_IMPL_ISUPPORTS0(nsDNSSyncRequest)
 565
 566 void nsDNSSyncRequest::OnResolveHostComplete(nsHostResolver* resolver,
 567                                              nsHostRecord* hostRecord,
 568                                              nsresult status) {
 569   // store results, and wake up nsDNSService::Resolve to process results.
 570   PR_EnterMonitor(mMonitor);
 571   mDone = true;
 572   mStatus = status;
 573   mHostRecord = hostRecord;
 574   PR_Notify(mMonitor);
 575   PR_ExitMonitor(mMonitor);
 576 }
 577
 578 bool nsDNSSyncRequest::EqualsAsyncListener(nsIDNSListener* aListener) {
 579   // Sync request: no listener to compare
 580   return false;
 581 }
 582
 583 size_t nsDNSSyncRequest::SizeOfIncludingThis(MallocSizeOf mallocSizeOf) const {
 584   size_t n = mallocSizeOf(this);
 585
 586   // The following fields aren't measured.
 587   // - mHostRecord, because it's a non-owning pointer
 588
 589   // Measurement of the following members may be added later if DMD finds it
 590   // is worthwhile:
 591   // - mMonitor
 592
 593   return n;
 594 }
 595
 596 class NotifyDNSResolution : public Runnable {
 597  public:
 598   explicit NotifyDNSResolution(const nsACString& aHostname)
 599       : mozilla::Runnable("NotifyDNSResolution"), mHostname(aHostname) {}
 600
 601   NS_IMETHOD Run() override {
 602     MOZ_ASSERT(NS_IsMainThread());
 603     nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
 604     if (obs) {
 605       obs->NotifyObservers(nullptr, "dns-resolution-request",
 606                            NS_ConvertUTF8toUTF16(mHostname).get());
 607     }
 608     return NS_OK;
 609   }
 610
 611  private:
 612   nsCString mHostname;
 613 };
 614
 615 //-----------------------------------------------------------------------------
 616
 617 static StaticRefPtr<DNSServiceWrapper> gDNSServiceWrapper;
 618
 619 NS_IMPL_ISUPPORTS(DNSServiceWrapper, nsIDNSService, nsPIDNSService)
 620
 621 // static
 622 already_AddRefed<nsIDNSService> DNSServiceWrapper::GetSingleton() {
 623   if (!gDNSServiceWrapper) {
 624     gDNSServiceWrapper = new DNSServiceWrapper();
 625     gDNSServiceWrapper->mDNSServiceInUse = ChildDNSService::GetSingleton();
 626     if (gDNSServiceWrapper->mDNSServiceInUse) {
 627       ClearOnShutdown(&gDNSServiceWrapper);
 628       nsDNSPrefetch::Initialize(gDNSServiceWrapper);
 629     } else {
 630       gDNSServiceWrapper = nullptr;
 631     }
 632   }
 633
 634   return do_AddRef(gDNSServiceWrapper);
 635 }
 636
 637 // static
 638 void DNSServiceWrapper::SwitchToBackupDNSService() {
 639   if (!gDNSServiceWrapper) {
 640     return;
 641   }
 642
 643   gDNSServiceWrapper->mBackupDNSService = nsDNSService::GetSingleton();
 644
 645   MutexAutoLock lock(gDNSServiceWrapper->mLock);
 646   gDNSServiceWrapper->mBackupDNSService.swap(
 647       gDNSServiceWrapper->mDNSServiceInUse);
 648 }
 649
 650 nsIDNSService* DNSServiceWrapper::DNSService() {
 651   MOZ_ASSERT(XRE_IsParentProcess());
 652
 653   MutexAutoLock lock(mLock);
 654   return mDNSServiceInUse.get();
 655 }
 656
 657 nsPIDNSService* DNSServiceWrapper::PIDNSService() {
 658   MOZ_ASSERT(XRE_IsParentProcess());
 659
 660   nsCOMPtr<nsPIDNSService> service = do_QueryInterface(DNSService());
 661   return service.get();
 662 }
 663
 664 //-----------------------------------------------------------------------------
 665 NS_IMPL_ISUPPORTS_INHERITED(nsDNSService, DNSServiceBase, nsIDNSService,
 666                             nsPIDNSService, nsIMemoryReporter)
 667
 668 /******************************************************************************
 669  * nsDNSService impl:
 670  * singleton instance ctor/dtor methods
 671  ******************************************************************************/
 672 static StaticRefPtr<nsDNSService> gDNSService;
 673 static Atomic<bool> gInited(false);
 674
 675 already_AddRefed<nsIDNSService> GetOrInitDNSService() {
 676   if (gInited) {
 677     return nsDNSService::GetXPCOMSingleton();
 678   }
 679
 680   nsCOMPtr<nsIDNSService> dns = nullptr;
 681   auto initTask = [&dns]() { dns = do_GetService(NS_DNSSERVICE_CID); };
 682   if (!NS_IsMainThread()) {
 683     // Forward to the main thread synchronously.
 684     RefPtr<nsIThread> mainThread = do_GetMainThread();
 685     if (!mainThread) {
 686       return nullptr;
 687     }
 688
 689     SyncRunnable::DispatchToThread(
 690         mainThread, NS_NewRunnableFunction("GetOrInitDNSService", initTask));
 691   } else {
 692     initTask();
 693   }
 694
 695   return dns.forget();
 696 }
 697
 698 already_AddRefed<nsIDNSService> nsDNSService::GetXPCOMSingleton() {
 699   auto getDNSHelper = []() -> already_AddRefed<nsIDNSService> {
 700     if (nsIOService::UseSocketProcess()) {
 701       if (XRE_IsSocketProcess()) {
 702         return GetSingleton();
 703       }
 704
 705       if (XRE_IsParentProcess()) {
 706         return DNSServiceWrapper::GetSingleton();
 707       }
 708
 709       if (XRE_IsContentProcess()) {
 710         return ChildDNSService::GetSingleton();
 711       }
 712
 713       return nullptr;
 714     }
 715
 716     if (XRE_IsParentProcess()) {
 717       return GetSingleton();
 718     }
 719
 720     if (XRE_IsContentProcess() || XRE_IsSocketProcess()) {
 721       return ChildDNSService::GetSingleton();
 722     }
 723
 724     return nullptr;
 725   };
 726
 727   if (gInited) {
 728     return getDNSHelper();
 729   }
 730
 731   nsCOMPtr<nsIDNSService> dns = getDNSHelper();
 732   if (dns) {
 733     gInited = true;
 734   }
 735   return dns.forget();
 736 }
 737
 738 already_AddRefed<nsDNSService> nsDNSService::GetSingleton() {
 739   MOZ_ASSERT_IF(nsIOService::UseSocketProcess(), XRE_IsSocketProcess());
 740   MOZ_ASSERT_IF(!nsIOService::UseSocketProcess(), XRE_IsParentProcess());
 741
 742   if (!gDNSService) {
 743     if (!NS_IsMainThread()) {
 744       return nullptr;
 745     }
 746     gDNSService = new nsDNSService();
 747     if (NS_SUCCEEDED(gDNSService->Init())) {
 748       ClearOnShutdown(&gDNSService);
 749     } else {
 750       gDNSService = nullptr;
 751     }
 752   }
 753
 754   return do_AddRef(gDNSService);
 755 }
 756
 757 void nsDNSService::ReadPrefs(const char* name) {
 758   DNSServiceBase::ReadPrefs(name);
 759
 760   bool tmpbool;
 761   uint32_t tmpint;
 762   mResolverPrefsUpdated = false;
 763
 764   // resolver-specific prefs first
 765   if (!name || !strcmp(name, kPrefDnsCacheEntries)) {
 766     if (NS_SUCCEEDED(Preferences::GetUint(kPrefDnsCacheEntries, &tmpint))) {
 767       if (!name || (tmpint != mResCacheEntries)) {
 768         mResCacheEntries = tmpint;
 769         mResolverPrefsUpdated = true;
 770       }
 771     }
 772   }
 773   if (!name || !strcmp(name, kPrefDnsCacheExpiration)) {
 774     if (NS_SUCCEEDED(Preferences::GetUint(kPrefDnsCacheExpiration, &tmpint))) {
 775       if (!name || (tmpint != mResCacheExpiration)) {
 776         mResCacheExpiration = tmpint;
 777         mResolverPrefsUpdated = true;
 778       }
 779     }
 780   }
 781   if (!name || !strcmp(name, kPrefDnsCacheGrace)) {
 782     if (NS_SUCCEEDED(Preferences::GetUint(kPrefDnsCacheGrace, &tmpint))) {
 783       if (!name || (tmpint != mResCacheGrace)) {
 784         mResCacheGrace = tmpint;
 785         mResolverPrefsUpdated = true;
 786       }
 787     }
 788   }
 789
 790   // DNSservice prefs
 791   if (!name || !strcmp(name, kPrefDnsOfflineLocalhost)) {
 792     if (NS_SUCCEEDED(
 793             Preferences::GetBool(kPrefDnsOfflineLocalhost, &tmpbool))) {
 794       mOfflineLocalhost = tmpbool;
 795     }
 796   }
 797   if (!name || !strcmp(name, kPrefBlockDotOnion)) {
 798     if (NS_SUCCEEDED(Preferences::GetBool(kPrefBlockDotOnion, &tmpbool))) {
 799       mBlockDotOnion = tmpbool;
 800     }
 801   }
 802   if (!name || !strcmp(name, kPrefDnsNotifyResolution)) {
 803     if (NS_SUCCEEDED(
 804             Preferences::GetBool(kPrefDnsNotifyResolution, &tmpbool))) {
 805       mNotifyResolution = tmpbool;
 806     }
 807   }
 808   if (!name || !strcmp(name, kPrefIPv4OnlyDomains)) {
 809     Preferences::GetCString(kPrefIPv4OnlyDomains, mIPv4OnlyDomains);
 810   }
 811   if (!name || !strcmp(name, kPrefDnsLocalDomains)) {
 812     nsCString localDomains;
 813     Preferences::GetCString(kPrefDnsLocalDomains, localDomains);
 814     MutexAutoLock lock(mLock);
 815     mLocalDomains.Clear();
 816     for (const auto& token :
 817          nsCCharSeparatedTokenizerTemplate<NS_IsAsciiWhitespace,
 818                                            nsTokenizerFlags::SeparatorOptional>(
 819              localDomains, ',')
 820              .ToRange()) {
 821       mLocalDomains.Insert(token);
 822     }
 823   }
 824   if (!name || !strcmp(name, kPrefDnsForceResolve)) {
 825     Preferences::GetCString(kPrefDnsForceResolve, mForceResolve);
 826     mForceResolveOn = !mForceResolve.IsEmpty();
 827   }
 828 }
 829
 830 NS_IMETHODIMP
 831 nsDNSService::Init() {
 832   MOZ_ASSERT(!mResolver);
 833   MOZ_ASSERT(NS_IsMainThread());
 834
 835   ReadPrefs(nullptr);
 836
 837   nsCOMPtr<nsIObserverService> observerService =
 838       mozilla::services::GetObserverService();
 839   if (observerService) {
 840     observerService->AddObserver(this, "last-pb-context-exited", false);
 841     observerService->AddObserver(this, NS_NETWORK_LINK_TOPIC, false);
 842     observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
 843   }
 844
 845   RefPtr<nsHostResolver> res;
 846   nsresult rv = nsHostResolver::Create(mResCacheEntries, mResCacheExpiration,
 847                                        mResCacheGrace, getter_AddRefs(res));
 848   if (NS_SUCCEEDED(rv)) {
 849     // now, set all of our member variables while holding the lock
 850     MutexAutoLock lock(mLock);
 851     mResolver = res;
 852   }
 853
 854   nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
 855   if (prefs) {
 856     // register as prefs observer
 857     prefs->AddObserver(kPrefDnsCacheEntries, this, false);
 858     prefs->AddObserver(kPrefDnsCacheExpiration, this, false);
 859     prefs->AddObserver(kPrefDnsCacheGrace, this, false);
 860     prefs->AddObserver(kPrefIPv4OnlyDomains, this, false);
 861     prefs->AddObserver(kPrefDnsLocalDomains, this, false);
 862     prefs->AddObserver(kPrefDnsForceResolve, this, false);
 863     prefs->AddObserver(kPrefDnsOfflineLocalhost, this, false);
 864     prefs->AddObserver(kPrefBlockDotOnion, this, false);
 865     prefs->AddObserver(kPrefDnsNotifyResolution, this, false);
 866     AddPrefObserver(prefs);
 867   }
 868
 869   nsDNSPrefetch::Initialize(this);
 870
 871   RegisterWeakMemoryReporter(this);
 872
 873   nsCOMPtr<nsIObliviousHttpService> ohttpService(
 874       do_GetService("@mozilla.org/network/oblivious-http-service;1"));
 875
 876   mTrrService = new TRRService();
 877   if (NS_FAILED(mTrrService->Init())) {
 878     mTrrService = nullptr;
 879   }
 880
 881   nsCOMPtr<nsIIDNService> idn = do_GetService(NS_IDNSERVICE_CONTRACTID);
 882   mIDN = idn;
 883
 884   return NS_OK;
 885 }
 886
 887 NS_IMETHODIMP
 888 nsDNSService::Shutdown() {
 889   UnregisterWeakMemoryReporter(this);
 890
 891   RefPtr<nsHostResolver> res;
 892   {
 893     MutexAutoLock lock(mLock);
 894     res = std::move(mResolver);
 895   }
 896   if (res) {
 897     // Shutdown outside lock.
 898     res->Shutdown();
 899   }
 900
 901   nsCOMPtr<nsIObserverService> observerService =
 902       mozilla::services::GetObserverService();
 903   if (observerService) {
 904     observerService->RemoveObserver(this, NS_NETWORK_LINK_TOPIC);
 905     observerService->RemoveObserver(this, "last-pb-context-exited");
 906     observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
 907   }
 908
 909   return NS_OK;
 910 }
 911
 912 bool nsDNSService::GetOffline() const {
 913   bool offline = false;
 914   nsCOMPtr<nsIIOService> io = do_GetService(NS_IOSERVICE_CONTRACTID);
 915   if (io) {
 916     io->GetOffline(&offline);
 917   }
 918   return offline;
 919 }
 920
 921 NS_IMETHODIMP
 922 nsDNSService::GetPrefetchEnabled(bool* outVal) {
 923   MutexAutoLock lock(mLock);
 924   *outVal = !mDisablePrefetch;
 925   return NS_OK;
 926 }
 927
 928 NS_IMETHODIMP
 929 nsDNSService::SetPrefetchEnabled(bool inVal) {
 930   MutexAutoLock lock(mLock);
 931   mDisablePrefetch = !inVal;
 932   return NS_OK;
 933 }
 934
 935 already_AddRefed<nsHostResolver> nsDNSService::GetResolverLocked() {
 936   MutexAutoLock lock(mLock);
 937   return do_AddRef(mResolver);
 938 }
 939
 940 nsresult nsDNSService::PreprocessHostname(bool aLocalDomain,
 941                                           const nsACString& aInput,
 942                                           nsIIDNService* aIDN,
 943                                           nsACString& aACE) {
 944   // Enforce RFC 7686
 945   if (mBlockDotOnion && StringEndsWith(aInput, ".onion"_ns)) {
 946     return NS_ERROR_UNKNOWN_HOST;
 947   }
 948
 949   if (aLocalDomain) {
 950     aACE.AssignLiteral("localhost");
 951     return NS_OK;
 952   }
 953
 954   if (mTrrService && mTrrService->MaybeBootstrap(aInput, aACE)) {
 955     return NS_OK;
 956   }
 957
 958   if (mForceResolveOn) {
 959     MutexAutoLock lock(mLock);
 960     if (!aInput.LowerCaseEqualsASCII("localhost") &&
 961         !aInput.LowerCaseEqualsASCII("127.0.0.1")) {
 962       aACE.Assign(mForceResolve);
 963       return NS_OK;
 964     }
 965   }
 966
 967   if (!aIDN || IsAscii(aInput)) {
 968     aACE = aInput;
 969     return NS_OK;
 970   }
 971
 972   if (!(IsUtf8(aInput) && NS_SUCCEEDED(aIDN->ConvertUTF8toACE(aInput, aACE)))) {
 973     return NS_ERROR_FAILURE;
 974   }
 975   return NS_OK;
 976 }
 977
 978 nsresult nsDNSService::AsyncResolveInternal(
 979     const nsACString& aHostname, uint16_t type, nsIDNSService::DNSFlags flags,
 980     nsIDNSAdditionalInfo* aInfo, nsIDNSListener* aListener,
 981     nsIEventTarget* target_, const OriginAttributes& aOriginAttributes,
 982     nsICancelable** result) {
 983   // grab reference to global host resolver and IDN service.  beware
 984   // simultaneous shutdown!!
 985   RefPtr<nsHostResolver> res;
 986   nsCOMPtr<nsIIDNService> idn;
 987   nsCOMPtr<nsIEventTarget> target = target_;
 988   nsCOMPtr<nsIDNSListener> listener = aListener;
 989   bool localDomain = false;
 990   {
 991     MutexAutoLock lock(mLock);
 992
 993     if (mDisablePrefetch && (flags & RESOLVE_SPECULATE)) {
 994       return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
 995     }
 996
 997     res = mResolver;
 998     idn = mIDN;
 999     localDomain = mLocalDomains.Contains(aHostname);
1000   }
1001
1002   if (mNotifyResolution) {
1003     NS_DispatchToMainThread(new NotifyDNSResolution(aHostname));
1004   }
1005
1006   if (!res) {
1007     return NS_ERROR_OFFLINE;
1008   }
1009
1010   if ((type != RESOLVE_TYPE_DEFAULT) && (type != RESOLVE_TYPE_TXT) &&
1011       (type != RESOLVE_TYPE_HTTPSSVC)) {
1012     return NS_ERROR_INVALID_ARG;
1013   }
1014
1015   if (DNSForbiddenByActiveProxy(aHostname, flags)) {
1016     // nsHostResolver returns NS_ERROR_UNKNOWN_HOST for lots of reasons.
1017     // We use a different error code to differentiate this failure and to make
1018     // it clear(er) where this error comes from.
1019     return NS_ERROR_UNKNOWN_PROXY_HOST;
1020   }
1021
1022   nsCString hostname;
1023   nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
1024   if (NS_FAILED(rv)) {
1025     return rv;
1026   }
1027
1028   if (GetOffline() &&
1029       (!mOfflineLocalhost || !hostname.LowerCaseEqualsASCII("localhost"))) {
1030     flags |= RESOLVE_OFFLINE;
1031   }
1032
1033   // make sure JS callers get notification on the main thread
1034   nsCOMPtr<nsIXPConnectWrappedJS> wrappedListener = do_QueryInterface(listener);
1035   if (wrappedListener && !target) {
1036     target = GetMainThreadSerialEventTarget();
1037   }
1038
1039   if (target) {
1040     listener = new DNSListenerProxy(listener, target);
1041   }
1042
1043   uint16_t af =
1044       (type != RESOLVE_TYPE_DEFAULT) ? 0 : GetAFForLookup(hostname, flags);
1045
1046   MOZ_ASSERT(listener);
1047   RefPtr<nsDNSAsyncRequest> req =
1048       new nsDNSAsyncRequest(res, hostname, DNSAdditionalInfo::URL(aInfo), type,
1049                             aOriginAttributes, listener, flags, af);
1050   if (!req) {
1051     return NS_ERROR_OUT_OF_MEMORY;
1052   }
1053
1054   rv = res->ResolveHost(req->mHost, DNSAdditionalInfo::URL(aInfo),
1055                         DNSAdditionalInfo::Port(aInfo), type,
1056                         req->mOriginAttributes, flags, af, req);
1057   req.forget(result);
1058   return rv;
1059 }
1060
1061 nsresult nsDNSService::CancelAsyncResolveInternal(
1062     const nsACString& aHostname, uint16_t aType, nsIDNSService::DNSFlags aFlags,
1063     nsIDNSAdditionalInfo* aInfo, nsIDNSListener* aListener, nsresult aReason,
1064     const OriginAttributes& aOriginAttributes) {
1065   // grab reference to global host resolver and IDN service.  beware
1066   // simultaneous shutdown!!
1067   RefPtr<nsHostResolver> res;
1068   nsCOMPtr<nsIIDNService> idn;
1069   bool localDomain = false;
1070   {
1071     MutexAutoLock lock(mLock);
1072
1073     if (mDisablePrefetch && (aFlags & RESOLVE_SPECULATE)) {
1074       return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
1075     }
1076
1077     res = mResolver;
1078     idn = mIDN;
1079     localDomain = mLocalDomains.Contains(aHostname);
1080   }
1081   if (!res) {
1082     return NS_ERROR_OFFLINE;
1083   }
1084
1085   nsCString hostname;
1086   nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
1087   if (NS_FAILED(rv)) {
1088     return rv;
1089   }
1090
1091   uint16_t af =
1092       (aType != RESOLVE_TYPE_DEFAULT) ? 0 : GetAFForLookup(hostname, aFlags);
1093
1094   res->CancelAsyncRequest(hostname, DNSAdditionalInfo::URL(aInfo), aType,
1095                           aOriginAttributes, aFlags, af, aListener, aReason);
1096   return NS_OK;
1097 }
1098
1099 NS_IMETHODIMP
1100 nsDNSService::AsyncResolve(const nsACString& aHostname,
1101                            nsIDNSService::ResolveType aType,
1102                            nsIDNSService::DNSFlags flags,
1103                            nsIDNSAdditionalInfo* aInfo,
1104                            nsIDNSListener* listener, nsIEventTarget* target_,
1105                            JS::Handle<JS::Value> aOriginAttributes,
1106                            JSContext* aCx, uint8_t aArgc,
1107                            nsICancelable** result) {
1108   OriginAttributes attrs;
1109
1110   if (aArgc == 1) {
1111     if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) {
1112       return NS_ERROR_INVALID_ARG;
1113     }
1114   }
1115
1116   return AsyncResolveInternal(aHostname, aType, flags, aInfo, listener, target_,
1117                               attrs, result);
1118 }
1119
1120 NS_IMETHODIMP
1121 nsDNSService::AsyncResolveNative(
1122     const nsACString& aHostname, nsIDNSService::ResolveType aType,
1123     nsIDNSService::DNSFlags flags, nsIDNSAdditionalInfo* aInfo,
1124     nsIDNSListener* aListener, nsIEventTarget* target_,
1125     const OriginAttributes& aOriginAttributes, nsICancelable** result) {
1126   return AsyncResolveInternal(aHostname, aType, flags, aInfo, aListener,
1127                               target_, aOriginAttributes, result);
1128 }
1129
1130 NS_IMETHODIMP
1131 nsDNSService::NewAdditionalInfo(const nsACString& aTrrURL, int32_t aPort,
1132                                 nsIDNSAdditionalInfo** aInfo) {
1133   RefPtr<DNSAdditionalInfo> res = new DNSAdditionalInfo(aTrrURL, aPort);
1134   res.forget(aInfo);
1135   return NS_OK;
1136 }
1137
1138 NS_IMETHODIMP
1139 nsDNSService::CancelAsyncResolve(const nsACString& aHostname,
1140                                  nsIDNSService::ResolveType aType,
1141                                  nsIDNSService::DNSFlags aFlags,
1142                                  nsIDNSAdditionalInfo* aInfo,
1143                                  nsIDNSListener* aListener, nsresult aReason,
1144                                  JS::Handle<JS::Value> aOriginAttributes,
1145                                  JSContext* aCx, uint8_t aArgc) {
1146   OriginAttributes attrs;
1147
1148   if (aArgc == 1) {
1149     if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) {
1150       return NS_ERROR_INVALID_ARG;
1151     }
1152   }
1153
1154   return CancelAsyncResolveInternal(aHostname, aType, aFlags, aInfo, aListener,
1155                                     aReason, attrs);
1156 }
1157
1158 NS_IMETHODIMP
1159 nsDNSService::CancelAsyncResolveNative(
1160     const nsACString& aHostname, nsIDNSService::ResolveType aType,
1161     nsIDNSService::DNSFlags aFlags, nsIDNSAdditionalInfo* aInfo,
1162     nsIDNSListener* aListener, nsresult aReason,
1163     const OriginAttributes& aOriginAttributes) {
1164   return CancelAsyncResolveInternal(aHostname, aType, aFlags, aInfo, aListener,
1165                                     aReason, aOriginAttributes);
1166 }
1167
1168 NS_IMETHODIMP
1169 nsDNSService::Resolve(const nsACString& aHostname,
1170                       nsIDNSService::DNSFlags flags,
1171                       JS::Handle<JS::Value> aOriginAttributes, JSContext* aCx,
1172                       uint8_t aArgc, nsIDNSRecord** result) {
1173   OriginAttributes attrs;
1174
1175   if (aArgc == 1) {
1176     if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) {
1177       return NS_ERROR_INVALID_ARG;
1178     }
1179   }
1180
1181   return ResolveNative(aHostname, flags, attrs, result);
1182 }
1183
1184 NS_IMETHODIMP
1185 nsDNSService::ResolveNative(const nsACString& aHostname,
1186                             nsIDNSService::DNSFlags flags,
1187                             const OriginAttributes& aOriginAttributes,
1188                             nsIDNSRecord** result) {
1189   // Synchronous resolution is not available on the main thread.
1190   if (NS_IsMainThread()) {
1191     return NS_ERROR_NOT_AVAILABLE;
1192   }
1193
1194   return ResolveInternal(aHostname, flags, aOriginAttributes, result);
1195 }
1196
1197 nsresult nsDNSService::DeprecatedSyncResolve(
1198     const nsACString& aHostname, nsIDNSService::DNSFlags flags,
1199     const OriginAttributes& aOriginAttributes, nsIDNSRecord** result) {
1200   return ResolveInternal(aHostname, flags, aOriginAttributes, result);
1201 }
1202
1203 nsresult nsDNSService::ResolveInternal(
1204     const nsACString& aHostname, nsIDNSService::DNSFlags flags,
1205     const OriginAttributes& aOriginAttributes, nsIDNSRecord** result) {
1206   // grab reference to global host resolver and IDN service.  beware
1207   // simultaneous shutdown!!
1208   RefPtr<nsHostResolver> res;
1209   nsCOMPtr<nsIIDNService> idn;
1210   bool localDomain = false;
1211   {
1212     MutexAutoLock lock(mLock);
1213     res = mResolver;
1214     idn = mIDN;
1215     localDomain = mLocalDomains.Contains(aHostname);
1216   }
1217
1218   if (mNotifyResolution) {
1219     NS_DispatchToMainThread(new NotifyDNSResolution(aHostname));
1220   }
1221
1222   NS_ENSURE_TRUE(res, NS_ERROR_OFFLINE);
1223
1224   nsCString hostname;
1225   nsresult rv = PreprocessHostname(localDomain, aHostname, idn, hostname);
1226   if (NS_FAILED(rv)) {
1227     return rv;
1228   }
1229
1230   if (GetOffline() &&
1231       (!mOfflineLocalhost || !hostname.LowerCaseEqualsASCII("localhost"))) {
1232     flags |= RESOLVE_OFFLINE;
1233   }
1234
1235   if (DNSForbiddenByActiveProxy(aHostname, flags)) {
1236     return NS_ERROR_UNKNOWN_PROXY_HOST;
1237   }
1238
1239   //
1240   // sync resolve: since the host resolver only works asynchronously, we need
1241   // to use a mutex and a condvar to wait for the result.  however, since the
1242   // result may be in the resolvers cache, we might get called back recursively
1243   // on the same thread.  so, our mutex needs to be re-entrant.  in other words,
1244   // we need to use a monitor! ;-)
1245   //
1246
1247   PRMonitor* mon = PR_NewMonitor();
1248   if (!mon) {
1249     return NS_ERROR_OUT_OF_MEMORY;
1250   }
1251
1252   PR_EnterMonitor(mon);
1253   RefPtr<nsDNSSyncRequest> syncReq = new nsDNSSyncRequest(mon);
1254
1255   uint16_t af = GetAFForLookup(hostname, flags);
1256
1257   // TRR uses the main thread for the HTTPS channel to the DoH server.
1258   // If this were to block the main thread while waiting for TRR it would
1259   // likely cause a deadlock. Instead we intentionally choose to not use TRR
1260   // for this.
1261   if (NS_IsMainThread()) {
1262     flags |= RESOLVE_DISABLE_TRR;
1263   }
1264
1265   rv = res->ResolveHost(hostname, ""_ns, -1, RESOLVE_TYPE_DEFAULT,
1266                         aOriginAttributes, flags, af, syncReq);
1267   if (NS_SUCCEEDED(rv)) {
1268     // wait for result
1269     while (!syncReq->mDone) {
1270       PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
1271     }
1272
1273     if (NS_FAILED(syncReq->mStatus)) {
1274       rv = syncReq->mStatus;
1275     } else {
1276       NS_ASSERTION(syncReq->mHostRecord, "no host record");
1277       RefPtr<nsDNSRecord> rec = new nsDNSRecord(syncReq->mHostRecord);
1278       rec.forget(result);
1279     }
1280   }
1281
1282   PR_ExitMonitor(mon);
1283   PR_DestroyMonitor(mon);
1284   return rv;
1285 }
1286
1287 NS_IMETHODIMP
1288 nsDNSService::GetMyHostName(nsACString& result) {
1289   char name[100];
1290   if (PR_GetSystemInfo(PR_SI_HOSTNAME, name, sizeof(name)) == PR_SUCCESS) {
1291     result = name;
1292     return NS_OK;
1293   }
1294   return NS_ERROR_FAILURE;
1295 }
1296
1297 NS_IMETHODIMP
1298 nsDNSService::Observe(nsISupports* subject, const char* topic,
1299                       const char16_t* data) {
1300   bool flushCache = false;
1301   RefPtr<nsHostResolver> resolver = GetResolverLocked();
1302
1303   if (!strcmp(topic, NS_NETWORK_LINK_TOPIC)) {
1304     nsAutoCString converted = NS_ConvertUTF16toUTF8(data);
1305     if (!strcmp(converted.get(), NS_NETWORK_LINK_DATA_CHANGED)) {
1306       flushCache = true;
1307     }
1308   } else if (!strcmp(topic, "last-pb-context-exited")) {
1309     flushCache = true;
1310   } else if (!strcmp(topic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
1311     ReadPrefs(NS_ConvertUTF16toUTF8(data).get());
1312     NS_ENSURE_TRUE(resolver, NS_ERROR_NOT_INITIALIZED);
1313     if (mResolverPrefsUpdated && resolver) {
1314       resolver->SetCacheLimits(mResCacheEntries, mResCacheExpiration,
1315                                mResCacheGrace);
1316     }
1317   } else if (!strcmp(topic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
1318     Shutdown();
1319   }
1320
1321   if (flushCache && resolver) {
1322     resolver->FlushCache(false);
1323     return NS_OK;
1324   }
1325
1326   return NS_OK;
1327 }
1328
1329 uint16_t nsDNSService::GetAFForLookup(const nsACString& host,
1330                                       nsIDNSService::DNSFlags flags) {
1331   if (StaticPrefs::network_dns_disableIPv6() ||
1332       (flags & RESOLVE_DISABLE_IPV6)) {
1333     return PR_AF_INET;
1334   }
1335
1336   MutexAutoLock lock(mLock);
1337
1338   uint16_t af = PR_AF_UNSPEC;
1339
1340   if (!mIPv4OnlyDomains.IsEmpty()) {
1341     const char *domain, *domainEnd, *end;
1342     uint32_t hostLen, domainLen;
1343
1344     // see if host is in one of the IPv4-only domains
1345     domain = mIPv4OnlyDomains.BeginReading();
1346     domainEnd = mIPv4OnlyDomains.EndReading();
1347
1348     nsACString::const_iterator hostStart;
1349     host.BeginReading(hostStart);
1350     hostLen = host.Length();
1351
1352     do {
1353       // skip any whitespace
1354       while (*domain == ' ' || *domain == '\t') {
1355         ++domain;
1356       }
1357
1358       // find end of this domain in the string
1359       end = strchr(domain, ',');
1360       if (!end) {
1361         end = domainEnd;
1362       }
1363
1364       // to see if the hostname is in the domain, check if the domain
1365       // matches the end of the hostname.
1366       domainLen = end - domain;
1367       if (domainLen && hostLen >= domainLen) {
1368         const char* hostTail = hostStart.get() + hostLen - domainLen;
1369         if (nsCRT::strncasecmp(domain, hostTail, domainLen) == 0) {
1370           // now, make sure either that the hostname is a direct match or
1371           // that the hostname begins with a dot.
1372           if (hostLen == domainLen || *hostTail == '.' ||
1373               *(hostTail - 1) == '.') {
1374             af = PR_AF_INET;
1375             break;
1376           }
1377         }
1378       }
1379
1380       domain = end + 1;
1381     } while (*end);
1382   }
1383
1384   if ((af != PR_AF_INET) && (flags & RESOLVE_DISABLE_IPV4)) {
1385     af = PR_AF_INET6;
1386   }
1387
1388   return af;
1389 }
1390
1391 NS_IMETHODIMP
1392 nsDNSService::GetDNSCacheEntries(
1393     nsTArray<mozilla::net::DNSCacheEntries>* args) {
1394   RefPtr<nsHostResolver> resolver = GetResolverLocked();
1395   NS_ENSURE_TRUE(resolver, NS_ERROR_NOT_INITIALIZED);
1396   resolver->GetDNSCacheEntries(args);
1397   return NS_OK;
1398 }
1399
1400 NS_IMETHODIMP
1401 nsDNSService::ClearCache(bool aTrrToo) {
1402   RefPtr<nsHostResolver> resolver = GetResolverLocked();
1403   NS_ENSURE_TRUE(resolver, NS_ERROR_NOT_INITIALIZED);
1404   resolver->FlushCache(aTrrToo);
1405   return NS_OK;
1406 }
1407
1408 NS_IMETHODIMP
1409 nsDNSService::ReloadParentalControlEnabled() {
1410   if (mTrrService) {
1411     mTrrService->mParentalControlEnabled =
1412         TRRService::GetParentalControlEnabledInternal();
1413   }
1414   return NS_OK;
1415 }
1416
1417 NS_IMETHODIMP
1418 nsDNSService::SetDetectedTrrURI(const nsACString& aURI) {
1419   if (mTrrService) {
1420     mTrrService->SetDetectedTrrURI(aURI);
1421   }
1422   return NS_OK;
1423 }
1424
1425 NS_IMETHODIMP
1426 nsDNSService::SetHeuristicDetectionResult(nsITRRSkipReason::value aValue) {
1427   if (mTrrService) {
1428     mTrrService->SetHeuristicDetectionResult(aValue);
1429   }
1430   return NS_OK;
1431 }
1432
1433 NS_IMETHODIMP
1434 nsDNSService::GetHeuristicDetectionResult(nsITRRSkipReason::value* aValue) {
1435   if (!mTrrService) {
1436     return NS_ERROR_NOT_AVAILABLE;
1437   }
1438
1439   *aValue = mTrrService->GetHeuristicDetectionResult();
1440   return NS_OK;
1441 }
1442
1443 NS_IMETHODIMP
1444 nsDNSService::GetTRRSkipReasonName(nsITRRSkipReason::value aValue,
1445                                    nsACString& aName) {
1446   return mozilla::net::GetTRRSkipReasonName(aValue, aName);
1447 }
1448
1449 NS_IMETHODIMP
1450 nsDNSService::GetCurrentTrrURI(nsACString& aURI) {
1451   if (mTrrService) {
1452     mTrrService->GetURI(aURI);
1453   }
1454   return NS_OK;
1455 }
1456
1457 NS_IMETHODIMP
1458 nsDNSService::GetCurrentTrrMode(nsIDNSService::ResolverMode* aMode) {
1459   *aMode = nsIDNSService::MODE_NATIVEONLY;  // The default mode.
1460   if (mTrrService) {
1461     *aMode = mTrrService->Mode();
1462   }
1463   return NS_OK;
1464 }
1465
1466 NS_IMETHODIMP
1467 nsDNSService::GetCurrentTrrConfirmationState(uint32_t* aConfirmationState) {
1468   *aConfirmationState = uint32_t(TRRService::CONFIRM_OFF);
1469   if (mTrrService) {
1470     *aConfirmationState = mTrrService->ConfirmationState();
1471   }
1472   return NS_OK;
1473 }
1474
1475 NS_IMETHODIMP
1476 nsDNSService::GetTrrDomain(nsACString& aTRRDomain) {
1477   aTRRDomain.Truncate();
1478   nsAutoCString url;
1479   if (mTrrService) {
1480     mTrrService->GetURI(url);
1481   }
1482   nsCOMPtr<nsIURI> uri;
1483   nsresult rv = NS_NewURI(getter_AddRefs(uri), url);
1484   if (NS_FAILED(rv)) {
1485     // An empty TRR domain in case of invalid URL.
1486     return NS_OK;
1487   }
1488   return uri->GetHost(aTRRDomain);
1489 }
1490
1491 nsresult nsDNSService::GetTRRDomainKey(nsACString& aTRRDomain) {
1492   aTRRDomain = TRRService::ProviderKey();
1493   return NS_OK;
1494 }
1495
1496 size_t nsDNSService::SizeOfIncludingThis(
1497     mozilla::MallocSizeOf mallocSizeOf) const {
1498   // Measurement of the following members may be added later if DMD finds it
1499   // is worthwhile:
1500   // - mIDN
1501   // - mLock
1502
1503   size_t n = mallocSizeOf(this);
1504   n += mResolver ? mResolver->SizeOfIncludingThis(mallocSizeOf) : 0;
1505   n += mIPv4OnlyDomains.SizeOfExcludingThisIfUnshared(mallocSizeOf);
1506   n += mLocalDomains.SizeOfExcludingThis(mallocSizeOf);
1507   n += mFailedSVCDomainNames.ShallowSizeOfExcludingThis(mallocSizeOf);
1508   for (const auto& data : mFailedSVCDomainNames.Values()) {
1509     n += data->ShallowSizeOfExcludingThis(mallocSizeOf);
1510     for (const auto& name : *data) {
1511       n += name.SizeOfExcludingThisIfUnshared(mallocSizeOf);
1512     }
1513   }
1514   return n;
1515 }
1516
1517 MOZ_DEFINE_MALLOC_SIZE_OF(DNSServiceMallocSizeOf)
1518
1519 NS_IMETHODIMP
1520 nsDNSService::CollectReports(nsIHandleReportCallback* aHandleReport,
1521                              nsISupports* aData, bool aAnonymize) {
1522   MOZ_COLLECT_REPORT("explicit/network/dns-service", KIND_HEAP, UNITS_BYTES,
1523                      SizeOfIncludingThis(DNSServiceMallocSizeOf),
1524                      "Memory used for the DNS service.");
1525
1526   return NS_OK;
1527 }
1528
1529 NS_IMETHODIMP
1530 nsDNSService::ReportFailedSVCDomainName(const nsACString& aOwnerName,
1531                                         const nsACString& aSVCDomainName) {
1532   MutexAutoLock lock(mLock);
1533
1534   mFailedSVCDomainNames.GetOrInsertNew(aOwnerName, 1)
1535       ->AppendElement(aSVCDomainName);
1536   return NS_OK;
1537 }
1538
1539 NS_IMETHODIMP
1540 nsDNSService::IsSVCDomainNameFailed(const nsACString& aOwnerName,
1541                                     const nsACString& aSVCDomainName,
1542                                     bool* aResult) {
1543   NS_ENSURE_ARG(aResult);
1544
1545   MutexAutoLock lock(mLock);
1546   *aResult = false;
1547   nsTArray<nsCString>* failedList = mFailedSVCDomainNames.Get(aOwnerName);
1548   if (!failedList) {
1549     return NS_OK;
1550   }
1551
1552   *aResult = failedList->Contains(aSVCDomainName);
1553   return NS_OK;
1554 }
1555
1556 NS_IMETHODIMP
1557 nsDNSService::ResetExcludedSVCDomainName(const nsACString& aOwnerName) {
1558   MutexAutoLock lock(mLock);
1559   mFailedSVCDomainNames.Remove(aOwnerName);
1560   return NS_OK;
1561 }
1562
1563 NS_IMETHODIMP
1564 nsDNSService::GetLastConfirmationStatus(nsresult* aConfirmationStatus) {
1565   if (!mTrrService) {
1566     return NS_ERROR_NOT_AVAILABLE;
1567   }
1568   *aConfirmationStatus = mTrrService->LastConfirmationStatus();
1569   return NS_OK;
1570 }
1571
1572 NS_IMETHODIMP nsDNSService::GetLastConfirmationSkipReason(
1573     TRRSkippedReason* aSkipReason) {
1574   if (!mTrrService) {
1575     return NS_ERROR_NOT_AVAILABLE;
1576   }
1577   *aSkipReason = mTrrService->LastConfirmationSkipReason();
1578   return NS_OK;
1579 }
1580
1581 namespace mozilla::net {
1582 nsresult GetTRRSkipReasonName(TRRSkippedReason aReason, nsACString& aName) {
1583   static_assert(TRRSkippedReason::TRR_UNSET == 0);
1584   static_assert(TRRSkippedReason::TRR_OK == 1);
1585   static_assert(TRRSkippedReason::TRR_NO_GSERVICE == 2);
1586   static_assert(TRRSkippedReason::TRR_PARENTAL_CONTROL == 3);
1587   static_assert(TRRSkippedReason::TRR_OFF_EXPLICIT == 4);
1588   static_assert(TRRSkippedReason::TRR_REQ_MODE_DISABLED == 5);
1589   static_assert(TRRSkippedReason::TRR_MODE_NOT_ENABLED == 6);
1590   static_assert(TRRSkippedReason::TRR_FAILED == 7);
1591   static_assert(TRRSkippedReason::TRR_MODE_UNHANDLED_DEFAULT == 8);
1592   static_assert(TRRSkippedReason::TRR_MODE_UNHANDLED_DISABLED == 9);
1593   static_assert(TRRSkippedReason::TRR_DISABLED_FLAG == 10);
1594   static_assert(TRRSkippedReason::TRR_TIMEOUT == 11);
1595   static_assert(TRRSkippedReason::TRR_CHANNEL_DNS_FAIL == 12);
1596   static_assert(TRRSkippedReason::TRR_IS_OFFLINE == 13);
1597   static_assert(TRRSkippedReason::TRR_NOT_CONFIRMED == 14);
1598   static_assert(TRRSkippedReason::TRR_DID_NOT_MAKE_QUERY == 15);
1599   static_assert(TRRSkippedReason::TRR_UNKNOWN_CHANNEL_FAILURE == 16);
1600   static_assert(TRRSkippedReason::TRR_HOST_BLOCKED_TEMPORARY == 17);
1601   static_assert(TRRSkippedReason::TRR_SEND_FAILED == 18);
1602   static_assert(TRRSkippedReason::TRR_NET_RESET == 19);
1603   static_assert(TRRSkippedReason::TRR_NET_TIMEOUT == 20);
1604   static_assert(TRRSkippedReason::TRR_NET_REFUSED == 21);
1605   static_assert(TRRSkippedReason::TRR_NET_INTERRUPT == 22);
1606   static_assert(TRRSkippedReason::TRR_NET_INADEQ_SEQURITY == 23);
1607   static_assert(TRRSkippedReason::TRR_NO_ANSWERS == 24);
1608   static_assert(TRRSkippedReason::TRR_DECODE_FAILED == 25);
1609   static_assert(TRRSkippedReason::TRR_EXCLUDED == 26);
1610   static_assert(TRRSkippedReason::TRR_SERVER_RESPONSE_ERR == 27);
1611   static_assert(TRRSkippedReason::TRR_RCODE_FAIL == 28);
1612   static_assert(TRRSkippedReason::TRR_NO_CONNECTIVITY == 29);
1613   static_assert(TRRSkippedReason::TRR_NXDOMAIN == 30);
1614   static_assert(TRRSkippedReason::TRR_REQ_CANCELLED == 31);
1615   static_assert(TRRSkippedReason::ODOH_KEY_NOT_USABLE == 32);
1616   static_assert(TRRSkippedReason::ODOH_UPDATE_KEY_FAILED == 33);
1617   static_assert(TRRSkippedReason::ODOH_KEY_NOT_AVAILABLE == 34);
1618   static_assert(TRRSkippedReason::ODOH_ENCRYPTION_FAILED == 35);
1619   static_assert(TRRSkippedReason::ODOH_DECRYPTION_FAILED == 36);
1620   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_GOOGLE_SAFESEARCH ==
1621                 37);
1622   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_YOUTUBE_SAFESEARCH ==
1623                 38);
1624   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_ZSCALER_CANARY == 39);
1625   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_CANARY == 40);
1626   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_MODIFIED_ROOTS == 41);
1627   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_PARENTAL_CONTROLS ==
1628                 42);
1629   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_THIRD_PARTY_ROOTS ==
1630                 43);
1631   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_ENTERPRISE_POLICY ==
1632                 44);
1633   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_VPN == 45);
1634   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_PROXY == 46);
1635   static_assert(TRRSkippedReason::TRR_HEURISTIC_TRIPPED_NRPT == 47);
1636   static_assert(TRRSkippedReason::TRR_BAD_URL == 48);
1637
1638   switch (aReason) {
1639     case TRRSkippedReason::TRR_UNSET:
1640       aName = "TRR_UNSET"_ns;
1641       break;
1642     case TRRSkippedReason::TRR_OK:
1643       aName = "TRR_OK"_ns;
1644       break;
1645     case TRRSkippedReason::TRR_NO_GSERVICE:
1646       aName = "TRR_NO_GSERVICE"_ns;
1647       break;
1648     case TRRSkippedReason::TRR_PARENTAL_CONTROL:
1649       aName = "TRR_PARENTAL_CONTROL"_ns;
1650       break;
1651     case TRRSkippedReason::TRR_OFF_EXPLICIT:
1652       aName = "TRR_OFF_EXPLICIT"_ns;
1653       break;
1654     case TRRSkippedReason::TRR_REQ_MODE_DISABLED:
1655       aName = "TRR_REQ_MODE_DISABLED"_ns;
1656       break;
1657     case TRRSkippedReason::TRR_MODE_NOT_ENABLED:
1658       aName = "TRR_MODE_NOT_ENABLED"_ns;
1659       break;
1660     case TRRSkippedReason::TRR_FAILED:
1661       aName = "TRR_FAILED"_ns;
1662       break;
1663     case TRRSkippedReason::TRR_MODE_UNHANDLED_DEFAULT:
1664       aName = "TRR_MODE_UNHANDLED_DEFAULT"_ns;
1665       break;
1666     case TRRSkippedReason::TRR_MODE_UNHANDLED_DISABLED:
1667       aName = "TRR_MODE_UNHANDLED_DISABLED"_ns;
1668       break;
1669     case TRRSkippedReason::TRR_DISABLED_FLAG:
1670       aName = "TRR_DISABLED_FLAG"_ns;
1671       break;
1672     case TRRSkippedReason::TRR_TIMEOUT:
1673       aName = "TRR_TIMEOUT"_ns;
1674       break;
1675     case TRRSkippedReason::TRR_CHANNEL_DNS_FAIL:
1676       aName = "TRR_CHANNEL_DNS_FAIL"_ns;
1677       break;
1678     case TRRSkippedReason::TRR_IS_OFFLINE:
1679       aName = "TRR_IS_OFFLINE"_ns;
1680       break;
1681     case TRRSkippedReason::TRR_NOT_CONFIRMED:
1682       aName = "TRR_NOT_CONFIRMED"_ns;
1683       break;
1684     case TRRSkippedReason::TRR_DID_NOT_MAKE_QUERY:
1685       aName = "TRR_DID_NOT_MAKE_QUERY"_ns;
1686       break;
1687     case TRRSkippedReason::TRR_UNKNOWN_CHANNEL_FAILURE:
1688       aName = "TRR_UNKNOWN_CHANNEL_FAILURE"_ns;
1689       break;
1690     case TRRSkippedReason::TRR_HOST_BLOCKED_TEMPORARY:
1691       aName = "TRR_HOST_BLOCKED_TEMPORARY"_ns;
1692       break;
1693     case TRRSkippedReason::TRR_SEND_FAILED:
1694       aName = "TRR_SEND_FAILED"_ns;
1695       break;
1696     case TRRSkippedReason::TRR_NET_RESET:
1697       aName = "TRR_NET_RESET"_ns;
1698       break;
1699     case TRRSkippedReason::TRR_NET_TIMEOUT:
1700       aName = "TRR_NET_TIMEOUT"_ns;
1701       break;
1702     case TRRSkippedReason::TRR_NET_REFUSED:
1703       aName = "TRR_NET_REFUSED"_ns;
1704       break;
1705     case TRRSkippedReason::TRR_NET_INTERRUPT:
1706       aName = "TRR_NET_INTERRUPT"_ns;
1707       break;
1708     case TRRSkippedReason::TRR_NET_INADEQ_SEQURITY:
1709       aName = "TRR_NET_INADEQ_SEQURITY"_ns;
1710       break;
1711     case TRRSkippedReason::TRR_NO_ANSWERS:
1712       aName = "TRR_NO_ANSWERS"_ns;
1713       break;
1714     case TRRSkippedReason::TRR_DECODE_FAILED:
1715       aName = "TRR_DECODE_FAILED"_ns;
1716       break;
1717     case TRRSkippedReason::TRR_EXCLUDED:
1718       aName = "TRR_EXCLUDED"_ns;
1719       break;
1720     case TRRSkippedReason::TRR_SERVER_RESPONSE_ERR:
1721       aName = "TRR_SERVER_RESPONSE_ERR"_ns;
1722       break;
1723     case TRRSkippedReason::TRR_RCODE_FAIL:
1724       aName = "TRR_RCODE_FAIL"_ns;
1725       break;
1726     case TRRSkippedReason::TRR_NO_CONNECTIVITY:
1727       aName = "TRR_NO_CONNECTIVITY"_ns;
1728       break;
1729     case TRRSkippedReason::TRR_NXDOMAIN:
1730       aName = "TRR_NXDOMAIN"_ns;
1731       break;
1732     case TRRSkippedReason::TRR_REQ_CANCELLED:
1733       aName = "TRR_REQ_CANCELLED"_ns;
1734       break;
1735     case TRRSkippedReason::ODOH_KEY_NOT_USABLE:
1736       aName = "ODOH_KEY_NOT_USABLE"_ns;
1737       break;
1738     case TRRSkippedReason::ODOH_UPDATE_KEY_FAILED:
1739       aName = "ODOH_UPDATE_KEY_FAILED"_ns;
1740       break;
1741     case TRRSkippedReason::ODOH_KEY_NOT_AVAILABLE:
1742       aName = "ODOH_KEY_NOT_AVAILABLE"_ns;
1743       break;
1744     case TRRSkippedReason::ODOH_ENCRYPTION_FAILED:
1745       aName = "ODOH_ENCRYPTION_FAILED"_ns;
1746       break;
1747     case TRRSkippedReason::ODOH_DECRYPTION_FAILED:
1748       aName = "ODOH_DECRYPTION_FAILED"_ns;
1749       break;
1750     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_GOOGLE_SAFESEARCH:
1751       aName = "TRR_HEURISTIC_TRIPPED_GOOGLE_SAFESEARCH"_ns;
1752       break;
1753     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_YOUTUBE_SAFESEARCH:
1754       aName = "TRR_HEURISTIC_TRIPPED_YOUTUBE_SAFESEARCH"_ns;
1755       break;
1756     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_ZSCALER_CANARY:
1757       aName = "TRR_HEURISTIC_TRIPPED_ZSCALER_CANARY"_ns;
1758       break;
1759     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_CANARY:
1760       aName = "TRR_HEURISTIC_TRIPPED_CANARY"_ns;
1761       break;
1762     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_MODIFIED_ROOTS:
1763       aName = "TRR_HEURISTIC_TRIPPED_MODIFIED_ROOTS"_ns;
1764       break;
1765     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_PARENTAL_CONTROLS:
1766       aName = "TRR_HEURISTIC_TRIPPED_PARENTAL_CONTROLS"_ns;
1767       break;
1768     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_THIRD_PARTY_ROOTS:
1769       aName = "TRR_HEURISTIC_TRIPPED_THIRD_PARTY_ROOTS"_ns;
1770       break;
1771     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_ENTERPRISE_POLICY:
1772       aName = "TRR_HEURISTIC_TRIPPED_ENTERPRISE_POLICY"_ns;
1773       break;
1774     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_VPN:
1775       aName = "TRR_HEURISTIC_TRIPPED_VPN"_ns;
1776       break;
1777     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_PROXY:
1778       aName = "TRR_HEURISTIC_TRIPPED_PROXY"_ns;
1779       break;
1780     case TRRSkippedReason::TRR_HEURISTIC_TRIPPED_NRPT:
1781       aName = "TRR_HEURISTIC_TRIPPED_NRPT"_ns;
1782       break;
1783     case TRRSkippedReason::TRR_BAD_URL:
1784       aName = "TRR_BAD_URL"_ns;
1785       break;
1786     default:
1787       MOZ_ASSERT(false, "Unknown value");
1788   }
1789
1790   return NS_OK;
1791 }
1792 }  // namespace mozilla::net