netwerk/dns/DNSRequestChild.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 "mozilla/dom/ContentChild.h"
   8 #include "mozilla/net/ChildDNSService.h"
   9 #include "mozilla/net/DNSByTypeRecord.h"
  10 #include "mozilla/net/DNSRequestChild.h"
  11 #include "mozilla/net/DNSRequestParent.h"
  12 #include "mozilla/net/NeckoChild.h"
  13 #include "mozilla/net/SocketProcessChild.h"
  14 #include "mozilla/SchedulerGroup.h"
  15 #include "mozilla/net/SocketProcessParent.h"
  16 #include "mozilla/Unused.h"
  17 #include "nsIDNSRecord.h"
  18 #include "nsIDNSByTypeRecord.h"
  19 #include "nsHostResolver.h"
  20 #include "nsIOService.h"
  21 #include "nsTArray.h"
  22 #include "nsNetAddr.h"
  23 #include "nsThreadUtils.h"
  24
  25 using namespace mozilla::ipc;
  26
  27 namespace mozilla {
  28 namespace net {
  29
  30 void DNSRequestBase::SetIPCActor(DNSRequestActor* aActor) {
  31   mIPCActor = aActor;
  32 }
  33
  34 //-----------------------------------------------------------------------------
  35 // ChildDNSRecord:
  36 // A simple class to provide nsIDNSRecord on the child
  37 //-----------------------------------------------------------------------------
  38
  39 class ChildDNSRecord : public nsIDNSAddrRecord {
  40  public:
  41   NS_DECL_THREADSAFE_ISUPPORTS
  42   NS_DECL_NSIDNSRECORD
  43   NS_DECL_NSIDNSADDRRECORD
  44
  45   ChildDNSRecord(const DNSRecord& reply, uint16_t flags);
  46
  47  private:
  48   virtual ~ChildDNSRecord() = default;
  49
  50   nsCString mCanonicalName;
  51   nsTArray<NetAddr> mAddresses;
  52   uint32_t mCurrent = 0;  // addr iterator
  53   uint16_t mFlags = 0;
  54   double mTrrFetchDuration = 0;
  55   double mTrrFetchDurationNetworkOnly = 0;
  56   bool mIsTRR = false;
  57   uint32_t mEffectiveTRRMode = 0;
  58   uint32_t mTTL = 0;
  59 };
  60
  61 NS_IMPL_ISUPPORTS(ChildDNSRecord, nsIDNSRecord, nsIDNSAddrRecord)
  62
  63 ChildDNSRecord::ChildDNSRecord(const DNSRecord& reply, uint16_t flags)
  64     : mFlags(flags) {
  65   mCanonicalName = reply.canonicalName();
  66   mTrrFetchDuration = reply.trrFetchDuration();
  67   mTrrFetchDurationNetworkOnly = reply.trrFetchDurationNetworkOnly();
  68   mIsTRR = reply.isTRR();
  69   mEffectiveTRRMode = reply.effectiveTRRMode();
  70
  71   // A shame IPDL gives us no way to grab ownership of array: so copy it.
  72   const nsTArray<NetAddr>& addrs = reply.addrs();
  73   mAddresses = addrs.Clone();
  74   mTTL = reply.ttl();
  75 }
  76
  77 //-----------------------------------------------------------------------------
  78 // ChildDNSRecord::nsIDNSAddrRecord
  79 //-----------------------------------------------------------------------------
  80
  81 NS_IMETHODIMP
  82 ChildDNSRecord::GetCanonicalName(nsACString& result) {
  83   if (!(mFlags & nsHostResolver::RES_CANON_NAME)) {
  84     return NS_ERROR_NOT_AVAILABLE;
  85   }
  86
  87   result = mCanonicalName;
  88   return NS_OK;
  89 }
  90
  91 NS_IMETHODIMP
  92 ChildDNSRecord::IsTRR(bool* retval) {
  93   *retval = mIsTRR;
  94   return NS_OK;
  95 }
  96
  97 NS_IMETHODIMP
  98 ChildDNSRecord::GetTrrFetchDuration(double* aTime) {
  99   *aTime = mTrrFetchDuration;
 100   return NS_OK;
 101 }
 102
 103 NS_IMETHODIMP
 104 ChildDNSRecord::GetTrrFetchDurationNetworkOnly(double* aTime) {
 105   *aTime = mTrrFetchDurationNetworkOnly;
 106   return NS_OK;
 107 }
 108
 109 NS_IMETHODIMP
 110 ChildDNSRecord::GetNextAddr(uint16_t port, NetAddr* addr) {
 111   if (mCurrent >= mAddresses.Length()) {
 112     return NS_ERROR_NOT_AVAILABLE;
 113   }
 114
 115   memcpy(addr, &mAddresses[mCurrent++], sizeof(NetAddr));
 116
 117   // both Ipv4/6 use same bits for port, so safe to just use ipv4's field
 118   addr->inet.port = htons(port);
 119
 120   return NS_OK;
 121 }
 122
 123 NS_IMETHODIMP
 124 ChildDNSRecord::GetAddresses(nsTArray<NetAddr>& aAddressArray) {
 125   aAddressArray = mAddresses.Clone();
 126   return NS_OK;
 127 }
 128
 129 // shamelessly copied from nsDNSRecord
 130 NS_IMETHODIMP
 131 ChildDNSRecord::GetScriptableNextAddr(uint16_t port, nsINetAddr** result) {
 132   NetAddr addr;
 133   nsresult rv = GetNextAddr(port, &addr);
 134   if (NS_FAILED(rv)) {
 135     return rv;
 136   }
 137
 138   RefPtr<nsNetAddr> netaddr = new nsNetAddr(&addr);
 139   netaddr.forget(result);
 140
 141   return NS_OK;
 142 }
 143
 144 // also copied from nsDNSRecord
 145 NS_IMETHODIMP
 146 ChildDNSRecord::GetNextAddrAsString(nsACString& result) {
 147   NetAddr addr;
 148   nsresult rv = GetNextAddr(0, &addr);
 149   if (NS_FAILED(rv)) {
 150     return rv;
 151   }
 152
 153   char buf[kIPv6CStrBufSize];
 154   if (addr.ToStringBuffer(buf, sizeof(buf))) {
 155     result.Assign(buf);
 156     return NS_OK;
 157   }
 158   NS_ERROR("NetAddrToString failed unexpectedly");
 159   return NS_ERROR_FAILURE;  // conversion failed for some reason
 160 }
 161
 162 NS_IMETHODIMP
 163 ChildDNSRecord::HasMore(bool* result) {
 164   *result = mCurrent < mAddresses.Length();
 165   return NS_OK;
 166 }
 167
 168 NS_IMETHODIMP
 169 ChildDNSRecord::Rewind() {
 170   mCurrent = 0;
 171   return NS_OK;
 172 }
 173
 174 NS_IMETHODIMP
 175 ChildDNSRecord::ReportUnusable(uint16_t aPort) {
 176   // "We thank you for your feedback" == >/dev/null
 177   // TODO: we could send info back to parent.
 178   return NS_OK;
 179 }
 180
 181 NS_IMETHODIMP
 182 ChildDNSRecord::GetEffectiveTRRMode(uint32_t* aMode) {
 183   *aMode = mEffectiveTRRMode;
 184   return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP
 188 ChildDNSRecord::GetTtl(uint32_t* aTtl) {
 189   *aTtl = mTTL;
 190   return NS_OK;
 191 }
 192
 193 class ChildDNSByTypeRecord : public nsIDNSByTypeRecord,
 194                              public nsIDNSTXTRecord,
 195                              public nsIDNSHTTPSSVCRecord,
 196                              public DNSHTTPSSVCRecordBase {
 197  public:
 198   NS_DECL_THREADSAFE_ISUPPORTS
 199   NS_DECL_NSIDNSRECORD
 200   NS_DECL_NSIDNSBYTYPERECORD
 201   NS_DECL_NSIDNSTXTRECORD
 202   NS_DECL_NSIDNSHTTPSSVCRECORD
 203
 204   explicit ChildDNSByTypeRecord(const TypeRecordResultType& reply,
 205                                 const nsACString& aHost);
 206
 207  private:
 208   virtual ~ChildDNSByTypeRecord() = default;
 209
 210   TypeRecordResultType mResults = AsVariant(mozilla::Nothing());
 211   bool mAllRecordsExcluded = false;
 212 };
 213
 214 NS_IMPL_ISUPPORTS(ChildDNSByTypeRecord, nsIDNSByTypeRecord, nsIDNSRecord,
 215                   nsIDNSTXTRecord, nsIDNSHTTPSSVCRecord)
 216
 217 ChildDNSByTypeRecord::ChildDNSByTypeRecord(const TypeRecordResultType& reply,
 218                                            const nsACString& aHost)
 219     : DNSHTTPSSVCRecordBase(aHost) {
 220   mResults = reply;
 221 }
 222
 223 NS_IMETHODIMP
 224 ChildDNSByTypeRecord::GetType(uint32_t* aType) {
 225   *aType = mResults.match(
 226       [](TypeRecordEmpty&) {
 227         MOZ_ASSERT(false, "This should never be the case");
 228         return nsIDNSService::RESOLVE_TYPE_DEFAULT;
 229       },
 230       [](TypeRecordTxt&) { return nsIDNSService::RESOLVE_TYPE_TXT; },
 231       [](TypeRecordHTTPSSVC&) { return nsIDNSService::RESOLVE_TYPE_HTTPSSVC; });
 232   return NS_OK;
 233 }
 234
 235 NS_IMETHODIMP
 236 ChildDNSByTypeRecord::GetRecords(CopyableTArray<nsCString>& aRecords) {
 237   if (!mResults.is<TypeRecordTxt>()) {
 238     return NS_ERROR_NOT_AVAILABLE;
 239   }
 240   aRecords = mResults.as<CopyableTArray<nsCString>>();
 241   return NS_OK;
 242 }
 243
 244 NS_IMETHODIMP
 245 ChildDNSByTypeRecord::GetRecordsAsOneString(nsACString& aRecords) {
 246   // deep copy
 247   if (!mResults.is<TypeRecordTxt>()) {
 248     return NS_ERROR_NOT_AVAILABLE;
 249   }
 250   auto& results = mResults.as<CopyableTArray<nsCString>>();
 251   for (uint32_t i = 0; i < results.Length(); i++) {
 252     aRecords.Append(results[i]);
 253   }
 254   return NS_OK;
 255 }
 256
 257 NS_IMETHODIMP
 258 ChildDNSByTypeRecord::GetRecords(nsTArray<RefPtr<nsISVCBRecord>>& aRecords) {
 259   if (!mResults.is<TypeRecordHTTPSSVC>()) {
 260     return NS_ERROR_NOT_AVAILABLE;
 261   }
 262
 263   auto& results = mResults.as<TypeRecordHTTPSSVC>();
 264
 265   for (const SVCB& r : results) {
 266     RefPtr<nsISVCBRecord> rec = new SVCBRecord(r);
 267     aRecords.AppendElement(rec);
 268   }
 269   return NS_OK;
 270 }
 271
 272 NS_IMETHODIMP
 273 ChildDNSByTypeRecord::GetServiceModeRecord(bool aNoHttp2, bool aNoHttp3,
 274                                            nsISVCBRecord** aRecord) {
 275   if (!mResults.is<TypeRecordHTTPSSVC>()) {
 276     return NS_ERROR_NOT_AVAILABLE;
 277   }
 278
 279   auto& results = mResults.as<TypeRecordHTTPSSVC>();
 280   nsCOMPtr<nsISVCBRecord> result = GetServiceModeRecordInternal(
 281       aNoHttp2, aNoHttp3, results, mAllRecordsExcluded);
 282   if (!result) {
 283     return NS_ERROR_NOT_AVAILABLE;
 284   }
 285
 286   result.forget(aRecord);
 287   return NS_OK;
 288 }
 289
 290 NS_IMETHODIMP
 291 ChildDNSByTypeRecord::GetAllRecordsWithEchConfig(
 292     bool aNoHttp2, bool aNoHttp3, bool* aAllRecordsHaveEchConfig,
 293     bool* aAllRecordsInH3ExcludedList,
 294     nsTArray<RefPtr<nsISVCBRecord>>& aResult) {
 295   if (!mResults.is<TypeRecordHTTPSSVC>()) {
 296     return NS_ERROR_NOT_AVAILABLE;
 297   }
 298
 299   auto& records = mResults.as<TypeRecordHTTPSSVC>();
 300   GetAllRecordsWithEchConfigInternal(aNoHttp2, aNoHttp3, records,
 301                                      aAllRecordsHaveEchConfig,
 302                                      aAllRecordsInH3ExcludedList, aResult);
 303   return NS_OK;
 304 }
 305
 306 NS_IMETHODIMP
 307 ChildDNSByTypeRecord::GetHasIPAddresses(bool* aResult) {
 308   NS_ENSURE_ARG(aResult);
 309
 310   if (!mResults.is<TypeRecordHTTPSSVC>()) {
 311     return NS_ERROR_NOT_AVAILABLE;
 312   }
 313
 314   auto& results = mResults.as<TypeRecordHTTPSSVC>();
 315   *aResult = HasIPAddressesInternal(results);
 316   return NS_OK;
 317 }
 318
 319 NS_IMETHODIMP
 320 ChildDNSByTypeRecord::GetAllRecordsExcluded(bool* aResult) {
 321   NS_ENSURE_ARG(aResult);
 322
 323   if (!mResults.is<TypeRecordHTTPSSVC>()) {
 324     return NS_ERROR_NOT_AVAILABLE;
 325   }
 326
 327   *aResult = mAllRecordsExcluded;
 328   return NS_OK;
 329 }
 330
 331 NS_IMETHODIMP
 332 ChildDNSByTypeRecord::GetResults(mozilla::net::TypeRecordResultType* aResults) {
 333   *aResults = mResults;
 334   return NS_OK;
 335 }
 336
 337 NS_IMETHODIMP
 338 ChildDNSByTypeRecord::GetTtl(uint32_t* aResult) {
 339   return NS_ERROR_NOT_IMPLEMENTED;
 340 }
 341
 342 //-----------------------------------------------------------------------------
 343 // DNSRequestSender
 344 //-----------------------------------------------------------------------------
 345
 346 NS_IMPL_ISUPPORTS(DNSRequestSender, nsICancelable)
 347
 348 DNSRequestSender::DNSRequestSender(
 349     const nsACString& aHost, const nsACString& aTrrServer,
 350     const uint16_t& aType, const OriginAttributes& aOriginAttributes,
 351     const uint32_t& aFlags, nsIDNSListener* aListener, nsIEventTarget* target)
 352     : mListener(aListener),
 353       mTarget(target),
 354       mResultStatus(NS_OK),
 355       mHost(aHost),
 356       mTrrServer(aTrrServer),
 357       mType(aType),
 358       mOriginAttributes(aOriginAttributes),
 359       mFlags(aFlags) {}
 360
 361 void DNSRequestSender::OnRecvCancelDNSRequest(
 362     const nsCString& hostName, const nsCString& trrServer, const uint16_t& type,
 363     const OriginAttributes& originAttributes, const uint32_t& flags,
 364     const nsresult& reason) {}
 365
 366 NS_IMETHODIMP
 367 DNSRequestSender::Cancel(nsresult reason) {
 368   if (!mIPCActor) {
 369     return NS_ERROR_NOT_AVAILABLE;
 370   }
 371
 372   if (mIPCActor->CanSend()) {
 373     // We can only do IPDL on the main thread
 374     nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction(
 375         "net::CancelDNSRequestEvent",
 376         [actor(mIPCActor), host(mHost), trrServer(mTrrServer), type(mType),
 377          originAttributes(mOriginAttributes), flags(mFlags), reason]() {
 378           if (!actor->CanSend()) {
 379             return;
 380           }
 381
 382           if (DNSRequestChild* child = actor->AsDNSRequestChild()) {
 383             Unused << child->SendCancelDNSRequest(
 384                 host, trrServer, type, originAttributes, flags, reason);
 385           } else if (DNSRequestParent* parent = actor->AsDNSRequestParent()) {
 386             Unused << parent->SendCancelDNSRequest(
 387                 host, trrServer, type, originAttributes, flags, reason);
 388           }
 389         });
 390     SchedulerGroup::Dispatch(TaskCategory::Other, runnable.forget());
 391   }
 392   return NS_OK;
 393 }
 394
 395 void DNSRequestSender::StartRequest() {
 396   // we can only do IPDL on the main thread
 397   if (!NS_IsMainThread()) {
 398     SchedulerGroup::Dispatch(
 399         TaskCategory::Other,
 400         NewRunnableMethod("net::DNSRequestSender::StartRequest", this,
 401                           &DNSRequestSender::StartRequest));
 402     return;
 403   }
 404
 405   if (DNSRequestChild* child = mIPCActor->AsDNSRequestChild()) {
 406     if (XRE_IsContentProcess()) {
 407       mozilla::dom::ContentChild* cc =
 408           static_cast<mozilla::dom::ContentChild*>(gNeckoChild->Manager());
 409       if (cc->IsShuttingDown()) {
 410         return;
 411       }
 412
 413       // Send request to Parent process.
 414       gNeckoChild->SendPDNSRequestConstructor(child, mHost, mTrrServer, mType,
 415                                               mOriginAttributes, mFlags);
 416     } else if (XRE_IsSocketProcess()) {
 417       // DNS resolution is done in the parent process. Send a DNS request to
 418       // parent process.
 419       MOZ_ASSERT(!nsIOService::UseSocketProcess());
 420
 421       SocketProcessChild* socketProcessChild =
 422           SocketProcessChild::GetSingleton();
 423       if (!socketProcessChild->CanSend()) {
 424         return;
 425       }
 426
 427       socketProcessChild->SendPDNSRequestConstructor(
 428           child, mHost, mTrrServer, mType, mOriginAttributes, mFlags);
 429     } else {
 430       MOZ_ASSERT(false, "Wrong process");
 431       return;
 432     }
 433   } else if (DNSRequestParent* parent = mIPCActor->AsDNSRequestParent()) {
 434     // DNS resolution is done in the socket process. Send a DNS request to
 435     // socket process.
 436     MOZ_ASSERT(nsIOService::UseSocketProcess());
 437
 438     RefPtr<DNSRequestParent> requestParent = parent;
 439     RefPtr<DNSRequestSender> self = this;
 440     auto task = [requestParent, self]() {
 441       Unused << SocketProcessParent::GetSingleton()->SendPDNSRequestConstructor(
 442           requestParent, self->mHost, self->mTrrServer, self->mType,
 443           self->mOriginAttributes, self->mFlags);
 444     };
 445     if (!gIOService->SocketProcessReady()) {
 446       gIOService->CallOrWaitForSocketProcess(std::move(task));
 447       return;
 448     }
 449
 450     task();
 451   }
 452 }
 453
 454 void DNSRequestSender::CallOnLookupComplete() {
 455   MOZ_ASSERT(mListener);
 456   mListener->OnLookupComplete(this, mResultRecord, mResultStatus);
 457 }
 458
 459 bool DNSRequestSender::OnRecvLookupCompleted(const DNSRequestResponse& reply) {
 460   MOZ_ASSERT(mListener);
 461
 462   switch (reply.type()) {
 463     case DNSRequestResponse::TDNSRecord: {
 464       mResultRecord = new ChildDNSRecord(reply.get_DNSRecord(), mFlags);
 465       break;
 466     }
 467     case DNSRequestResponse::Tnsresult: {
 468       mResultStatus = reply.get_nsresult();
 469       break;
 470     }
 471     case DNSRequestResponse::TIPCTypeRecord: {
 472       MOZ_ASSERT(mType != nsIDNSService::RESOLVE_TYPE_DEFAULT);
 473       mResultRecord =
 474           new ChildDNSByTypeRecord(reply.get_IPCTypeRecord().mData, mHost);
 475       break;
 476     }
 477     default:
 478       MOZ_ASSERT_UNREACHABLE("unknown type");
 479       return false;
 480   }
 481
 482   MOZ_ASSERT(NS_IsMainThread());
 483
 484   bool targetIsMain = false;
 485   if (!mTarget) {
 486     targetIsMain = true;
 487   } else {
 488     mTarget->IsOnCurrentThread(&targetIsMain);
 489   }
 490
 491   if (targetIsMain) {
 492     CallOnLookupComplete();
 493   } else {
 494     nsCOMPtr<nsIRunnable> event =
 495         NewRunnableMethod("net::DNSRequestSender::CallOnLookupComplete", this,
 496                           &DNSRequestSender::CallOnLookupComplete);
 497     mTarget->Dispatch(event, NS_DISPATCH_NORMAL);
 498   }
 499
 500   if (DNSRequestChild* child = mIPCActor->AsDNSRequestChild()) {
 501     Unused << mozilla::net::DNSRequestChild::Send__delete__(child);
 502   } else if (DNSRequestParent* parent = mIPCActor->AsDNSRequestParent()) {
 503     Unused << mozilla::net::DNSRequestParent::Send__delete__(parent);
 504   }
 505
 506   return true;
 507 }
 508
 509 void DNSRequestSender::OnIPCActorDestroy() {
 510   // Request is done or destroyed. Remove it from the hash table.
 511   RefPtr<ChildDNSService> dnsServiceChild =
 512       dont_AddRef(ChildDNSService::GetSingleton());
 513   dnsServiceChild->NotifyRequestDone(this);
 514
 515   mIPCActor = nullptr;
 516 }
 517
 518 //-----------------------------------------------------------------------------
 519 // DNSRequestChild
 520 //-----------------------------------------------------------------------------
 521
 522 DNSRequestChild::DNSRequestChild(DNSRequestBase* aRequest)
 523     : DNSRequestActor(aRequest) {
 524   aRequest->SetIPCActor(this);
 525 }
 526
 527 mozilla::ipc::IPCResult DNSRequestChild::RecvCancelDNSRequest(
 528     const nsCString& hostName, const nsCString& trrServer, const uint16_t& type,
 529     const OriginAttributes& originAttributes, const uint32_t& flags,
 530     const nsresult& reason) {
 531   mDNSRequest->OnRecvCancelDNSRequest(hostName, trrServer, type,
 532                                       originAttributes, flags, reason);
 533   return IPC_OK();
 534 }
 535
 536 mozilla::ipc::IPCResult DNSRequestChild::RecvLookupCompleted(
 537     const DNSRequestResponse& reply) {
 538   return mDNSRequest->OnRecvLookupCompleted(reply) ? IPC_OK()
 539                                                    : IPC_FAIL_NO_REASON(this);
 540 }
 541
 542 void DNSRequestChild::ActorDestroy(ActorDestroyReason) {
 543   mDNSRequest->OnIPCActorDestroy();
 544   mDNSRequest = nullptr;
 545 }
 546
 547 //------------------------------------------------------------------------------
 548 }  // namespace net
 549 }  // namespace mozilla