netwerk/dns/ChildDNSService.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "mozilla/net/ChildDNSService.h"
   6 #include "nsDNSPrefetch.h"
   7 #include "nsIDNSListener.h"
   8 #include "nsIOService.h"
   9 #include "nsThreadUtils.h"
  10 #include "nsIXPConnect.h"
  11 #include "nsIProtocolProxyService.h"
  12 #include "nsNetCID.h"
  13 #include "nsQueryObject.h"
  14 #include "mozilla/ClearOnShutdown.h"
  15 #include "mozilla/StaticPrefs_network.h"
  16 #include "mozilla/StaticPtr.h"
  17 #include "mozilla/SyncRunnable.h"
  18 #include "mozilla/net/NeckoChild.h"
  19 #include "mozilla/net/DNSListenerProxy.h"
  20 #include "mozilla/net/TRRServiceParent.h"
  21 #include "nsHostResolver.h"
  22 #include "nsServiceManagerUtils.h"
  23 #include "prsystem.h"
  24 #include "DNSAdditionalInfo.h"
  25 #include "TRRService.h"
  26
  27 namespace mozilla {
  28 namespace net {
  29
  30 //-----------------------------------------------------------------------------
  31 // ChildDNSService
  32 //-----------------------------------------------------------------------------
  33
  34 static StaticRefPtr<ChildDNSService> gChildDNSService;
  35
  36 already_AddRefed<ChildDNSService> ChildDNSService::GetSingleton() {
  37   MOZ_ASSERT_IF(nsIOService::UseSocketProcess(),
  38                 XRE_IsContentProcess() || XRE_IsParentProcess());
  39   MOZ_ASSERT_IF(!nsIOService::UseSocketProcess(),
  40                 XRE_IsContentProcess() || XRE_IsSocketProcess());
  41
  42   if (!gChildDNSService) {
  43     if (NS_WARN_IF(!NS_IsMainThread())) {
  44       return nullptr;
  45     }
  46     gChildDNSService = new ChildDNSService();
  47     gChildDNSService->Init();
  48     ClearOnShutdown(&gChildDNSService);
  49   }
  50
  51   return do_AddRef(gChildDNSService);
  52 }
  53
  54 NS_IMPL_ISUPPORTS_INHERITED(ChildDNSService, DNSServiceBase, nsIDNSService,
  55                             nsPIDNSService)
  56
  57 ChildDNSService::ChildDNSService() {
  58   MOZ_ASSERT_IF(nsIOService::UseSocketProcess(),
  59                 XRE_IsContentProcess() || XRE_IsParentProcess());
  60   MOZ_ASSERT_IF(!nsIOService::UseSocketProcess(),
  61                 XRE_IsContentProcess() || XRE_IsSocketProcess());
  62   if (XRE_IsParentProcess() && nsIOService::UseSocketProcess()) {
  63     nsDNSPrefetch::Initialize(this);
  64     mTRRServiceParent = new TRRServiceParent();
  65     mTRRServiceParent->Init();
  66   }
  67 }
  68
  69 void ChildDNSService::GetDNSRecordHashKey(
  70     const nsACString& aHost, const nsACString& aTrrServer, int32_t aPort,
  71     uint16_t aType, const OriginAttributes& aOriginAttributes,
  72     nsIDNSService::DNSFlags aFlags, uintptr_t aListenerAddr,
  73     nsACString& aHashKey) {
  74   aHashKey.Assign(aHost);
  75   aHashKey.Assign(aTrrServer);
  76   aHashKey.AppendInt(aPort);
  77   aHashKey.AppendInt(aType);
  78
  79   nsAutoCString originSuffix;
  80   aOriginAttributes.CreateSuffix(originSuffix);
  81   aHashKey.Append(originSuffix);
  82
  83   aHashKey.AppendInt(aFlags);
  84   aHashKey.AppendPrintf("0x%" PRIxPTR, aListenerAddr);
  85 }
  86
  87 nsresult ChildDNSService::AsyncResolveInternal(
  88     const nsACString& hostname, uint16_t type, nsIDNSService::DNSFlags flags,
  89     nsIDNSAdditionalInfo* aInfo, nsIDNSListener* listener,
  90     nsIEventTarget* target_, const OriginAttributes& aOriginAttributes,
  91     nsICancelable** result) {
  92   if (XRE_IsContentProcess()) {
  93     NS_ENSURE_TRUE(gNeckoChild != nullptr, NS_ERROR_FAILURE);
  94   }
  95
  96   if (DNSForbiddenByActiveProxy(hostname, flags)) {
  97     // nsHostResolver returns NS_ERROR_UNKNOWN_HOST for lots of reasons.
  98     // We use a different error code to differentiate this failure and to make
  99     // it clear(er) where this error comes from.
 100     return NS_ERROR_UNKNOWN_PROXY_HOST;
 101   }
 102
 103   bool resolveDNSInSocketProcess = false;
 104   if (XRE_IsParentProcess() && nsIOService::UseSocketProcess()) {
 105     resolveDNSInSocketProcess = true;
 106     if (type != nsIDNSService::RESOLVE_TYPE_DEFAULT &&
 107         (mTRRServiceParent->Mode() != nsIDNSService::MODE_TRRFIRST &&
 108          mTRRServiceParent->Mode() != nsIDNSService::MODE_TRRONLY) &&
 109         !StaticPrefs::network_dns_native_https_query()) {
 110       return NS_ERROR_UNKNOWN_HOST;
 111     }
 112   }
 113
 114   if (mDisablePrefetch && (flags & RESOLVE_SPECULATE)) {
 115     return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
 116   }
 117
 118   // We need original listener for the pending requests hash.
 119   uintptr_t originalListenerAddr = reinterpret_cast<uintptr_t>(listener);
 120
 121   // make sure JS callers get notification on the main thread
 122   nsCOMPtr<nsIEventTarget> target = target_;
 123   nsCOMPtr<nsIXPConnectWrappedJS> wrappedListener = do_QueryInterface(listener);
 124   if (wrappedListener && !target) {
 125     target = GetMainThreadSerialEventTarget();
 126   }
 127   if (target) {
 128     // Guarantee listener freed on main thread.  Not sure we need this in child
 129     // (or in parent in nsDNSService.cpp) but doesn't hurt.
 130     listener = new DNSListenerProxy(listener, target);
 131   }
 132
 133   RefPtr<DNSRequestSender> sender = new DNSRequestSender(
 134       hostname, DNSAdditionalInfo::URL(aInfo), DNSAdditionalInfo::Port(aInfo),
 135       type, aOriginAttributes, flags, listener, target);
 136   RefPtr<DNSRequestActor> dnsReq;
 137   if (resolveDNSInSocketProcess) {
 138     dnsReq = new DNSRequestParent(sender);
 139     if (!mTRRServiceParent->TRRConnectionInfoInited()) {
 140       mTRRServiceParent->InitTRRConnectionInfo();
 141     }
 142   } else {
 143     dnsReq = new DNSRequestChild(sender);
 144   }
 145
 146   {
 147     MutexAutoLock lock(mPendingRequestsLock);
 148     nsCString key;
 149     GetDNSRecordHashKey(hostname, DNSAdditionalInfo::URL(aInfo),
 150                         DNSAdditionalInfo::Port(aInfo), type, aOriginAttributes,
 151                         flags, originalListenerAddr, key);
 152     mPendingRequests.GetOrInsertNew(key)->AppendElement(sender);
 153   }
 154
 155   sender->StartRequest();
 156
 157   sender.forget(result);
 158   return NS_OK;
 159 }
 160
 161 nsresult ChildDNSService::CancelAsyncResolveInternal(
 162     const nsACString& aHostname, uint16_t aType, nsIDNSService::DNSFlags aFlags,
 163     nsIDNSAdditionalInfo* aInfo, nsIDNSListener* aListener, nsresult aReason,
 164     const OriginAttributes& aOriginAttributes) {
 165   if (mDisablePrefetch && (aFlags & RESOLVE_SPECULATE)) {
 166     return NS_ERROR_DNS_LOOKUP_QUEUE_FULL;
 167   }
 168
 169   MutexAutoLock lock(mPendingRequestsLock);
 170   nsTArray<RefPtr<DNSRequestSender>>* hashEntry;
 171   nsCString key;
 172   uintptr_t listenerAddr = reinterpret_cast<uintptr_t>(aListener);
 173   GetDNSRecordHashKey(aHostname, DNSAdditionalInfo::URL(aInfo),
 174                       DNSAdditionalInfo::Port(aInfo), aType, aOriginAttributes,
 175                       aFlags, listenerAddr, key);
 176   if (mPendingRequests.Get(key, &hashEntry)) {
 177     // We cancel just one.
 178     hashEntry->ElementAt(0)->Cancel(aReason);
 179   }
 180
 181   return NS_OK;
 182 }
 183
 184 //-----------------------------------------------------------------------------
 185 // ChildDNSService::nsIDNSService
 186 //-----------------------------------------------------------------------------
 187
 188 NS_IMETHODIMP
 189 ChildDNSService::AsyncResolve(const nsACString& hostname,
 190                               nsIDNSService::ResolveType aType,
 191                               nsIDNSService::DNSFlags flags,
 192                               nsIDNSAdditionalInfo* aInfo,
 193                               nsIDNSListener* listener, nsIEventTarget* target_,
 194                               JS::Handle<JS::Value> aOriginAttributes,
 195                               JSContext* aCx, uint8_t aArgc,
 196                               nsICancelable** result) {
 197   OriginAttributes attrs;
 198
 199   if (aArgc == 1) {
 200     if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) {
 201       return NS_ERROR_INVALID_ARG;
 202     }
 203   }
 204
 205   return AsyncResolveInternal(hostname, aType, flags, aInfo, listener, target_,
 206                               attrs, result);
 207 }
 208
 209 NS_IMETHODIMP
 210 ChildDNSService::AsyncResolveNative(
 211     const nsACString& hostname, nsIDNSService::ResolveType aType,
 212     nsIDNSService::DNSFlags flags, nsIDNSAdditionalInfo* aInfo,
 213     nsIDNSListener* listener, nsIEventTarget* target_,
 214     const OriginAttributes& aOriginAttributes, nsICancelable** result) {
 215   return AsyncResolveInternal(hostname, aType, flags, aInfo, listener, target_,
 216                               aOriginAttributes, result);
 217 }
 218
 219 NS_IMETHODIMP
 220 ChildDNSService::NewAdditionalInfo(const nsACString& aTrrURL, int32_t aPort,
 221                                    nsIDNSAdditionalInfo** aInfo) {
 222   RefPtr<DNSAdditionalInfo> res = new DNSAdditionalInfo(aTrrURL, aPort);
 223   res.forget(aInfo);
 224   return NS_OK;
 225 }
 226
 227 NS_IMETHODIMP
 228 ChildDNSService::CancelAsyncResolve(const nsACString& aHostname,
 229                                     nsIDNSService::ResolveType aType,
 230                                     nsIDNSService::DNSFlags aFlags,
 231                                     nsIDNSAdditionalInfo* aInfo,
 232                                     nsIDNSListener* aListener, nsresult aReason,
 233                                     JS::Handle<JS::Value> aOriginAttributes,
 234                                     JSContext* aCx, uint8_t aArgc) {
 235   OriginAttributes attrs;
 236
 237   if (aArgc == 1) {
 238     if (!aOriginAttributes.isObject() || !attrs.Init(aCx, aOriginAttributes)) {
 239       return NS_ERROR_INVALID_ARG;
 240     }
 241   }
 242
 243   return CancelAsyncResolveInternal(aHostname, aType, aFlags, aInfo, aListener,
 244                                     aReason, attrs);
 245 }
 246
 247 NS_IMETHODIMP
 248 ChildDNSService::CancelAsyncResolveNative(
 249     const nsACString& aHostname, nsIDNSService::ResolveType aType,
 250     nsIDNSService::DNSFlags aFlags, nsIDNSAdditionalInfo* aInfo,
 251     nsIDNSListener* aListener, nsresult aReason,
 252     const OriginAttributes& aOriginAttributes) {
 253   return CancelAsyncResolveInternal(aHostname, aType, aFlags, aInfo, aListener,
 254                                     aReason, aOriginAttributes);
 255 }
 256
 257 NS_IMETHODIMP
 258 ChildDNSService::Resolve(const nsACString& hostname,
 259                          nsIDNSService::DNSFlags flags,
 260                          JS::Handle<JS::Value> aOriginAttributes,
 261                          JSContext* aCx, uint8_t aArgc, nsIDNSRecord** result) {
 262   // not planning to ever support this, since sync IPDL is evil.
 263   return NS_ERROR_NOT_AVAILABLE;
 264 }
 265
 266 NS_IMETHODIMP
 267 ChildDNSService::ResolveNative(const nsACString& hostname,
 268                                nsIDNSService::DNSFlags flags,
 269                                const OriginAttributes& aOriginAttributes,
 270                                nsIDNSRecord** result) {
 271   // not planning to ever support this, since sync IPDL is evil.
 272   return NS_ERROR_NOT_AVAILABLE;
 273 }
 274
 275 NS_IMETHODIMP
 276 ChildDNSService::GetDNSCacheEntries(
 277     nsTArray<mozilla::net::DNSCacheEntries>* args) {
 278   // Only used by networking dashboard, so may not ever need this in child.
 279   // (and would provide a way to spy on what hosts other apps are connecting to,
 280   // unless we start keeping per-app DNS caches).
 281   return NS_ERROR_NOT_AVAILABLE;
 282 }
 283
 284 NS_IMETHODIMP
 285 ChildDNSService::ClearCache(bool aTrrToo) {
 286   if (!mTRRServiceParent || !mTRRServiceParent->CanSend()) {
 287     return NS_ERROR_NOT_AVAILABLE;
 288   }
 289
 290   Unused << mTRRServiceParent->SendClearDNSCache(aTrrToo);
 291   return NS_OK;
 292 }
 293
 294 NS_IMETHODIMP
 295 ChildDNSService::ReloadParentalControlEnabled() {
 296   if (!mTRRServiceParent) {
 297     return NS_ERROR_NOT_AVAILABLE;
 298   }
 299
 300   mTRRServiceParent->UpdateParentalControlEnabled();
 301   return NS_OK;
 302 }
 303
 304 NS_IMETHODIMP
 305 ChildDNSService::SetDetectedTrrURI(const nsACString& aURI) {
 306   if (!mTRRServiceParent) {
 307     return NS_ERROR_NOT_AVAILABLE;
 308   }
 309
 310   mTRRServiceParent->SetDetectedTrrURI(aURI);
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP
 315 ChildDNSService::SetHeuristicDetectionResult(nsITRRSkipReason::value aValue) {
 316   return NS_ERROR_NOT_IMPLEMENTED;
 317 }
 318
 319 NS_IMETHODIMP
 320 ChildDNSService::GetHeuristicDetectionResult(nsITRRSkipReason::value* aValue) {
 321   return NS_ERROR_NOT_IMPLEMENTED;
 322 }
 323
 324 NS_IMETHODIMP
 325 ChildDNSService::GetTRRSkipReasonName(nsITRRSkipReason::value aValue,
 326                                       nsACString& aName) {
 327   return mozilla::net::GetTRRSkipReasonName(aValue, aName);
 328 }
 329
 330 NS_IMETHODIMP
 331 ChildDNSService::GetCurrentTrrURI(nsACString& aURI) {
 332   if (!mTRRServiceParent) {
 333     return NS_ERROR_NOT_AVAILABLE;
 334   }
 335
 336   mTRRServiceParent->GetURI(aURI);
 337   return NS_OK;
 338 }
 339
 340 NS_IMETHODIMP
 341 ChildDNSService::GetCurrentTrrMode(nsIDNSService::ResolverMode* aMode) {
 342   if (XRE_IsContentProcess()) {
 343     *aMode = mTRRMode;
 344     return NS_OK;
 345   }
 346   if (!mTRRServiceParent) {
 347     return NS_ERROR_NOT_AVAILABLE;
 348   }
 349
 350   *aMode = mTRRServiceParent->Mode();
 351   return NS_OK;
 352 }
 353
 354 void ChildDNSService::SetTRRModeInChild(
 355     nsIDNSService::ResolverMode mode,
 356     nsIDNSService::ResolverMode modeFromPref) {
 357   if (!XRE_IsContentProcess()) {
 358     MOZ_ASSERT(false, "Why are we calling this?");
 359     return;
 360   }
 361   mTRRMode = mode;
 362   TRRService::SetCurrentTRRMode(modeFromPref);
 363 }
 364
 365 NS_IMETHODIMP
 366 ChildDNSService::GetCurrentTrrConfirmationState(uint32_t* aConfirmationState) {
 367   if (!mTRRServiceParent) {
 368     return NS_ERROR_NOT_AVAILABLE;
 369   }
 370
 371   *aConfirmationState = mTRRServiceParent->GetConfirmationState();
 372   return NS_OK;
 373 }
 374
 375 NS_IMETHODIMP
 376 ChildDNSService::GetMyHostName(nsACString& result) {
 377   if (XRE_IsParentProcess()) {
 378     char name[100];
 379     if (PR_GetSystemInfo(PR_SI_HOSTNAME, name, sizeof(name)) == PR_SUCCESS) {
 380       result = name;
 381       return NS_OK;
 382     }
 383
 384     return NS_ERROR_FAILURE;
 385   }
 386   // TODO: get value from parent during PNecko construction?
 387   return NS_ERROR_NOT_AVAILABLE;
 388 }
 389
 390 void ChildDNSService::NotifyRequestDone(DNSRequestSender* aDnsRequest) {
 391   // We need the original flags and listener for the pending requests hash.
 392   nsIDNSService::DNSFlags originalFlags =
 393       aDnsRequest->mFlags & ~RESOLVE_OFFLINE;
 394   uintptr_t originalListenerAddr =
 395       reinterpret_cast<uintptr_t>(aDnsRequest->mListener.get());
 396   RefPtr<DNSListenerProxy> wrapper = do_QueryObject(aDnsRequest->mListener);
 397   if (wrapper) {
 398     originalListenerAddr = wrapper->GetOriginalListenerAddress();
 399   }
 400
 401   MutexAutoLock lock(mPendingRequestsLock);
 402
 403   nsCString key;
 404   GetDNSRecordHashKey(aDnsRequest->mHost, aDnsRequest->mTrrServer,
 405                       aDnsRequest->mPort, aDnsRequest->mType,
 406                       aDnsRequest->mOriginAttributes, originalFlags,
 407                       originalListenerAddr, key);
 408
 409   nsTArray<RefPtr<DNSRequestSender>>* hashEntry;
 410
 411   if (mPendingRequests.Get(key, &hashEntry)) {
 412     auto idx = hashEntry->IndexOf(aDnsRequest);
 413     if (idx != nsTArray<RefPtr<DNSRequestSender>>::NoIndex) {
 414       hashEntry->RemoveElementAt(idx);
 415       if (hashEntry->IsEmpty()) {
 416         mPendingRequests.Remove(key);
 417       }
 418     }
 419   }
 420 }
 421
 422 //-----------------------------------------------------------------------------
 423 // ChildDNSService::nsPIDNSService
 424 //-----------------------------------------------------------------------------
 425
 426 nsresult ChildDNSService::Init() {
 427   ReadPrefs(nullptr);
 428
 429   nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID);
 430   if (prefs) {
 431     AddPrefObserver(prefs);
 432   }
 433
 434   return NS_OK;
 435 }
 436
 437 nsresult ChildDNSService::Shutdown() { return NS_OK; }
 438
 439 NS_IMETHODIMP
 440 ChildDNSService::GetPrefetchEnabled(bool* outVal) {
 441   *outVal = !mDisablePrefetch;
 442   return NS_OK;
 443 }
 444
 445 NS_IMETHODIMP
 446 ChildDNSService::SetPrefetchEnabled(bool inVal) {
 447   mDisablePrefetch = !inVal;
 448   return NS_OK;
 449 }
 450
 451 NS_IMETHODIMP
 452 ChildDNSService::ReportFailedSVCDomainName(const nsACString& aOwnerName,
 453                                            const nsACString& aSVCDomainName) {
 454   return NS_ERROR_NOT_IMPLEMENTED;
 455 }
 456
 457 NS_IMETHODIMP
 458 ChildDNSService::IsSVCDomainNameFailed(const nsACString& aOwnerName,
 459                                        const nsACString& aSVCDomainName,
 460                                        bool* aResult) {
 461   return NS_ERROR_NOT_IMPLEMENTED;
 462 }
 463
 464 NS_IMETHODIMP
 465 ChildDNSService::ResetExcludedSVCDomainName(const nsACString& aOwnerName) {
 466   return NS_ERROR_NOT_IMPLEMENTED;
 467 }
 468
 469 //-----------------------------------------------------------------------------
 470 // ChildDNSService::nsIObserver
 471 //-----------------------------------------------------------------------------
 472
 473 NS_IMETHODIMP
 474 ChildDNSService::Observe(nsISupports* subject, const char* topic,
 475                          const char16_t* data) {
 476   if (!strcmp(topic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
 477     // Reread prefs
 478     ReadPrefs(NS_ConvertUTF16toUTF8(data).get());
 479   }
 480   return NS_OK;
 481 }
 482
 483 void ChildDNSService::SetTRRDomain(const nsACString& aTRRDomain) {
 484   mTRRDomain = aTRRDomain;
 485   TRRService::SetProviderDomain(aTRRDomain);
 486 }
 487
 488 nsresult ChildDNSService::GetTRRDomainKey(nsACString& aTRRDomain) {
 489   aTRRDomain = TRRService::ProviderKey();
 490   return NS_OK;
 491 }
 492
 493 NS_IMETHODIMP
 494 ChildDNSService::GetTrrDomain(nsACString& aTRRDomain) {
 495   aTRRDomain = mTRRDomain;
 496   return NS_OK;
 497 }
 498
 499 NS_IMETHODIMP
 500 ChildDNSService::GetLastConfirmationStatus(nsresult* aConfirmationStatus) {
 501   // XXX(valentin): Fix for socket process
 502   *aConfirmationStatus = NS_OK;
 503   return NS_OK;
 504 }
 505
 506 NS_IMETHODIMP ChildDNSService::GetLastConfirmationSkipReason(
 507     TRRSkippedReason* aSkipReason) {
 508   // XXX(valentin): Fix for socket process
 509   *aSkipReason = nsITRRSkipReason::TRR_UNSET;
 510   return NS_OK;
 511 }
 512
 513 }  // namespace net
 514 }  // namespace mozilla