Attachment #8926220 for bug #1222008

Attachment #8926220: Propagate the URLs from respondWith() if the response's URL is different from the request's and the response has been redirected for bug #1222008

View | Details | Raw Unified | Return to bug 1222008
Collapse All | Expand All





NS_IMPL_ISUPPORTS(BodyCopyHandle, nsIInterceptedBodyCallback)

class StartResponse final : public Runnable
{
  nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel;
  RefPtr<InternalResponse> mInternalResponse;
  ChannelInfo mWorkerChannelInfo;
  const nsCString mScriptSpec;
  const nsCString mResponseURLSpec;
  UniquePtr<RespondWithClosure> mClosure;

public:
  StartResponse(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,
                InternalResponse* aInternalResponse,
                const ChannelInfo& aWorkerChannelInfo,
                const nsACString& aScriptSpec,
                const nsACString& aResponseURLSpec,
                UniquePtr<RespondWithClosure>&& aClosure)
    : Runnable("dom::workers::StartResponse")
    , mChannel(aChannel)
    , mInternalResponse(aInternalResponse)
    , mWorkerChannelInfo(aWorkerChannelInfo)
    , mScriptSpec(aScriptSpec)
    , mResponseURLSpec(aResponseURLSpec)
    , mClosure(Move(aClosure))
  {
  }

  NS_IMETHOD
  Run() override
  {
    AssertIsOnMainThread();

    auto castLoadInfo = static_cast<LoadInfo*>(loadInfo.get());
    castLoadInfo->SynthesizeServiceWorkerTainting(mInternalResponse->GetTainting());

    nsCOMPtr<nsIInputStream> body;
    mInternalResponse->GetUnfilteredBody(getter_AddRefs(body));
    RefPtr<BodyCopyHandle> copyHandle;
    copyHandle = new BodyCopyHandle(Move(mClosure));

    rv =
      mChannel->StartSynthesizedResponse(body, copyHandle,
                                         mInternalResponse->GetUnfilteredURL(),
                                         mInternalResponse->IsRedirected());
    if (NS_WARN_IF(NS_FAILED(rv))) {
      mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);
      return NS_OK;
    }

    nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
    if (obsService) {
      obsService->NotifyObservers(underlyingChannel, "service-worker-synthesized-response", nullptr);

      NS_LITERAL_CSTRING("InterceptedUsedResponseWithURL"), mRequestURL);
    return;
  }

  RefPtr<InternalResponse> ir = response->GetInternalResponse();
  if (NS_WARN_IF(!ir)) {
    return;
  }

  // When an opaque response is encountered, we need the original channel's principal
  // to reflect the final URL. Non-opaque responses are either same-origin or CORS-enabled
  // cross-origin responses, which are treated as same-origin by consumers.
  if (response->Type() == ResponseType::Opaque &&
      NS_WARN_IF(ir->GetUnfilteredURL().IsEmpty())) {
    return;
    if (NS_WARN_IF(responseURL.IsEmpty())) {
      return;
    }
  }

  UniquePtr<RespondWithClosure> closure(new RespondWithClosure(mInterceptedChannel,
                                                               mRegistration,
                                                               mRequestURL,
                                                               mRespondWithScriptSpec,
                                                               mRespondWithLineNumber,
                                                               mRespondWithColumnNumber));

  nsCOMPtr<nsIRunnable> startRunnable = new StartResponse(mInterceptedChannel,
                                                          ir,
                                                          worker->GetChannelInfo(),
                                                          mScriptSpec,
                                                          responseURL,
                                                          Move(closure));

  nsCOMPtr<nsIInputStream> body;
  ir->GetUnfilteredBody(getter_AddRefs(body));
  // Errors and redirects may not have a body.
  if (body) {
    IgnoredErrorResult error;
    response->SetBodyUsed(aCx, error);





     *   empty body is assumed.
     * - A callback may be optionally passed.  It will be invoked
     *   when the body is complete.  For a nullptr body this may be
     *   synchronously on the current thread.  Otherwise it will be invoked
     *   asynchronously on the current thread.
     * - The caller may optionally pass a spec for a URL that this response
     *   originates from; an empty string will cause the original
     *   intercepted request's URL to be used instead.
     * - The redirected flag is false will cause the channel do an internal
     *   redirect when the original intercepted reauest's URL is different from
     *   the response's URL. The flag is true will cause the chaanel do a real
     *   redirect when the URLs are different.
     */
    void startSynthesizedResponse(in nsIInputStream body,
                                  in nsIInterceptedBodyCallback callback,
                                  in ACString finalURLSpec,
                                  in bool redirected);

    /**
     * Instruct a channel that has been intercepted that response synthesis
     * has completed and all outstanding resources can be closed.
     */
    void finishSynthesizedResponse();

    /**





  }

  if (NS_FAILED(rv))
    OnRedirectVerifyCallback(rv);
}

void
HttpChannelChild::BeginNonIPCRedirect(nsIURI* responseURI,
                                      const nsHttpResponseHead* responseHead,
                                      const bool aRealRedirect)
{
  LOG(("HttpChannelChild::BeginNonIPCRedirect [this=%p]\n", this));

  const uint32_t redirectFlag =
    aRealRedirect ? nsIChannelEventSink::REDIRECT_TEMPORARY
                  : nsIChannelEventSink::REDIRECT_INTERNAL;


  nsCOMPtr<nsIChannel> newChannel;
  nsresult rv = SetupRedirect(responseURI,
                              responseHead,
                              redirectFlag,
                              getter_AddRefs(newChannel));

  if (NS_SUCCEEDED(rv)) {
    // Ensure that the new channel shares the original channel's security information,
    // since it won't be provided via IPC. In particular, if the target of this redirect
    // is a synthesized response that has its own security info, the pre-redirect channel
    // has already received it and it must be propagated to the post-redirect channel.
    nsCOMPtr<nsIHttpChannelChild> channelChild = do_QueryInterface(newChannel);

      httpChannelChild->OverrideSecurityInfoForNonIPCRedirect(mSecurityInfo);
    }

    nsCOMPtr<nsIEventTarget> target = GetNeckoTarget();
    MOZ_ASSERT(target);

    rv = gHttpHandler->AsyncOnChannelRedirect(this,
                                              newChannel,
                                              redirectFlag,
                                              target);
  }

  if (NS_FAILED(rv))
    OnRedirectVerifyCallback(rv);
}

void





  // response headers.
  MOZ_MUST_USE nsresult SetupRedirect(nsIURI* uri,
                                      const nsHttpResponseHead* responseHead,
                                      const uint32_t& redirectFlags,
                                      nsIChannel** outChannel);

  // Perform a redirection without communicating with the parent process at all.
  void BeginNonIPCRedirect(nsIURI* responseURI,
                           const nsHttpResponseHead* responseHead,
                           const bool realRedirect);

  // Override the default security info pointer during a non-IPC redirection.
  void OverrideSecurityInfoForNonIPCRedirect(nsISupports* securityInfo);

  // Collect telemetry for the successful rate of OMT.
  void CollectOMTTelemetry();

  // The result of RetargetDeliveryTo for this channel.





    , mChannel(aChannel)
  {
  }

  NS_IMETHOD Run() override
  {
    // The URL passed as an argument here doesn't matter, since the child will
    // receive a redirection notification as a result of this synthesized response.
    mChannel->StartSynthesizedResponse(nullptr, nullptr, EmptyCString(), false);
    mChannel->FinishSynthesizedResponse();
    return NS_OK;
  }
};

NS_IMETHODIMP
HttpChannelParentListener::ChannelIntercepted(nsIInterceptedChannel* aChannel)
{





  }

  return DoSynthesizeHeader(aName, aValue);
}

NS_IMETHODIMP
InterceptedChannelContent::StartSynthesizedResponse(nsIInputStream* aBody,
                                                    nsIInterceptedBodyCallback* aBodyCallback,
                                                    const nsACString& aFinalURLSpec,
                                                    bool aRedirected)
{
  if (NS_WARN_IF(mClosed)) {
    return NS_ERROR_NOT_AVAILABLE;
  }

  EnsureSynthesizedResponse();

  nsCOMPtr<nsIURI> originalURI;

  } else {
    responseURI = originalURI;
  }

  bool equal = false;
  originalURI->Equals(responseURI, &equal);
  if (!equal) {
    mChannel->ForceIntercepted(aBody, aBodyCallback);
    // If the response has been redirected, do the real redirect. Otherwise, do
    // an internal redirect.
    mChannel->BeginNonIPCRedirect(responseURI, *mSynthesizedResponseHead.ptr(),
                                  aRedirected);
  } else {
    mChannel->OverrideWithSynthesizedResponse(mSynthesizedResponseHead.ref(),
                                              aBody, aBodyCallback,
                                              mStreamListener);
  }

  return NS_OK;
}





  InterceptedChannelContent(HttpChannelChild* aChannel,
                            nsINetworkInterceptController* aController,
                            InterceptStreamListener* aListener,
                            bool aSecureUpgrade);

  NS_IMETHOD ResetInterception() override;
  NS_IMETHOD StartSynthesizedResponse(nsIInputStream* aBody,
                                      nsIInterceptedBodyCallback* aBodyCallback,
                                      const nsACString& aFinalURLSpec,
                                      bool aRedirected) override;
  NS_IMETHOD FinishSynthesizedResponse() override;
  NS_IMETHOD GetChannel(nsIChannel** aChannel) override;
  NS_IMETHOD GetSecureUpgradedChannelURI(nsIURI** aURI) override;
  NS_IMETHOD SynthesizeStatus(uint16_t aStatus, const nsACString& aReason) override;
  NS_IMETHOD SynthesizeHeader(const nsACString& aName, const nsACString& aValue) override;
  NS_IMETHOD CancelInterception(nsresult aStatus) override;
  NS_IMETHOD SetChannelInfo(mozilla::dom::ChannelInfo* aChannelInfo) override;
  NS_IMETHOD GetInternalContentPolicyType(nsContentPolicyType *aInternalContentPolicyType) override;





  if (NS_WARN_IF(NS_FAILED(rv))) {
    OnRedirectVerifyCallback(rv);
  }

  return rv;
}

nsresult
InterceptedHttpChannel::RedirectForResponse(nsIURI* aResponseURI,
                                            const bool aRealRedirect)
{
  // Perform a real/internal redirect to another InterceptedHttpChannel using
  // the given cross-origin response URL.  The resulting channel will then
  // process the synthetic response as normal.  This extra redirect is
  // performed so that listeners treat the result as unsafe cross-origin
  // data.

  nsresult rv = NS_OK;

  // We want to pass ownership of the body callback to the new synthesized

    CreateForSynthesis(mResponseHead, mBodyReader, bodyCallback,
                       mChannelCreationTime, mChannelCreationTimestamp,
                       mAsyncOpenTime);

  rv = newChannel->Init(aResponseURI, mCaps,
                        static_cast<nsProxyInfo*>(mProxyInfo.get()),
                        mProxyResolveFlags, mProxyURI, mChannelId);

  uint32_t flags = aRealRedirect ? nsIChannelEventSink::REDIRECT_TEMPORARY
                                 : nsIChannelEventSink::REDIRECT_INTERNAL;

  nsCOMPtr<nsILoadInfo> redirectLoadInfo =
    CloneLoadInfoForRedirect(aResponseURI, flags);
  newChannel->SetLoadInfo(redirectLoadInfo);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = SetupReplacementChannel(aResponseURI, newChannel, true, flags);
  NS_ENSURE_SUCCESS(rv, rv);

  nsresult rv = mSynthesizedResponseHead->ParseHeaderLine(header);
  NS_ENSURE_SUCCESS(rv, rv);
  return NS_OK;
}

NS_IMETHODIMP
InterceptedHttpChannel::StartSynthesizedResponse(nsIInputStream* aBody,
                                                 nsIInterceptedBodyCallback* aBodyCallback,
                                                 const nsACString& aFinalURLSpec,
                                                 bool aRedirected)
{
  nsresult rv = NS_OK;

  auto autoCleanup = MakeScopeExit([&] {
    // Auto-cancel on failure.  Do this first to get mStatus set, if necessary.
    if (NS_FAILED(rv)) {
      Cancel(rv);
    }

    NS_ENSURE_SUCCESS(rv, rv);
  } else {
    responseURI = mURI;
  }

  bool equal = false;
  Unused << mURI->Equals(responseURI, &equal);
  if (!equal) {
    rv = RedirectForResponse(responseURI, aRedirected);
    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;
  }

  rv = StartPump();
  NS_ENSURE_SUCCESS(rv, rv);






  AsyncOpenInternal();

  bool
  ShouldRedirect() const;

  nsresult
  FollowSyntheticRedirect();

  // If the response's URL is different from the request's, do a real redirect
  // while the response has not been redirected yet. Otherwise, do an internal
  // redirect.
  nsresult
  RedirectForResponse(nsIURI* aResponseURI, const bool aRealRedirect);

  nsresult
  StartPump();

  nsresult
  OpenRedirectChannel();

  void

Return to bug 1222008