netwerk/ipc/ParentProcessDocumentChannel.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
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "ParentProcessDocumentChannel.h"
   9
  10 #include "mozilla/extensions/StreamFilterParent.h"
  11 #include "mozilla/net/ParentChannelWrapper.h"
  12 #include "mozilla/net/UrlClassifierCommon.h"
  13 #include "mozilla/StaticPrefs_extensions.h"
  14 #include "nsCRT.h"
  15 #include "nsDocShell.h"
  16 #include "nsIObserverService.h"
  17 #include "nsIClassifiedChannel.h"
  18 #include "nsIXULRuntime.h"
  19 #include "nsHttpHandler.h"
  20 #include "nsDocShellLoadState.h"
  21
  22 extern mozilla::LazyLogModule gDocumentChannelLog;
  23 #define LOG(fmt) MOZ_LOG(gDocumentChannelLog, mozilla::LogLevel::Verbose, fmt)
  24
  25 namespace mozilla {
  26 namespace net {
  27
  28 using RedirectToRealChannelPromise =
  29     typename PDocumentChannelParent::RedirectToRealChannelPromise;
  30
  31 NS_IMPL_ISUPPORTS_INHERITED(ParentProcessDocumentChannel, DocumentChannel,
  32                             nsIAsyncVerifyRedirectCallback, nsIObserver)
  33
  34 ParentProcessDocumentChannel::ParentProcessDocumentChannel(
  35     nsDocShellLoadState* aLoadState, class LoadInfo* aLoadInfo,
  36     nsLoadFlags aLoadFlags, uint32_t aCacheKey, bool aUriModified,
  37     bool aIsEmbeddingBlockedError)
  38     : DocumentChannel(aLoadState, aLoadInfo, aLoadFlags, aCacheKey,
  39                       aUriModified, aIsEmbeddingBlockedError) {
  40   LOG(("ParentProcessDocumentChannel ctor [this=%p]", this));
  41 }
  42
  43 ParentProcessDocumentChannel::~ParentProcessDocumentChannel() {
  44   LOG(("ParentProcessDocumentChannel dtor [this=%p]", this));
  45 }
  46
  47 RefPtr<RedirectToRealChannelPromise>
  48 ParentProcessDocumentChannel::RedirectToRealChannel(
  49     nsTArray<ipc::Endpoint<extensions::PStreamFilterParent>>&&
  50         aStreamFilterEndpoints,
  51     uint32_t aRedirectFlags, uint32_t aLoadFlags,
  52     const nsTArray<EarlyHintConnectArgs>& aEarlyHints) {
  53   LOG(("ParentProcessDocumentChannel RedirectToRealChannel [this=%p]", this));
  54   nsCOMPtr<nsIChannel> channel = mDocumentLoadListener->GetChannel();
  55   channel->SetLoadFlags(aLoadFlags);
  56   channel->SetNotificationCallbacks(mCallbacks);
  57
  58   if (mLoadGroup) {
  59     channel->SetLoadGroup(mLoadGroup);
  60   }
  61
  62   if (XRE_IsE10sParentProcess()) {
  63     nsCOMPtr<nsIURI> uri;
  64     MOZ_ALWAYS_SUCCEEDS(NS_GetFinalChannelURI(channel, getter_AddRefs(uri)));
  65     if (!nsDocShell::CanLoadInParentProcess(uri)) {
  66       nsAutoCString msg;
  67       uri->GetSpec(msg);
  68       msg.Insert(
  69           "Attempt to load a non-authorised load in the parent process: ", 0);
  70       NS_ASSERTION(false, msg.get());
  71       return RedirectToRealChannelPromise::CreateAndResolve(
  72           NS_ERROR_CONTENT_BLOCKED, __func__);
  73     }
  74   }
  75   mStreamFilterEndpoints = std::move(aStreamFilterEndpoints);
  76
  77   if (mDocumentLoadListener->IsDocumentLoad() &&
  78       mozilla::SessionHistoryInParent() && GetDocShell() &&
  79       mDocumentLoadListener->GetLoadingSessionHistoryInfo()) {
  80     GetDocShell()->SetLoadingSessionHistoryInfo(
  81         *mDocumentLoadListener->GetLoadingSessionHistoryInfo());
  82   }
  83
  84   RefPtr<RedirectToRealChannelPromise> p = mPromise.Ensure(__func__);
  85   // We make the promise use direct task dispatch in order to reduce the number
  86   // of event loops iterations.
  87   mPromise.UseDirectTaskDispatch(__func__);
  88
  89   nsresult rv =
  90       gHttpHandler->AsyncOnChannelRedirect(this, channel, aRedirectFlags);
  91   if (NS_FAILED(rv)) {
  92     LOG(
  93         ("ParentProcessDocumentChannel RedirectToRealChannel "
  94          "AsyncOnChannelRedirect failed [this=%p "
  95          "aRv=%d]",
  96          this, int(rv)));
  97     OnRedirectVerifyCallback(rv);
  98   }
  99
 100   return p;
 101 }
 102
 103 NS_IMETHODIMP
 104 ParentProcessDocumentChannel::OnRedirectVerifyCallback(nsresult aResult) {
 105   LOG(
 106       ("ParentProcessDocumentChannel OnRedirectVerifyCallback [this=%p "
 107        "aResult=%d]",
 108        this, int(aResult)));
 109
 110   MOZ_ASSERT(mDocumentLoadListener);
 111
 112   if (NS_FAILED(aResult)) {
 113     Cancel(aResult);
 114   } else if (mCanceled) {
 115     aResult = NS_ERROR_ABORT;
 116   } else {
 117     const nsCOMPtr<nsIChannel> channel = mDocumentLoadListener->GetChannel();
 118     mLoadGroup->AddRequest(channel, nullptr);
 119     // Adding the channel to the loadgroup could have triggered a status
 120     // change with an observer being called destroying the docShell, resulting
 121     // in the PPDC to be canceled.
 122     if (mCanceled) {
 123       aResult = NS_ERROR_ABORT;
 124     } else {
 125       mLoadGroup->RemoveRequest(this, nullptr, NS_BINDING_REDIRECTED);
 126       for (auto& endpoint : mStreamFilterEndpoints) {
 127         extensions::StreamFilterParent::Attach(channel, std::move(endpoint));
 128       }
 129
 130       RefPtr<ParentChannelWrapper> wrapper =
 131           new ParentChannelWrapper(channel, mListener);
 132
 133       wrapper->Register(mDocumentLoadListener->GetRedirectChannelId());
 134     }
 135   }
 136
 137   mPromise.Resolve(aResult, __func__);
 138
 139   return NS_OK;
 140 }
 141
 142 NS_IMETHODIMP ParentProcessDocumentChannel::AsyncOpen(
 143     nsIStreamListener* aListener) {
 144   LOG(("ParentProcessDocumentChannel AsyncOpen [this=%p]", this));
 145   auto docShell = RefPtr<nsDocShell>(GetDocShell());
 146   MOZ_ASSERT(docShell);
 147
 148   bool isDocumentLoad = mLoadInfo->GetExternalContentPolicyType() !=
 149                         ExtContentPolicy::TYPE_OBJECT;
 150
 151   mDocumentLoadListener = MakeRefPtr<DocumentLoadListener>(
 152       docShell->GetBrowsingContext()->Canonical(), isDocumentLoad);
 153   LOG(("Created PPDocumentChannel with listener=%p",
 154        mDocumentLoadListener.get()));
 155
 156   // Add observers.
 157   nsCOMPtr<nsIObserverService> observerService =
 158       mozilla::services::GetObserverService();
 159   if (observerService) {
 160     MOZ_ALWAYS_SUCCEEDS(observerService->AddObserver(
 161         this, NS_HTTP_ON_MODIFY_REQUEST_TOPIC, false));
 162   }
 163
 164   gHttpHandler->OnOpeningDocumentRequest(this);
 165
 166   if (isDocumentLoad) {
 167     // Return value of setting synced field should be checked. See bug 1656492.
 168     Unused << GetDocShell()->GetBrowsingContext()->SetCurrentLoadIdentifier(
 169         Some(mLoadState->GetLoadIdentifier()));
 170   }
 171
 172   nsresult rv = NS_OK;
 173   Maybe<dom::ClientInfo> initialClientInfo = mInitialClientInfo;
 174
 175   RefPtr<DocumentLoadListener::OpenPromise> promise;
 176   if (isDocumentLoad) {
 177     promise = mDocumentLoadListener->OpenDocument(
 178         mLoadState, mCacheKey, Some(mChannelId), TimeStamp::Now(), mTiming,
 179         std::move(initialClientInfo), Some(mUriModified),
 180         Some(mIsEmbeddingBlockedError), nullptr /* ContentParent */, &rv);
 181   } else {
 182     promise = mDocumentLoadListener->OpenObject(
 183         mLoadState, mCacheKey, Some(mChannelId), TimeStamp::Now(), mTiming,
 184         std::move(initialClientInfo), InnerWindowIDForExtantDoc(docShell),
 185         mLoadFlags, mLoadInfo->InternalContentPolicyType(),
 186         dom::UserActivation::IsHandlingUserInput(), nullptr /* ContentParent */,
 187         nullptr /* ObjectUpgradeHandler */, &rv);
 188   }
 189
 190   if (NS_FAILED(rv)) {
 191     MOZ_ASSERT(!promise);
 192     mDocumentLoadListener = nullptr;
 193     RemoveObserver();
 194     return rv;
 195   }
 196
 197   mListener = aListener;
 198   if (mLoadGroup) {
 199     mLoadGroup->AddRequest(this, nullptr);
 200   }
 201
 202   RefPtr<ParentProcessDocumentChannel> self = this;
 203   promise->Then(
 204       GetCurrentSerialEventTarget(), __func__,
 205       [self](DocumentLoadListener::OpenPromiseSucceededType&& aResolveValue) {
 206         self->mDocumentLoadListener->CancelEarlyHintPreloads();
 207         nsTArray<EarlyHintConnectArgs> earlyHints;
 208
 209         // The DLL is waiting for us to resolve the
 210         // RedirectToRealChannelPromise given as parameter.
 211         RefPtr<RedirectToRealChannelPromise> p =
 212             self->RedirectToRealChannel(
 213                     std::move(aResolveValue.mStreamFilterEndpoints),
 214                     aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags,
 215                     earlyHints)
 216                 ->Then(
 217                     GetCurrentSerialEventTarget(), __func__,
 218                     [self](RedirectToRealChannelPromise::ResolveOrRejectValue&&
 219                                aValue) -> RefPtr<RedirectToRealChannelPromise> {
 220                       MOZ_ASSERT(aValue.IsResolve());
 221                       nsresult rv = aValue.ResolveValue();
 222                       if (NS_FAILED(rv)) {
 223                         self->DisconnectChildListeners(rv, rv);
 224                       }
 225                       self->mLoadGroup = nullptr;
 226                       self->mListener = nullptr;
 227                       self->mCallbacks = nullptr;
 228                       self->RemoveObserver();
 229                       auto p =
 230                           MakeRefPtr<RedirectToRealChannelPromise::Private>(
 231                               __func__);
 232                       p->UseDirectTaskDispatch(__func__);
 233                       p->ResolveOrReject(std::move(aValue), __func__);
 234                       return p;
 235                     });
 236         // We chain the promise the DLL is waiting on to the one returned by
 237         // RedirectToRealChannel. As soon as the promise returned is
 238         // resolved or rejected, so will the DLL's promise.
 239         p->ChainTo(aResolveValue.mPromise.forget(), __func__);
 240       },
 241       [self](DocumentLoadListener::OpenPromiseFailedType&& aRejectValue) {
 242         // If this is a normal failure, then we want to disconnect our listeners
 243         // and notify them of the failure. If this is a process switch, then we
 244         // can just ignore it silently, and trust that the switch will shut down
 245         // our docshell and cancel us when it's ready.
 246         if (!aRejectValue.mContinueNavigating) {
 247           self->DisconnectChildListeners(aRejectValue.mStatus,
 248                                          aRejectValue.mLoadGroupStatus);
 249         }
 250         self->RemoveObserver();
 251       });
 252   return NS_OK;
 253 }
 254
 255 NS_IMETHODIMP ParentProcessDocumentChannel::Cancel(nsresult aStatus) {
 256   return CancelWithReason(aStatus, "ParentProcessDocumentChannel::Cancel"_ns);
 257 }
 258
 259 NS_IMETHODIMP ParentProcessDocumentChannel::CancelWithReason(
 260     nsresult aStatusCode, const nsACString& aReason) {
 261   LOG(("ParentProcessDocumentChannel CancelWithReason [this=%p]", this));
 262   if (mCanceled) {
 263     return NS_OK;
 264   }
 265
 266   mCanceled = true;
 267   // This will force the DocumentListener to abort the promise if there's one
 268   // pending.
 269   mDocumentLoadListener->Cancel(aStatusCode, aReason);
 270
 271   return NS_OK;
 272 }
 273
 274 void ParentProcessDocumentChannel::RemoveObserver() {
 275   if (nsCOMPtr<nsIObserverService> observerService =
 276           mozilla::services::GetObserverService()) {
 277     observerService->RemoveObserver(this, NS_HTTP_ON_MODIFY_REQUEST_TOPIC);
 278   }
 279 }
 280
 281 ////////////////////////////////////////////////////////////////////////////////
 282 // nsIObserver
 283 ////////////////////////////////////////////////////////////////////////////////
 284
 285 NS_IMETHODIMP
 286 ParentProcessDocumentChannel::Observe(nsISupports* aSubject, const char* aTopic,
 287                                       const char16_t* aData) {
 288   MOZ_ASSERT(NS_IsMainThread());
 289
 290   if (mRequestObserversCalled) {
 291     // We have already emitted the event, we don't want to emit it again.
 292     // We only care about forwarding the first NS_HTTP_ON_MODIFY_REQUEST_TOPIC
 293     // encountered.
 294     return NS_OK;
 295   }
 296   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aSubject);
 297   if (!channel || mDocumentLoadListener->GetChannel() != channel) {
 298     // Not a channel we are interested with.
 299     return NS_OK;
 300   }
 301   LOG(("DocumentChannelParent Observe [this=%p aChannel=%p]", this,
 302        channel.get()));
 303   if (!nsCRT::strcmp(aTopic, NS_HTTP_ON_MODIFY_REQUEST_TOPIC)) {
 304     mRequestObserversCalled = true;
 305     gHttpHandler->OnModifyDocumentRequest(this);
 306   }
 307
 308   return NS_OK;
 309 }
 310
 311 }  // namespace net
 312 }  // namespace mozilla
 313
 314 #undef LOG