The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

 /* vim:set expandtab ts=4 sw=4 sts=4 cin: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 // HttpLog.h should generally be included first

 #include "HttpLog.h"

 #include "nsHttp.h"

 #include "nsHttpChannel.h"

 #include "nsHttpHandler.h"

 #include "nsIApplicationCacheService.h"

 #include "nsIApplicationCacheContainer.h"

 #include "nsICacheStorageService.h"

 #include "nsICacheStorage.h"

 #include "nsICacheEntry.h"

 #include "nsICryptoHash.h"

 #include "nsIStringBundle.h"

 #include "nsIStreamListenerTee.h"

 #include "nsISeekableStream.h"

 #include "nsILoadGroupChild.h"

 #include "nsIProtocolProxyService2.h"

 #include "nsMimeTypes.h"

 #include "nsNetUtil.h"

 #include "prprf.h"

 #include "prnetdb.h"

 #include "nsEscape.h"

 #include "nsStreamUtils.h"

 #include "nsIOService.h"

 #include "nsDNSPrefetch.h"

 #include "nsChannelClassifier.h"

 #include "nsIRedirectResultListener.h"

 #include "mozilla/TimeStamp.h"

 #include "nsError.h"

 #include "nsPrintfCString.h"

 #include "nsAlgorithm.h"

 #include "GeckoProfiler.h"

 #include "nsIConsoleService.h"

 #include "mozilla/Attributes.h"

 #include "mozilla/VisualEventTracer.h"

 #include "nsISSLSocketControl.h"

 #include "sslt.h"

 #include "nsContentUtils.h"

 #include "nsIPermissionManager.h"

 #include "nsIPrincipal.h"

 #include "nsIScriptSecurityManager.h"

 #include "nsISSLStatus.h"

 #include "nsISSLStatusProvider.h"

 #include "LoadContextInfo.h"

 #include "netCore.h"

 #include "nsHttpTransaction.h"

 #include "nsICacheEntryDescriptor.h"

 #include "nsICancelable.h"

 #include "nsIHttpChannelAuthProvider.h"

 #include "nsIHttpEventSink.h"

 #include "nsIPrompt.h"

 #include "nsInputStreamPump.h"

 #include "nsURLHelper.h"

 #include "nsISocketTransport.h"

 #include "nsICacheSession.h"

 #include "nsIStreamConverterService.h"

 #include "nsISiteSecurityService.h"

 #include "nsCRT.h"

 #include "nsPIDOMWindow.h"

 #include "nsPerformance.h"

 #include "CacheObserver.h"

 #include "mozilla/Telemetry.h"

 #include "mozIThirdPartyUtil.h"

 namespace mozilla { namespace net {

 namespace {

 // True if the local cache should be bypassed when processing a request.

 #define BYPASS_LOCAL_CACHE(loadFlags) \

         (loadFlags & (nsIRequest::LOAD_BYPASS_CACHE | \

                       nsICachingChannel::LOAD_BYPASS_LOCAL_CACHE))

 #define CACHE_FILE_GONE(result) \

         ((result) == NS_ERROR_FILE_NOT_FOUND || \

          (result) == NS_ERROR_FILE_CORRUPTED)

 static NS_DEFINE_CID(kStreamListenerTeeCID, NS_STREAMLISTENERTEE_CID);

 static NS_DEFINE_CID(kStreamTransportServiceCID,

                      NS_STREAMTRANSPORTSERVICE_CID);

 enum CacheDisposition {

     kCacheHit = 1,

     kCacheHitViaReval = 2,

     kCacheMissedViaReval = 3,

     kCacheMissed = 4

 };

 void

 AccumulateCacheHitTelemetry(CacheDisposition hitOrMiss)

 {

     if (!CacheObserver::UseNewCache()) {

         Telemetry::Accumulate(Telemetry::HTTP_CACHE_DISPOSITION_2, hitOrMiss);

     }

     else {

         Telemetry::Accumulate(Telemetry::HTTP_CACHE_DISPOSITION_2_V2, hitOrMiss);

         int32_t experiment = CacheObserver::HalfLifeExperiment();

         if (experiment > 0 && hitOrMiss == kCacheMissed) {

             Telemetry::Accumulate(Telemetry::HTTP_CACHE_MISS_HALFLIFE_EXPERIMENT,

                                   experiment - 1);

         }

     }

 }

 // Computes and returns a SHA1 hash of the input buffer. The input buffer

 // must be a null-terminated string.

 nsresult

 Hash(const char *buf, nsACString &hash)

 {

     nsresult rv;

     nsCOMPtr<nsICryptoHash> hasher

       = do_CreateInstance(NS_CRYPTO_HASH_CONTRACTID, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = hasher->Init(nsICryptoHash::SHA1);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = hasher->Update(reinterpret_cast<unsigned const char*>(buf),

                          strlen(buf));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = hasher->Finish(true, hash);

     NS_ENSURE_SUCCESS(rv, rv);

     return NS_OK;

 }

 bool IsRedirectStatus(uint32_t status)

 {

     // 305 disabled as a security measure (see bug 187996).

     return status == 300 || status == 301 || status == 302 || status == 303 ||

            status == 307 || status == 308;

 }

 // We only treat 3xx responses as redirects if they have a Location header and

 // the status code is in a whitelist.

 bool

 WillRedirect(const nsHttpResponseHead * response)

 {

     return IsRedirectStatus(response->Status()) &&

            response->PeekHeader(nsHttp::Location);

 }

 } // unnamed namespace

 class AutoRedirectVetoNotifier

 {

 public:

     AutoRedirectVetoNotifier(nsHttpChannel* channel) : mChannel(channel)

     {

       if (mChannel->mHasAutoRedirectVetoNotifier) {

         MOZ_CRASH("Nested AutoRedirectVetoNotifier on the stack");

         mChannel = nullptr;

         return;

       }

       mChannel->mHasAutoRedirectVetoNotifier = true;

     }

     ~AutoRedirectVetoNotifier() {ReportRedirectResult(false);}

     void RedirectSucceeded() {ReportRedirectResult(true);}

 private:

     nsHttpChannel* mChannel;

     void ReportRedirectResult(bool succeeded);

 };

 void

 AutoRedirectVetoNotifier::ReportRedirectResult(bool succeeded)

 {

     if (!mChannel)

         return;

     mChannel->mRedirectChannel = nullptr;

     nsCOMPtr<nsIRedirectResultListener> vetoHook;

     NS_QueryNotificationCallbacks(mChannel,

                                   NS_GET_IID(nsIRedirectResultListener),

                                   getter_AddRefs(vetoHook));

     nsHttpChannel* channel = mChannel;

     mChannel = nullptr;

     if (vetoHook)

         vetoHook->OnRedirectResult(succeeded);

     // Drop after the notification

     channel->mHasAutoRedirectVetoNotifier = false;

     MOZ_EVENT_TRACER_DONE(channel, "net::http::redirect-callbacks");

 }

 //-----------------------------------------------------------------------------

 // nsHttpChannel <public>

 //-----------------------------------------------------------------------------

 nsHttpChannel::nsHttpChannel()

     : HttpAsyncAborter<nsHttpChannel>(MOZ_THIS_IN_INITIALIZER_LIST())

     , mLogicalOffset(0)

     , mPostID(0)

     , mRequestTime(0)

     , mOfflineCacheLastModifiedTime(0)

     , mCachedContentIsValid(false)

     , mCachedContentIsPartial(false)

     , mTransactionReplaced(false)

     , mAuthRetryPending(false)

     , mProxyAuthPending(false)

     , mResuming(false)

     , mInitedCacheEntry(false)

     , mFallbackChannel(false)

     , mCustomConditionalRequest(false)

     , mFallingBack(false)

     , mWaitingForRedirectCallback(false)

     , mRequestTimeInitialized(false)

     , mCacheEntryIsReadOnly(false)

     , mCacheEntryIsWriteOnly(false)

     , mCacheEntriesToWaitFor(0)

     , mHasQueryString(0)

     , mConcurentCacheAccess(0)

     , mIsPartialRequest(0)

     , mHasAutoRedirectVetoNotifier(0)

     , mDidReval(false)

     , mForcePending(false)

 {

     LOG(("Creating nsHttpChannel [this=%p]\n", this));

     mChannelCreationTime = PR_Now();

     mChannelCreationTimestamp = TimeStamp::Now();

 }

 nsHttpChannel::~nsHttpChannel()

 {

     LOG(("Destroying nsHttpChannel [this=%p]\n", this));

     if (mAuthProvider)

         mAuthProvider->Disconnect(NS_ERROR_ABORT);

 }

 nsresult

 nsHttpChannel::Init(nsIURI *uri,

                     uint32_t caps,

                     nsProxyInfo *proxyInfo,

                     uint32_t proxyResolveFlags,

                     nsIURI *proxyURI)

 {

 #ifdef MOZ_VISUAL_EVENT_TRACER

     nsAutoCString url;

     uri->GetAsciiSpec(url);

     MOZ_EVENT_TRACER_NAME_OBJECT(this, url.get());

 #endif

     nsresult rv = HttpBaseChannel::Init(uri, caps, proxyInfo,

                                         proxyResolveFlags, proxyURI);

     if (NS_FAILED(rv))

         return rv;

     LOG(("nsHttpChannel::Init [this=%p]\n", this));

     return rv;

 }

 //-----------------------------------------------------------------------------

 // nsHttpChannel <private>

 //-----------------------------------------------------------------------------

 nsresult

 nsHttpChannel::Connect()

 {

     nsresult rv;

     LOG(("nsHttpChannel::Connect [this=%p]\n", this));

     // Even if we're in private browsing mode, we still enforce existing STS

     // data (it is read-only).

     // if the connection is not using SSL and either the exact host matches or

     // a superdomain wants to force HTTPS, do it.

     bool usingSSL = false;

     rv = mURI->SchemeIs("https", &usingSSL);

     NS_ENSURE_SUCCESS(rv,rv);

     if (!usingSSL) {

         // enforce Strict-Transport-Security

         nsISiteSecurityService* sss = gHttpHandler->GetSSService();

         NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY);

         bool isStsHost = false;

         uint32_t flags = mPrivateBrowsing ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;

         rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, mURI, flags,

                               &isStsHost);

         // if the SSS check fails, it's likely because this load is on a

         // malformed URI or something else in the setup is wrong, so any error

         // should be reported.

         NS_ENSURE_SUCCESS(rv, rv);

         if (isStsHost) {

             LOG(("nsHttpChannel::Connect() STS permissions found\n"));

             return AsyncCall(&nsHttpChannel::HandleAsyncRedirectChannelToHttps);

         }

     }

     // ensure that we are using a valid hostname

     if (!net_IsValidHostName(nsDependentCString(mConnectionInfo->Host())))

         return NS_ERROR_UNKNOWN_HOST;

     // Finalize ConnectionInfo flags before SpeculativeConnect

     mConnectionInfo->SetAnonymous((mLoadFlags & LOAD_ANONYMOUS) != 0);

     mConnectionInfo->SetPrivate(mPrivateBrowsing);

     // Consider opening a TCP connection right away

     RetrieveSSLOptions();

     SpeculativeConnect();

     // Don't allow resuming when cache must be used

     if (mResuming && (mLoadFlags & LOAD_ONLY_FROM_CACHE)) {

         LOG(("Resuming from cache is not supported yet"));

         return NS_ERROR_DOCUMENT_NOT_CACHED;

     }

     if (!gHttpHandler->UseCache()) {

         return ContinueConnect();

     }

     // open a cache entry for this channel...

     rv = OpenCacheEntry(usingSSL);

     // do not continue if asyncOpenCacheEntry is in progress

     if (mCacheEntriesToWaitFor) {

         MOZ_ASSERT(NS_SUCCEEDED(rv), "Unexpected state");

         return NS_OK;

     }

     if (NS_FAILED(rv)) {

         LOG(("OpenCacheEntry failed [rv=%x]\n", rv));

         // if this channel is only allowed to pull from the cache, then

         // we must fail if we were unable to open a cache entry.

         if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {

             // If we have a fallback URI (and we're not already

             // falling back), process the fallback asynchronously.

             if (!mFallbackChannel && !mFallbackKey.IsEmpty()) {

                 return AsyncCall(&nsHttpChannel::HandleAsyncFallback);

             }

             return NS_ERROR_DOCUMENT_NOT_CACHED;

         }

         // otherwise, let's just proceed without using the cache.

     }

     return ContinueConnect();

 }

 nsresult

 nsHttpChannel::ContinueConnect()

 {

     // we may or may not have a cache entry at this point

     if (mCacheEntry) {

         // read straight from the cache if possible...

         if (mCachedContentIsValid) {

             nsRunnableMethod<nsHttpChannel> *event = nullptr;

             if (!mCachedContentIsPartial) {

                 AsyncCall(&nsHttpChannel::AsyncOnExamineCachedResponse, &event);

             }

             nsresult rv = ReadFromCache(true);

             if (NS_FAILED(rv) && event) {

                 event->Revoke();

             }

             AccumulateCacheHitTelemetry(kCacheHit);

             return rv;

         }

         else if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {

             // the cache contains the requested resource, but it must be

             // validated before we can reuse it.  since we are not allowed

             // to hit the net, there's nothing more to do.  the document

             // is effectively not in the cache.

             LOG(("  !mCachedContentIsValid && mLoadFlags & LOAD_ONLY_FROM_CACHE"));

             return NS_ERROR_DOCUMENT_NOT_CACHED;

         }

     }

     else if (mLoadFlags & LOAD_ONLY_FROM_CACHE) {

         // If we have a fallback URI (and we're not already

         // falling back), process the fallback asynchronously.

         if (!mFallbackChannel && !mFallbackKey.IsEmpty()) {

             return AsyncCall(&nsHttpChannel::HandleAsyncFallback);

         }

         LOG(("  !mCachedEntry && mLoadFlags & LOAD_ONLY_FROM_CACHE"));

         return NS_ERROR_DOCUMENT_NOT_CACHED;

     }

     if (mLoadFlags & LOAD_NO_NETWORK_IO) {

         LOG(("  mLoadFlags & LOAD_NO_NETWORK_IO"));

         return NS_ERROR_DOCUMENT_NOT_CACHED;

     }

     // hit the net...

     nsresult rv = SetupTransaction();

     if (NS_FAILED(rv)) return rv;

     rv = gHttpHandler->InitiateTransaction(mTransaction, mPriority);

     if (NS_FAILED(rv)) return rv;

     rv = mTransactionPump->AsyncRead(this, nullptr);

     if (NS_FAILED(rv)) return rv;

     uint32_t suspendCount = mSuspendCount;

     while (suspendCount--)

         mTransactionPump->Suspend();

     return NS_OK;

 }

 void

 nsHttpChannel::SpeculativeConnect()

 {

     // Before we take the latency hit of dealing with the cache, try and

     // get the TCP (and SSL) handshakes going so they can overlap.

     // don't speculate on uses of the offline application cache,

     // if we are offline, when doing http upgrade (i.e. websockets bootstrap),

     // or if we can't do keep-alive (because then we couldn't reuse

     // the speculative connection anyhow).

     if (mApplicationCache || gIOService->IsOffline() ||

         mUpgradeProtocolCallback || !(mCaps & NS_HTTP_ALLOW_KEEPALIVE))

         return;

     // LOAD_ONLY_FROM_CACHE and LOAD_NO_NETWORK_IO must not hit network.

     // LOAD_FROM_CACHE and LOAD_CHECK_OFFLINE_CACHE are unlikely to hit network,

     // so skip preconnects for them.

     if (mLoadFlags & (LOAD_ONLY_FROM_CACHE | LOAD_FROM_CACHE |

                       LOAD_NO_NETWORK_IO | LOAD_CHECK_OFFLINE_CACHE))

         return;

     nsCOMPtr<nsIInterfaceRequestor> callbacks;

     NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,

                                            getter_AddRefs(callbacks));

     if (!callbacks)

         return;

     gHttpHandler->SpeculativeConnect(

         mConnectionInfo, callbacks,

         mCaps & (NS_HTTP_ALLOW_RSA_FALSESTART | NS_HTTP_DISALLOW_SPDY));

 }

 void

 nsHttpChannel::DoNotifyListenerCleanup()

 {

     // We don't need this info anymore

     CleanRedirectCacheChainIfNecessary();

 }

 void

 nsHttpChannel::HandleAsyncRedirect()

 {

     NS_PRECONDITION(!mCallOnResume, "How did that happen?");

     if (mSuspendCount) {

         LOG(("Waiting until resume to do async redirect [this=%p]\n", this));

         mCallOnResume = &nsHttpChannel::HandleAsyncRedirect;

         return;

     }

     nsresult rv = NS_OK;

     LOG(("nsHttpChannel::HandleAsyncRedirect [this=%p]\n", this));

     // since this event is handled asynchronously, it is possible that this

     // channel could have been canceled, in which case there would be no point

     // in processing the redirect.

     if (NS_SUCCEEDED(mStatus)) {

         PushRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncRedirect);

         rv = AsyncProcessRedirection(mResponseHead->Status());

         if (NS_FAILED(rv)) {

             PopRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncRedirect);

             // TODO: if !DoNotRender3xxBody(), render redirect body instead.

             // But first we need to cache 3xx bodies (bug 748510)

             ContinueHandleAsyncRedirect(rv);

         }

     }

     else {

         ContinueHandleAsyncRedirect(NS_OK);

     }

 }

 nsresult

 nsHttpChannel::ContinueHandleAsyncRedirect(nsresult rv)

 {

     if (NS_FAILED(rv)) {

         // If AsyncProcessRedirection fails, then we have to send out the

         // OnStart/OnStop notifications.

         LOG(("ContinueHandleAsyncRedirect got failure result [rv=%x]\n", rv));

         mStatus = rv;

         DoNotifyListener();

     }

     // close the cache entry.  Blow it away if we couldn't process the redirect

     // for some reason (the cache entry might be corrupt).

     if (mCacheEntry) {

         if (NS_FAILED(rv))

             mCacheEntry->AsyncDoom(nullptr);

     }

     CloseCacheEntry(false);

     mIsPending = false;

     if (mLoadGroup)

         mLoadGroup->RemoveRequest(this, nullptr, mStatus);

     return NS_OK;

 }

 void

 nsHttpChannel::HandleAsyncNotModified()

 {

     NS_PRECONDITION(!mCallOnResume, "How did that happen?");

     if (mSuspendCount) {

         LOG(("Waiting until resume to do async not-modified [this=%p]\n",

              this));

         mCallOnResume = &nsHttpChannel::HandleAsyncNotModified;

         return;

     }

     LOG(("nsHttpChannel::HandleAsyncNotModified [this=%p]\n", this));

     DoNotifyListener();

     CloseCacheEntry(true);

     mIsPending = false;

     if (mLoadGroup)

         mLoadGroup->RemoveRequest(this, nullptr, mStatus);

 }

 void

 nsHttpChannel::HandleAsyncFallback()

 {

     NS_PRECONDITION(!mCallOnResume, "How did that happen?");

     if (mSuspendCount) {

         LOG(("Waiting until resume to do async fallback [this=%p]\n", this));

         mCallOnResume = &nsHttpChannel::HandleAsyncFallback;

         return;

     }

     nsresult rv = NS_OK;

     LOG(("nsHttpChannel::HandleAsyncFallback [this=%p]\n", this));

     // since this event is handled asynchronously, it is possible that this

     // channel could have been canceled, in which case there would be no point

     // in processing the fallback.

     if (!mCanceled) {

         PushRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncFallback);

         bool waitingForRedirectCallback;

         rv = ProcessFallback(&waitingForRedirectCallback);

         if (waitingForRedirectCallback)

             return;

         PopRedirectAsyncFunc(&nsHttpChannel::ContinueHandleAsyncFallback);

     }

     ContinueHandleAsyncFallback(rv);

 }

 nsresult

 nsHttpChannel::ContinueHandleAsyncFallback(nsresult rv)

 {

     if (!mCanceled && (NS_FAILED(rv) || !mFallingBack)) {

         // If ProcessFallback fails, then we have to send out the

         // OnStart/OnStop notifications.

         LOG(("ProcessFallback failed [rv=%x, %d]\n", rv, mFallingBack));

         mStatus = NS_FAILED(rv) ? rv : NS_ERROR_DOCUMENT_NOT_CACHED;

         DoNotifyListener();

     }

     mIsPending = false;

     if (mLoadGroup)

         mLoadGroup->RemoveRequest(this, nullptr, mStatus);

     return rv;

 }

 void

 nsHttpChannel::SetupTransactionLoadGroupInfo()

 {

     // Find the loadgroup at the end of the chain in order

     // to make sure all channels derived from the load group

     // use the same connection scope.

     nsCOMPtr<nsILoadGroupChild> childLoadGroup = do_QueryInterface(mLoadGroup);

     if (!childLoadGroup)

         return;

     nsCOMPtr<nsILoadGroup> rootLoadGroup;

     childLoadGroup->GetRootLoadGroup(getter_AddRefs(rootLoadGroup));

     if (!rootLoadGroup)

         return;

     // Set the load group connection scope on the transaction

     nsCOMPtr<nsILoadGroupConnectionInfo> ci;

     rootLoadGroup->GetConnectionInfo(getter_AddRefs(ci));

     if (ci)

         mTransaction->SetLoadGroupConnectionInfo(ci);

 }

 void

 nsHttpChannel::RetrieveSSLOptions()

 {

     if (!IsHTTPS() || mPrivateBrowsing)

         return;

     nsIPrincipal *principal = GetPrincipal();

     if (!principal)

         return;

     nsCOMPtr<nsIPermissionManager> permMgr =

         do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);

     if (!permMgr)

         return;

     uint32_t perm;

     nsresult rv = permMgr->TestPermissionFromPrincipal(principal,

                                                        "falsestart-rsa", &perm);

     if (NS_SUCCEEDED(rv) && perm == nsIPermissionManager::ALLOW_ACTION) {

         LOG(("nsHttpChannel::RetrieveSSLOptions [this=%p] "

              "falsestart-rsa permission found\n", this));

         mCaps |= NS_HTTP_ALLOW_RSA_FALSESTART;

     }

 }

 static bool

 SafeForPipelining(nsHttpRequestHead::ParsedMethodType method,

                   const nsCString &methodString)

 {

     if (method == nsHttpRequestHead::kMethod_Get ||

         method == nsHttpRequestHead::kMethod_Head ||

         method == nsHttpRequestHead::kMethod_Options) {

         return true;

     }

     if (method != nsHttpRequestHead::kMethod_Custom) {

         return false;

     }

     return (!strcmp(methodString.get(), "PROPFIND") ||

             !strcmp(methodString.get(), "PROPPATCH"));

 }

 nsresult

 nsHttpChannel::SetupTransaction()

 {

     LOG(("nsHttpChannel::SetupTransaction [this=%p]\n", this));

     NS_ENSURE_TRUE(!mTransaction, NS_ERROR_ALREADY_INITIALIZED);

     nsresult rv;

     if (mCaps & NS_HTTP_ALLOW_PIPELINING) {

         //

         // disable pipelining if:

         //   (1) pipelining has been disabled by config

         //   (2) pipelining has been disabled by connection mgr info

         //   (3) request corresponds to a top-level document load (link click)

         //   (4) request method is non-idempotent

         //   (5) request is marked slow (e.g XHR)

         //

         if (!mAllowPipelining ||

            (mLoadFlags & (LOAD_INITIAL_DOCUMENT_URI | INHIBIT_PIPELINE)) ||

             !SafeForPipelining(mRequestHead.ParsedMethod(), mRequestHead.Method())) {

             LOG(("  pipelining disallowed\n"));

             mCaps &= ~NS_HTTP_ALLOW_PIPELINING;

         }

     }

     if (!mAllowSpdy)

         mCaps |= NS_HTTP_DISALLOW_SPDY;

     // Use the URI path if not proxying (transparent proxying such as proxy

     // CONNECT does not count here). Also figure out what HTTP version to use.

     nsAutoCString buf, path;

     nsCString* requestURI;

     if (mConnectionInfo->UsingConnect() ||

         !mConnectionInfo->UsingHttpProxy()) {

         rv = mURI->GetPath(path);

         if (NS_FAILED(rv)) return rv;

         // path may contain UTF-8 characters, so ensure that they're escaped.

         if (NS_EscapeURL(path.get(), path.Length(), esc_OnlyNonASCII, buf))

             requestURI = &buf;

         else

             requestURI = &path;

         mRequestHead.SetVersion(gHttpHandler->HttpVersion());

     }

     else {

         rv = mURI->GetUserPass(buf);

         if (NS_FAILED(rv)) return rv;

         if (!buf.IsEmpty() && ((strncmp(mSpec.get(), "http:", 5) == 0) ||

                                 strncmp(mSpec.get(), "https:", 6) == 0)) {

             nsCOMPtr<nsIURI> tempURI;

             rv = mURI->Clone(getter_AddRefs(tempURI));

             if (NS_FAILED(rv)) return rv;

             rv = tempURI->SetUserPass(EmptyCString());

             if (NS_FAILED(rv)) return rv;

             rv = tempURI->GetAsciiSpec(path);

             if (NS_FAILED(rv)) return rv;

             requestURI = &path;

         }

         else

             requestURI = &mSpec;

         mRequestHead.SetVersion(gHttpHandler->ProxyHttpVersion());

     }

     // trim off the #ref portion if any...

     int32_t ref = requestURI->FindChar('#');

     if (ref != kNotFound)

         requestURI->SetLength(ref);

     mRequestHead.SetRequestURI(*requestURI);

     // set the request time for cache expiration calculations

     mRequestTime = NowInSeconds();

     mRequestTimeInitialized = true;

     // if doing a reload, force end-to-end

     if (mLoadFlags & LOAD_BYPASS_CACHE) {

         // We need to send 'Pragma:no-cache' to inhibit proxy caching even if

         // no proxy is configured since we might be talking with a transparent

         // proxy, i.e. one that operates at the network level.  See bug #14772.

         mRequestHead.SetHeaderOnce(nsHttp::Pragma, "no-cache", true);

         // If we're configured to speak HTTP/1.1 then also send 'Cache-control:

         // no-cache'

         if (mRequestHead.Version() >= NS_HTTP_VERSION_1_1)

             mRequestHead.SetHeaderOnce(nsHttp::Cache_Control, "no-cache", true);

     }

     else if ((mLoadFlags & VALIDATE_ALWAYS) && !mCacheEntryIsWriteOnly) {

         // We need to send 'Cache-Control: max-age=0' to force each cache along

         // the path to the origin server to revalidate its own entry, if any,

         // with the next cache or server.  See bug #84847.

         //

         // If we're configured to speak HTTP/1.0 then just send 'Pragma: no-cache'

         if (mRequestHead.Version() >= NS_HTTP_VERSION_1_1)

             mRequestHead.SetHeaderOnce(nsHttp::Cache_Control, "max-age=0", true);

         else

             mRequestHead.SetHeaderOnce(nsHttp::Pragma, "no-cache", true);

     }

     if (mResuming) {

         char byteRange[32];

         PR_snprintf(byteRange, sizeof(byteRange), "bytes=%llu-", mStartPos);

         mRequestHead.SetHeader(nsHttp::Range, nsDependentCString(byteRange));

         if (!mEntityID.IsEmpty()) {

             // Also, we want an error if this resource changed in the meantime

             // Format of the entity id is: escaped_etag/size/lastmod

             nsCString::const_iterator start, end, slash;

             mEntityID.BeginReading(start);

             mEntityID.EndReading(end);

             mEntityID.BeginReading(slash);

             if (FindCharInReadable('/', slash, end)) {

                 nsAutoCString ifMatch;

                 mRequestHead.SetHeader(nsHttp::If_Match,

                         NS_UnescapeURL(Substring(start, slash), 0, ifMatch));

                 ++slash; // Incrementing, so that searching for '/' won't find

                          // the same slash again

             }

             if (FindCharInReadable('/', slash, end)) {

                 mRequestHead.SetHeader(nsHttp::If_Unmodified_Since,

                         Substring(++slash, end));

             }

         }

     }

     // create wrapper for this channel's notification callbacks

     nsCOMPtr<nsIInterfaceRequestor> callbacks;

     NS_NewNotificationCallbacksAggregation(mCallbacks, mLoadGroup,

                                            getter_AddRefs(callbacks));

     if (!callbacks)

         return NS_ERROR_OUT_OF_MEMORY;

     // create the transaction object

     mTransaction = new nsHttpTransaction();

     if (!mTransaction)

         return NS_ERROR_OUT_OF_MEMORY;

     // See bug #466080. Transfer LOAD_ANONYMOUS flag to socket-layer.

     if (mLoadFlags & LOAD_ANONYMOUS)

         mCaps |= NS_HTTP_LOAD_ANONYMOUS;

     if (mTimingEnabled)

         mCaps |= NS_HTTP_TIMING_ENABLED;

     if (mUpgradeProtocolCallback) {

         mRequestHead.SetHeader(nsHttp::Upgrade, mUpgradeProtocol, false);

         mRequestHead.SetHeaderOnce(nsHttp::Connection,

                                    nsHttp::Upgrade.get(),

                                    true);

         mCaps |=  NS_HTTP_STICKY_CONNECTION;

         mCaps &= ~NS_HTTP_ALLOW_PIPELINING;

         mCaps &= ~NS_HTTP_ALLOW_KEEPALIVE;

         mCaps |=  NS_HTTP_DISALLOW_SPDY;

     }

     nsCOMPtr<nsIAsyncInputStream> responseStream;

     rv = mTransaction->Init(mCaps, mConnectionInfo, &mRequestHead,

                             mUploadStream, mUploadStreamHasHeaders,

                             NS_GetCurrentThread(), callbacks, this,

                             getter_AddRefs(responseStream));

     if (NS_FAILED(rv)) {

         mTransaction = nullptr;

         return rv;

     }

     SetupTransactionLoadGroupInfo();

     rv = nsInputStreamPump::Create(getter_AddRefs(mTransactionPump),

                                    responseStream);

     return rv;

 }

 // NOTE: This function duplicates code from nsBaseChannel. This will go away

 // once HTTP uses nsBaseChannel (part of bug 312760)

 static void

 CallTypeSniffers(void *aClosure, const uint8_t *aData, uint32_t aCount)

 {

   nsIChannel *chan = static_cast<nsIChannel*>(aClosure);

   nsAutoCString newType;

   NS_SniffContent(NS_CONTENT_SNIFFER_CATEGORY, chan, aData, aCount, newType);

   if (!newType.IsEmpty()) {

     chan->SetContentType(newType);

   }

 }

 nsresult

 nsHttpChannel::CallOnStartRequest()

 {

     nsresult rv;

     mTracingEnabled = false;

     // Allow consumers to override our content type

     if (mLoadFlags & LOAD_CALL_CONTENT_SNIFFERS) {

         // NOTE: We can have both a txn pump and a cache pump when the cache

         // content is partial. In that case, we need to read from the cache,

         // because that's the one that has the initial contents. If that fails

         // then give the transaction pump a shot.

         nsIChannel* thisChannel = static_cast<nsIChannel*>(this);

         bool typeSniffersCalled = false;

         if (mCachePump) {

           typeSniffersCalled =

             NS_SUCCEEDED(mCachePump->PeekStream(CallTypeSniffers, thisChannel));

         }

         if (!typeSniffersCalled && mTransactionPump) {

           mTransactionPump->PeekStream(CallTypeSniffers, thisChannel);

         }

     }

     bool shouldSniff = mResponseHead && (mResponseHead->ContentType().IsEmpty() ||

         ((mResponseHead->ContentType().EqualsLiteral(APPLICATION_OCTET_STREAM) &&

         (mLoadFlags & LOAD_TREAT_APPLICATION_OCTET_STREAM_AS_UNKNOWN))));

     if (shouldSniff) {

         MOZ_ASSERT(mConnectionInfo, "Should have connection info here");

         if (!mContentTypeHint.IsEmpty())

             mResponseHead->SetContentType(mContentTypeHint);

         else if (mResponseHead->Version() == NS_HTTP_VERSION_0_9 &&

                  mConnectionInfo->Port() != mConnectionInfo->DefaultPort())

             mResponseHead->SetContentType(NS_LITERAL_CSTRING(TEXT_PLAIN));

         else {

             // Uh-oh.  We had better find out what type we are!

             // XXX This does not work with content-encodings...  but

             // neither does applying the conversion from the URILoader

             nsCOMPtr<nsIStreamConverterService> serv;

             rv = gHttpHandler->

                 GetStreamConverterService(getter_AddRefs(serv));

             // If we failed, we just fall through to the "normal" case

             if (NS_SUCCEEDED(rv)) {

                 nsCOMPtr<nsIStreamListener> converter;

                 rv = serv->AsyncConvertData(UNKNOWN_CONTENT_TYPE,

                                             "*/*",

                                             mListener,

                                             mListenerContext,

                                             getter_AddRefs(converter));

                 if (NS_SUCCEEDED(rv)) {

                     mListener = converter;

                 }

             }

         }

     }

     if (mResponseHead && mResponseHead->ContentCharset().IsEmpty())

         mResponseHead->SetContentCharset(mContentCharsetHint);

     if (mResponseHead && mCacheEntry) {

         // If we have a cache entry, set its predicted size to ContentLength to

         // avoid caching an entry that will exceed the max size limit.

         rv = mCacheEntry->SetPredictedDataSize(

             mResponseHead->ContentLength());

         if (NS_ERROR_FILE_TOO_BIG == rv) {

           mCacheEntry = nullptr;

           LOG(("  entry too big, throwing away"));

         } else {

           NS_ENSURE_SUCCESS(rv, rv);

         }

     }

     LOG(("  calling mListener->OnStartRequest\n"));

     if (mListener) {

         rv = mListener->OnStartRequest(this, mListenerContext);

         if (NS_FAILED(rv))

             return rv;

     } else {

         NS_WARNING("OnStartRequest skipped because of null listener");

     }

     // install stream converter if required

     rv = ApplyContentConversions();

     if (NS_FAILED(rv)) return rv;

     rv = EnsureAssocReq();

     if (NS_FAILED(rv))

         return rv;

     // if this channel is for a download, close off access to the cache.

     if (mCacheEntry && mChannelIsForDownload) {

         mCacheEntry->AsyncDoom(nullptr);

         // We must keep the cache entry in case of partial request.

         // Concurrent access is the same, we need the entry in

         // OnStopRequest.

         if (!mCachedContentIsPartial && !mConcurentCacheAccess)

             CloseCacheEntry(false);

     }

     if (!mCanceled) {

         // create offline cache entry if offline caching was requested

         if (ShouldUpdateOfflineCacheEntry()) {

             LOG(("writing to the offline cache"));

             rv = InitOfflineCacheEntry();

             if (NS_FAILED(rv)) return rv;

             // InitOfflineCacheEntry may have closed mOfflineCacheEntry

             if (mOfflineCacheEntry) {

                 rv = InstallOfflineCacheListener();

                 if (NS_FAILED(rv)) return rv;

             }

         } else if (mApplicationCacheForWrite) {

             LOG(("offline cache is up to date, not updating"));

             CloseOfflineCacheEntry();

         }

     }

     return NS_OK;

 }

 nsresult

 nsHttpChannel::ProcessFailedProxyConnect(uint32_t httpStatus)

 {

     // Failure to set up a proxy tunnel via CONNECT means one of the following:

     // 1) Proxy wants authorization, or forbids.

     // 2) DNS at proxy couldn't resolve target URL.

     // 3) Proxy connection to target failed or timed out.

     // 4) Eve intercepted our CONNECT, and is replying with malicious HTML.

     //

     // Our current architecture would parse the proxy's response content with

     // the permission of the target URL.  Given #4, we must avoid rendering the

     // body of the reply, and instead give the user a (hopefully helpful)

     // boilerplate error page, based on just the HTTP status of the reply.

     MOZ_ASSERT(mConnectionInfo->UsingConnect(),

                "proxy connect failed but not using CONNECT?");

     nsresult rv;

     switch (httpStatus)

     {

     case 300: case 301: case 302: case 303: case 307: case 308:

         // Bad redirect: not top-level, or it's a POST, bad/missing Location,

         // or ProcessRedirect() failed for some other reason.  Legal

         // redirects that fail because site not available, etc., are handled

         // elsewhere, in the regular codepath.

         rv = NS_ERROR_CONNECTION_REFUSED;

         break;

     case 403: // HTTP/1.1: "Forbidden"

     case 407: // ProcessAuthentication() failed

     case 501: // HTTP/1.1: "Not Implemented"

         // user sees boilerplate Mozilla "Proxy Refused Connection" page.

         rv = NS_ERROR_PROXY_CONNECTION_REFUSED;

         break;

     // Squid sends 404 if DNS fails (regular 404 from target is tunneled)

     case 404: // HTTP/1.1: "Not Found"

     // RFC 2616: "some deployed proxies are known to return 400 or 500 when

     // DNS lookups time out."  (Squid uses 500 if it runs out of sockets: so

     // we have a conflict here).

     case 400: // HTTP/1.1 "Bad Request"

     case 500: // HTTP/1.1: "Internal Server Error"

         /* User sees: "Address Not Found: Firefox can't find the server at

          * www.foo.com."

          */

         rv = NS_ERROR_UNKNOWN_HOST;

         break;

     case 502: // HTTP/1.1: "Bad Gateway" (invalid resp from target server)

     // Squid returns 503 if target request fails for anything but DNS.

     case 503: // HTTP/1.1: "Service Unavailable"

         /* User sees: "Failed to Connect:

          *  Firefox can't establish a connection to the server at

          *  www.foo.com.  Though the site seems valid, the browser

          *  was unable to establish a connection."

          */

         rv = NS_ERROR_CONNECTION_REFUSED;

         break;

     // RFC 2616 uses 504 for both DNS and target timeout, so not clear what to

     // do here: picking target timeout, as DNS covered by 400/404/500

     case 504: // HTTP/1.1: "Gateway Timeout"

         // user sees: "Network Timeout: The server at www.foo.com

         //              is taking too long to respond."

         rv = NS_ERROR_NET_TIMEOUT;

         break;

     // Confused proxy server or malicious response

     default:

         rv = NS_ERROR_PROXY_CONNECTION_REFUSED;

         break;

     }

     LOG(("Cancelling failed proxy CONNECT [this=%p httpStatus=%u]\n",

          this, httpStatus));

     Cancel(rv);

     CallOnStartRequest();

     return rv;

 }

 /**

  * Decide whether or not to remember Strict-Transport-Security, and whether

  * or not to enforce channel integrity.

  *

  * @return NS_ERROR_FAILURE if there's security information missing even though

  *             it's an HTTPS connection.

  */

 nsresult

 nsHttpChannel::ProcessSTSHeader()

 {

     nsresult rv;

     bool isHttps = false;

     rv = mURI->SchemeIs("https", &isHttps);

     NS_ENSURE_SUCCESS(rv, rv);

     // If this channel is not loading securely, STS doesn't do anything.

     // The upgrade to HTTPS takes place earlier in the channel load process.

     if (!isHttps)

         return NS_OK;

     nsAutoCString asciiHost;

     rv = mURI->GetAsciiHost(asciiHost);

     NS_ENSURE_SUCCESS(rv, NS_OK);

     // If the channel is not a hostname, but rather an IP, STS doesn't do

     // anything.

     PRNetAddr hostAddr;

     if (PR_SUCCESS == PR_StringToNetAddr(asciiHost.get(), &hostAddr))

         return NS_OK;

     nsISiteSecurityService* sss = gHttpHandler->GetSSService();

     NS_ENSURE_TRUE(sss, NS_ERROR_OUT_OF_MEMORY);

     // mSecurityInfo may not always be present, and if it's not then it is okay

     // to just disregard any STS headers since we know nothing about the

     // security of the connection.

     NS_ENSURE_TRUE(mSecurityInfo, NS_OK);

     // Check the trustworthiness of the channel (are there any cert errors?)

     // If there are certificate errors, we still load the data, we just ignore

     // any STS headers that are present.

     bool tlsIsBroken = false;

     rv = sss->ShouldIgnoreHeaders(mSecurityInfo, &tlsIsBroken);

     NS_ENSURE_SUCCESS(rv, NS_OK);

     // If this was already an STS host, the connection should have been aborted

     // by the bad cert handler in the case of cert errors.  If it didn't abort the connection,

     // there's probably something funny going on.

     // If this wasn't an STS host, errors are allowed, but no more STS processing

     // will happen during the session.

     bool wasAlreadySTSHost;

     uint32_t flags =

       NS_UsePrivateBrowsing(this) ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;

     rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS, mURI, flags,

                           &wasAlreadySTSHost);

     // Failure here means STS is broken.  Don't prevent the load, but this

     // shouldn't fail.

     NS_ENSURE_SUCCESS(rv, NS_OK);

     MOZ_ASSERT(!(wasAlreadySTSHost && tlsIsBroken),

                "connection should have been aborted by nss-bad-cert-handler");

     // Any STS header is ignored if the channel is not trusted due to

     // certificate errors (STS Spec 7.1) -- there is nothing else to do, and

     // the load may progress.

     if (tlsIsBroken) {

         LOG(("STS: Transport layer is not trustworthy, ignoring "

              "STS headers and continuing load\n"));

         return NS_OK;

     }

     // If there's a STS header, process it (STS Spec 7.1).  At this point in

     // processing, the channel is trusted, so the header should not be ignored.

     const nsHttpAtom atom = nsHttp::ResolveAtom("Strict-Transport-Security");

     nsAutoCString stsHeader;

     rv = mResponseHead->GetHeader(atom, stsHeader);

     if (rv == NS_ERROR_NOT_AVAILABLE) {

         LOG(("STS: No STS header, continuing load.\n"));

         return NS_OK;

     }

     // All other failures are fatal.

     NS_ENSURE_SUCCESS(rv, rv);

     rv = sss->ProcessHeader(nsISiteSecurityService::HEADER_HSTS, mURI,

                             stsHeader.get(), flags, nullptr, nullptr);

     if (NS_FAILED(rv)) {

         AddSecurityMessage(NS_LITERAL_STRING("InvalidSTSHeaders"),

                 NS_LITERAL_STRING("Invalid HSTS Headers"));

         LOG(("STS: Failed to parse STS header, continuing load.\n"));

     }

     return NS_OK;

 }

 bool

 nsHttpChannel::IsHTTPS()

 {

     bool isHttps;

     if (NS_FAILED(mURI->SchemeIs("https", &isHttps)) || !isHttps)

         return false;

     return true;

 }

 void

 nsHttpChannel::ProcessSSLInformation()

 {

     // If this is HTTPS, record any use of RSA so that Key Exchange Algorithm

     // can be whitelisted for TLS False Start in future sessions. We could

     // do the same for DH but its rarity doesn't justify the lookup.

     if (mCanceled || NS_FAILED(mStatus) || !mSecurityInfo ||

         !IsHTTPS() || mPrivateBrowsing)

         return;

     nsCOMPtr<nsISSLSocketControl> ssl = do_QueryInterface(mSecurityInfo);

     nsCOMPtr<nsISSLStatusProvider> statusProvider =

         do_QueryInterface(mSecurityInfo);

     if (!ssl || !statusProvider)

         return;

     nsCOMPtr<nsISSLStatus> sslstat;

     statusProvider->GetSSLStatus(getter_AddRefs(sslstat));

     if (!sslstat)

         return;

     // If certificate exceptions are being used don't record this information

     // in the permission manager.

     bool trustCheck;

     if (NS_FAILED(sslstat->GetIsDomainMismatch(&trustCheck)) || trustCheck)

         return;

     if (NS_FAILED(sslstat->GetIsNotValidAtThisTime(&trustCheck)) || trustCheck)

         return;

     if (NS_FAILED(sslstat->GetIsUntrusted(&trustCheck)) || trustCheck)

         return;

     int16_t kea = ssl->GetKEAUsed();

     nsIPrincipal *principal = GetPrincipal();

     if (!principal)

         return;

     // set a permission manager flag that future transactions can

     // use via RetrieveSSLOptions(()

     nsCOMPtr<nsIPermissionManager> permMgr =

         do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);

     if (!permMgr)

         return;

     // Allow this to stand for a week

     int64_t expireTime = (PR_Now() / PR_USEC_PER_MSEC) +

         (86400 * 7 * PR_MSEC_PER_SEC);

     if (kea == ssl_kea_rsa) {

         permMgr->AddFromPrincipal(principal, "falsestart-rsa",

                                   nsIPermissionManager::ALLOW_ACTION,

                                   nsIPermissionManager::EXPIRE_TIME,

                                   expireTime);

         LOG(("nsHttpChannel::ProcessSSLInformation [this=%p] "

              "falsestart-rsa permission granted for this host\n", this));

     } else {

         permMgr->RemoveFromPrincipal(principal, "falsestart-rsa");

     }

 }

 nsresult

 nsHttpChannel::ProcessResponse()

 {

     nsresult rv;

     uint32_t httpStatus = mResponseHead->Status();

     // Gather data on whether the transaction and page (if this is

     // the initial page load) is being loaded with SSL.

     Telemetry::Accumulate(Telemetry::HTTP_TRANSACTION_IS_SSL,

                           mConnectionInfo->UsingSSL());

     if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {

         Telemetry::Accumulate(Telemetry::HTTP_PAGELOAD_IS_SSL,

                               mConnectionInfo->UsingSSL());

     }

     LOG(("nsHttpChannel::ProcessResponse [this=%p httpStatus=%u]\n",

         this, httpStatus));

     if (mTransaction->ProxyConnectFailed()) {

         // Only allow 407 (authentication required) to continue

         if (httpStatus != 407)

             return ProcessFailedProxyConnect(httpStatus);

         // If proxy CONNECT response needs to complete, wait to process connection

         // for Strict-Transport-Security.

     } else {

         // Given a successful connection, process any STS data that's relevant.

         rv = ProcessSTSHeader();

         MOZ_ASSERT(NS_SUCCEEDED(rv), "ProcessSTSHeader failed, continuing load.");

     }

     MOZ_ASSERT(!mCachedContentIsValid);

     ProcessSSLInformation();

     // notify "http-on-examine-response" observers

     gHttpHandler->OnExamineResponse(this);

     SetCookie(mResponseHead->PeekHeader(nsHttp::Set_Cookie));

     // handle unused username and password in url (see bug 232567)

     if (httpStatus != 401 && httpStatus != 407) {

         if (!mAuthRetryPending)

             mAuthProvider->CheckForSuperfluousAuth();

         if (mCanceled)

             return CallOnStartRequest();

         // reset the authentication's current continuation state because our

         // last authentication attempt has been completed successfully

         mAuthProvider->Disconnect(NS_ERROR_ABORT);

         mAuthProvider = nullptr;

         LOG(("  continuation state has been reset"));

     }

     bool successfulReval = false;

     // handle different server response categories.  Note that we handle

     // caching or not caching of error pages in

     // nsHttpResponseHead::MustValidate; if you change this switch, update that

     // one

     switch (httpStatus) {

     case 200:

     case 203:

         // Per RFC 2616, 14.35.2, "A server MAY ignore the Range header".

         // So if a server does that and sends 200 instead of 206 that we

         // expect, notify our caller.

         // However, if we wanted to start from the beginning, let it go through

         if (mResuming && mStartPos != 0) {

             LOG(("Server ignored our Range header, cancelling [this=%p]\n", this));

             Cancel(NS_ERROR_NOT_RESUMABLE);

             rv = CallOnStartRequest();

             break;

         }

         // these can normally be cached

         rv = ProcessNormal();

         MaybeInvalidateCacheEntryForSubsequentGet();

         break;

     case 206:

         if (mCachedContentIsPartial) // an internal byte range request...

             rv = ProcessPartialContent();

         else {

             mCacheInputStream.CloseAndRelease();

             rv = ProcessNormal();

         }

         break;

     case 300:

     case 301:

     case 302:

     case 307:

     case 308:

     case 303:

 #if 0

     case 305: // disabled as a security measure (see bug 187996).

 #endif

         // don't store the response body for redirects

         MaybeInvalidateCacheEntryForSubsequentGet();

         PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessResponse);

         rv = AsyncProcessRedirection(httpStatus);

         if (NS_FAILED(rv)) {

             PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessResponse);

             LOG(("AsyncProcessRedirection failed [rv=%x]\n", rv));

             // don't cache failed redirect responses.

             if (mCacheEntry)

                 mCacheEntry->AsyncDoom(nullptr);

             if (DoNotRender3xxBody(rv)) {

                 mStatus = rv;

                 DoNotifyListener();

             } else {

                 rv = ContinueProcessResponse(rv);

             }

         }

         break;

     case 304:

         rv = ProcessNotModified();

         if (NS_FAILED(rv)) {

             LOG(("ProcessNotModified failed [rv=%x]\n", rv));

             mCacheInputStream.CloseAndRelease();

             rv = ProcessNormal();

         }

         else {

             successfulReval = true;

         }

         break;

     case 401:

     case 407:

         rv = mAuthProvider->ProcessAuthentication(

             httpStatus, mConnectionInfo->UsingSSL() &&

                         mTransaction->ProxyConnectFailed());

         if (rv == NS_ERROR_IN_PROGRESS)  {

             // authentication prompt has been invoked and result

             // is expected asynchronously

             mAuthRetryPending = true;

             if (httpStatus == 407 || mTransaction->ProxyConnectFailed())

                 mProxyAuthPending = true;

             // suspend the transaction pump to stop receiving the

             // unauthenticated content data. We will throw that data

             // away when user provides credentials or resume the pump

             // when user refuses to authenticate.

             LOG(("Suspending the transaction, asynchronously prompting for credentials"));

             mTransactionPump->Suspend();

             rv = NS_OK;

         }

         else if (NS_FAILED(rv)) {

             LOG(("ProcessAuthentication failed [rv=%x]\n", rv));

             if (mTransaction->ProxyConnectFailed())

                 return ProcessFailedProxyConnect(httpStatus);

             if (!mAuthRetryPending)

                 mAuthProvider->CheckForSuperfluousAuth();

             rv = ProcessNormal();

         }

         else

             mAuthRetryPending = true; // see DoAuthRetry

         break;

     default:

         rv = ProcessNormal();

         MaybeInvalidateCacheEntryForSubsequentGet();

         break;

     }

     CacheDisposition cacheDisposition;

     if (!mDidReval)

         cacheDisposition = kCacheMissed;

     else if (successfulReval)

         cacheDisposition = kCacheHitViaReval;

     else

         cacheDisposition = kCacheMissedViaReval;

     AccumulateCacheHitTelemetry(cacheDisposition);

     return rv;

 }

 nsresult

 nsHttpChannel::ContinueProcessResponse(nsresult rv)

 {

     bool doNotRender = DoNotRender3xxBody(rv);

     if (rv == NS_ERROR_DOM_BAD_URI && mRedirectURI) {

         bool isHTTP = false;

         if (NS_FAILED(mRedirectURI->SchemeIs("http", &isHTTP)))

             isHTTP = false;

         if (!isHTTP && NS_FAILED(mRedirectURI->SchemeIs("https", &isHTTP)))

             isHTTP = false;

         if (!isHTTP) {

             // This was a blocked attempt to redirect and subvert the system by

             // redirecting to another protocol (perhaps javascript:)

             // In that case we want to throw an error instead of displaying the

             // non-redirected response body.

             LOG(("ContinueProcessResponse detected rejected Non-HTTP Redirection"));

             doNotRender = true;

             rv = NS_ERROR_CORRUPTED_CONTENT;

         }

     }

     if (doNotRender) {

         Cancel(rv);

         DoNotifyListener();

         return rv;

     }

     if (NS_SUCCEEDED(rv)) {

         UpdateInhibitPersistentCachingFlag();

         InitCacheEntry();

         CloseCacheEntry(false);

         if (mApplicationCacheForWrite) {

             // Store response in the offline cache

             InitOfflineCacheEntry();

             CloseOfflineCacheEntry();

         }

         return NS_OK;

     }

     LOG(("ContinueProcessResponse got failure result [rv=%x]\n", rv));

     if (mTransaction->ProxyConnectFailed()) {

         return ProcessFailedProxyConnect(mRedirectType);

     }

     return ProcessNormal();

 }

 nsresult

 nsHttpChannel::ProcessNormal()

 {

     nsresult rv;

     LOG(("nsHttpChannel::ProcessNormal [this=%p]\n", this));

     bool succeeded;

     rv = GetRequestSucceeded(&succeeded);

     if (NS_SUCCEEDED(rv) && !succeeded) {

         PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessNormal);

         bool waitingForRedirectCallback;

         (void)ProcessFallback(&waitingForRedirectCallback);

         if (waitingForRedirectCallback) {

             // The transaction has been suspended by ProcessFallback.

             return NS_OK;

         }

         PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessNormal);

     }

     return ContinueProcessNormal(NS_OK);

 }

 nsresult

 nsHttpChannel::ContinueProcessNormal(nsresult rv)

 {

     if (NS_FAILED(rv)) {

         // Fill the failure status here, we have failed to fall back, thus we

         // have to report our status as failed.

         mStatus = rv;

         DoNotifyListener();

         return rv;

     }

     if (mFallingBack) {

         // Do not continue with normal processing, fallback is in

         // progress now.

         return NS_OK;

     }

     // if we're here, then any byte-range requests failed to result in a partial

     // response.  we must clear this flag to prevent BufferPartialContent from

     // being called inside our OnDataAvailable (see bug 136678).

     mCachedContentIsPartial = false;

     ClearBogusContentEncodingIfNeeded();

     UpdateInhibitPersistentCachingFlag();

     // this must be called before firing OnStartRequest, since http clients,

     // such as imagelib, expect our cache entry to already have the correct

     // expiration time (bug 87710).

     if (mCacheEntry) {

         rv = InitCacheEntry();

         if (NS_FAILED(rv))

             CloseCacheEntry(true);

     }

     // Check that the server sent us what we were asking for

     if (mResuming) {

         // Create an entity id from the response

         nsAutoCString id;

         rv = GetEntityID(id);

         if (NS_FAILED(rv)) {

             // If creating an entity id is not possible -> error

             Cancel(NS_ERROR_NOT_RESUMABLE);

         }

         else if (mResponseHead->Status() != 206 &&

                  mResponseHead->Status() != 200) {

             // Probably 404 Not Found, 412 Precondition Failed or

             // 416 Invalid Range -> error

             LOG(("Unexpected response status while resuming, aborting [this=%p]\n",

                  this));

             Cancel(NS_ERROR_ENTITY_CHANGED);

         }

         // If we were passed an entity id, verify it's equal to the server's

         else if (!mEntityID.IsEmpty()) {

             if (!mEntityID.Equals(id)) {

                 LOG(("Entity mismatch, expected '%s', got '%s', aborting [this=%p]",

                      mEntityID.get(), id.get(), this));

                 Cancel(NS_ERROR_ENTITY_CHANGED);

             }

         }

     }

     rv = CallOnStartRequest();

     if (NS_FAILED(rv)) return rv;

     // install cache listener if we still have a cache entry open

     if (mCacheEntry && !mLoadedFromApplicationCache) {

         rv = InstallCacheListener();

         if (NS_FAILED(rv)) return rv;

     }

     return NS_OK;

 }

 nsresult

 nsHttpChannel::PromptTempRedirect()

 {

     if (!gHttpHandler->PromptTempRedirect()) {

         return NS_OK;

     }

     nsresult rv;

     nsCOMPtr<nsIStringBundleService> bundleService =

             do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);

     if (NS_FAILED(rv)) return rv;

     nsCOMPtr<nsIStringBundle> stringBundle;

     rv = bundleService->CreateBundle(NECKO_MSGS_URL, getter_AddRefs(stringBundle));

     if (NS_FAILED(rv)) return rv;

     nsXPIDLString messageString;

     rv = stringBundle->GetStringFromName(MOZ_UTF16("RepostFormData"), getter_Copies(messageString));

     // GetStringFromName can return NS_OK and nullptr messageString.

     if (NS_SUCCEEDED(rv) && messageString) {

         bool repost = false;

         nsCOMPtr<nsIPrompt> prompt;

         GetCallback(prompt);

         if (!prompt)

             return NS_ERROR_NO_INTERFACE;

         prompt->Confirm(nullptr, messageString, &repost);

         if (!repost)

             return NS_ERROR_FAILURE;

     }

     return rv;

 }

 nsresult

 nsHttpChannel::ProxyFailover()

 {

     LOG(("nsHttpChannel::ProxyFailover [this=%p]\n", this));

     nsresult rv;

     nsCOMPtr<nsIProtocolProxyService> pps =

             do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);

     if (NS_FAILED(rv))

         return rv;

     nsCOMPtr<nsIProxyInfo> pi;

     rv = pps->GetFailoverForProxy(mConnectionInfo->ProxyInfo(), mURI, mStatus,

                                   getter_AddRefs(pi));

     if (NS_FAILED(rv))

         return rv;

     // XXXbz so where does this codepath remove us from the loadgroup,

     // exactly?

     return AsyncDoReplaceWithProxy(pi);

 }

 void

 nsHttpChannel::HandleAsyncRedirectChannelToHttps()

 {

     NS_PRECONDITION(!mCallOnResume, "How did that happen?");

     if (mSuspendCount) {

         LOG(("Waiting until resume to do async redirect to https [this=%p]\n", this));

         mCallOnResume = &nsHttpChannel::HandleAsyncRedirectChannelToHttps;

         return;

     }

     nsresult rv = StartRedirectChannelToHttps();

     if (NS_FAILED(rv))

         ContinueAsyncRedirectChannelToURI(rv);

 }

 nsresult

 nsHttpChannel::StartRedirectChannelToHttps()

 {

     nsresult rv = NS_OK;

     LOG(("nsHttpChannel::HandleAsyncRedirectChannelToHttps() [STS]\n"));

     nsCOMPtr<nsIURI> upgradedURI;

     rv = mURI->Clone(getter_AddRefs(upgradedURI));

     NS_ENSURE_SUCCESS(rv,rv);

     upgradedURI->SetScheme(NS_LITERAL_CSTRING("https"));

     int32_t oldPort = -1;

     rv = mURI->GetPort(&oldPort);

     if (NS_FAILED(rv)) return rv;

     // Keep any nonstandard ports so only the scheme is changed.

     // For example:

     //  http://foo.com:80 -> https://foo.com:443

     //  http://foo.com:81 -> https://foo.com:81

     if (oldPort == 80 || oldPort == -1)

         upgradedURI->SetPort(-1);

     else

         upgradedURI->SetPort(oldPort);

     return StartRedirectChannelToURI(upgradedURI,

                                      nsIChannelEventSink::REDIRECT_PERMANENT);

 }

 void

 nsHttpChannel::HandleAsyncAPIRedirect()

 {

     NS_PRECONDITION(!mCallOnResume, "How did that happen?");

     NS_PRECONDITION(mAPIRedirectToURI, "How did that happen?");

     if (mSuspendCount) {

         LOG(("Waiting until resume to do async API redirect [this=%p]\n", this));

         mCallOnResume = &nsHttpChannel::HandleAsyncAPIRedirect;

         return;

     }

     nsresult rv = StartRedirectChannelToURI(mAPIRedirectToURI,

                                             nsIChannelEventSink::REDIRECT_PERMANENT);

     if (NS_FAILED(rv))

         ContinueAsyncRedirectChannelToURI(rv);

     return;

 }

 nsresult

 nsHttpChannel::StartRedirectChannelToURI(nsIURI *upgradedURI, uint32_t flags)

 {

     nsresult rv = NS_OK;

     LOG(("nsHttpChannel::StartRedirectChannelToURI()\n"));

     nsCOMPtr<nsIChannel> newChannel;

     nsCOMPtr<nsIIOService> ioService;

     rv = gHttpHandler->GetIOService(getter_AddRefs(ioService));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = ioService->NewChannelFromURI(upgradedURI, getter_AddRefs(newChannel));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = SetupReplacementChannel(upgradedURI, newChannel, true);

     NS_ENSURE_SUCCESS(rv, rv);

     // Inform consumers about this fake redirect

     mRedirectChannel = newChannel;

     PushRedirectAsyncFunc(

         &nsHttpChannel::ContinueAsyncRedirectChannelToURI);

     rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, flags);

     if (NS_SUCCEEDED(rv))

         rv = WaitForRedirectCallback();

     if (NS_FAILED(rv)) {

         AutoRedirectVetoNotifier notifier(this);

         /* Remove the async call to ContinueAsyncRedirectChannelToURI().

          * It is called directly by our callers upon return (to clean up

          * the failed redirect). */

         PopRedirectAsyncFunc(

             &nsHttpChannel::ContinueAsyncRedirectChannelToURI);

     }

     return rv;

 }

 nsresult

 nsHttpChannel::ContinueAsyncRedirectChannelToURI(nsresult rv)

 {

     if (NS_SUCCEEDED(rv))

         rv = OpenRedirectChannel(rv);

     if (NS_FAILED(rv)) {

         // Fill the failure status here, the update to https had been vetoed

         // but from the security reasons we have to discard the whole channel

         // load.

         mStatus = rv;

     }

     if (mLoadGroup)

         mLoadGroup->RemoveRequest(this, nullptr, mStatus);

     if (NS_FAILED(rv)) {

         // We have to manually notify the listener because there is not any pump

         // that would call our OnStart/StopRequest after resume from waiting for

         // the redirect callback.

         DoNotifyListener();

     }

     return rv;

 }

 nsresult

 nsHttpChannel::OpenRedirectChannel(nsresult rv)

 {

     AutoRedirectVetoNotifier notifier(this);

     // Make sure to do this _after_ calling OnChannelRedirect

     mRedirectChannel->SetOriginalURI(mOriginalURI);

     // And now, notify observers the deprecated way

     nsCOMPtr<nsIHttpEventSink> httpEventSink;

     GetCallback(httpEventSink);

     if (httpEventSink) {

         // NOTE: nsIHttpEventSink is only used for compatibility with pre-1.8

         // versions.

         rv = httpEventSink->OnRedirect(this, mRedirectChannel);

         if (NS_FAILED(rv)) {

             return rv;

         }

     }

     // open new channel

     rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);

     if (NS_FAILED(rv)) {

         return rv;

     }

     mStatus = NS_BINDING_REDIRECTED;

     notifier.RedirectSucceeded();

     ReleaseListeners();

     return NS_OK;

 }

 nsresult

 nsHttpChannel::AsyncDoReplaceWithProxy(nsIProxyInfo* pi)

 {

     LOG(("nsHttpChannel::AsyncDoReplaceWithProxy [this=%p pi=%p]", this, pi));

     nsresult rv;

     nsCOMPtr<nsIChannel> newChannel;

     rv = gHttpHandler->NewProxiedChannel(mURI, pi, mProxyResolveFlags,

                                          mProxyURI, getter_AddRefs(newChannel));

     if (NS_FAILED(rv))

         return rv;

     rv = SetupReplacementChannel(mURI, newChannel, true);

     if (NS_FAILED(rv))

         return rv;

     // Inform consumers about this fake redirect

     mRedirectChannel = newChannel;

     uint32_t flags = nsIChannelEventSink::REDIRECT_INTERNAL;

     PushRedirectAsyncFunc(&nsHttpChannel::ContinueDoReplaceWithProxy);

     rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, flags);

     if (NS_SUCCEEDED(rv))

         rv = WaitForRedirectCallback();

     if (NS_FAILED(rv)) {

         AutoRedirectVetoNotifier notifier(this);

         PopRedirectAsyncFunc(&nsHttpChannel::ContinueDoReplaceWithProxy);

     }

     return rv;

 }

 nsresult

 nsHttpChannel::ContinueDoReplaceWithProxy(nsresult rv)

 {

     AutoRedirectVetoNotifier notifier(this);

     if (NS_FAILED(rv))

         return rv;

     NS_PRECONDITION(mRedirectChannel, "No redirect channel?");

     // Make sure to do this _after_ calling OnChannelRedirect

     mRedirectChannel->SetOriginalURI(mOriginalURI);

     // open new channel

     rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);

     if (NS_FAILED(rv))

         return rv;

     mStatus = NS_BINDING_REDIRECTED;

     notifier.RedirectSucceeded();

     ReleaseListeners();

     return rv;

 }

 nsresult

 nsHttpChannel::ResolveProxy()

 {

     LOG(("nsHttpChannel::ResolveProxy [this=%p]\n", this));

     nsresult rv;

     nsCOMPtr<nsIProtocolProxyService> pps =

             do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID, &rv);

     if (NS_FAILED(rv))

         return rv;

     // using the nsIProtocolProxyService2 allows a minor performance

     // optimization, but if an add-on has only provided the original interface

     // then it is ok to use that version.

     nsCOMPtr<nsIProtocolProxyService2> pps2 = do_QueryInterface(pps);

     if (pps2) {

         rv = pps2->AsyncResolve2(this, mProxyResolveFlags,

                                  this, getter_AddRefs(mProxyRequest));

     } else {

         rv = pps->AsyncResolve(this, mProxyResolveFlags,

                                this, getter_AddRefs(mProxyRequest));

     }

     return rv;

 }

 bool

 nsHttpChannel::ResponseWouldVary(nsICacheEntry* entry) const

 {

     nsresult rv;

     nsAutoCString buf, metaKey;

     mCachedResponseHead->GetHeader(nsHttp::Vary, buf);

     if (!buf.IsEmpty()) {

         NS_NAMED_LITERAL_CSTRING(prefix, "request-");

         // enumerate the elements of the Vary header...

         char *val = buf.BeginWriting(); // going to munge buf

         char *token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);

         while (token) {

             LOG(("nsHttpChannel::ResponseWouldVary [channel=%p] " \

                  "processing %s\n",

                  this, token));

             //

             // if "*", then assume response would vary.  technically speaking,

             // "Vary: header, *" is not permitted, but we allow it anyways.

             //

             // We hash values of cookie-headers for the following reasons:

             //

             //   1- cookies can be very large in size

             //

             //   2- cookies may contain sensitive information.  (for parity with

             //      out policy of not storing Set-cookie headers in the cache

             //      meta data, we likewise do not want to store cookie headers

             //      here.)

             //

             if (*token == '*')

                 return true; // if we encounter this, just get out of here

             // build cache meta data key...

             metaKey = prefix + nsDependentCString(token);

             // check the last value of the given request header to see if it has

             // since changed.  if so, then indeed the cached response is invalid.

             nsXPIDLCString lastVal;

             entry->GetMetaDataElement(metaKey.get(), getter_Copies(lastVal));

             LOG(("nsHttpChannel::ResponseWouldVary [channel=%p] "

                      "stored value = \"%s\"\n",

                  this, lastVal.get()));

             // Look for value of "Cookie" in the request headers

             nsHttpAtom atom = nsHttp::ResolveAtom(token);

             const char *newVal = mRequestHead.PeekHeader(atom);

             if (!lastVal.IsEmpty()) {

                 // value for this header in cache, but no value in request

                 if (!newVal)

                     return true; // yes - response would vary

                 // If this is a cookie-header, stored metadata is not

                 // the value itself but the hash. So we also hash the

                 // outgoing value here in order to compare the hashes

                 nsAutoCString hash;

                 if (atom == nsHttp::Cookie) {

                     rv = Hash(newVal, hash);

                     // If hash failed, be conservative (the cached hash

                     // exists at this point) and claim response would vary

                     if (NS_FAILED(rv))

                         return true;

                     newVal = hash.get();

                     LOG(("nsHttpChannel::ResponseWouldVary [this=%p] " \

                             "set-cookie value hashed to %s\n",

                          this, newVal));

                 }

                 if (strcmp(newVal, lastVal))

                     return true; // yes, response would vary

             } else if (newVal) { // old value is empty, but newVal is set

                 return true;

             }

             // next token...

             token = nsCRT::strtok(val, NS_HTTP_HEADER_SEPS, &val);

         }

     }

     return false;

 }

 // We need to have an implementation of this function just so that we can keep

 // all references to mCallOnResume of type nsHttpChannel:  it's not OK in C++

 // to set a member function ptr to  a base class function.

 void

 nsHttpChannel::HandleAsyncAbort()

 {

     HttpAsyncAborter<nsHttpChannel>::HandleAsyncAbort();

 }

 nsresult

 nsHttpChannel::EnsureAssocReq()

 {

     // Confirm Assoc-Req response header on pipelined transactions

     // per draft-nottingham-http-pipeline-01.txt

     // of the form: GET http://blah.com/foo/bar?qv

     // return NS_OK as long as we don't find a violation

     // (i.e. no header is ok, as are malformed headers, as are

     // transactions that have not been pipelined (unless those have been

     // opted in via pragma))

     if (!mResponseHead)

         return NS_OK;

     const char *assoc_val = mResponseHead->PeekHeader(nsHttp::Assoc_Req);

     if (!assoc_val)

         return NS_OK;

     if (!mTransaction || !mURI)

         return NS_OK;

     if (!mTransaction->PipelinePosition()) {

         // "Pragma: X-Verify-Assoc-Req" can be used to verify even non pipelined

         // transactions. It is used by test harness.

         const char *pragma_val = mResponseHead->PeekHeader(nsHttp::Pragma);

         if (!pragma_val ||

             !nsHttp::FindToken(pragma_val, "X-Verify-Assoc-Req",

                                HTTP_HEADER_VALUE_SEPS))

             return NS_OK;

     }

     char *method = net_FindCharNotInSet(assoc_val, HTTP_LWS);

     if (!method)

         return NS_OK;

     bool equals;

     char *endofmethod;

     assoc_val = nullptr;

     endofmethod = net_FindCharInSet(method, HTTP_LWS);

     if (endofmethod)

         assoc_val = net_FindCharNotInSet(endofmethod, HTTP_LWS);

     if (!assoc_val)

         return NS_OK;

     // check the method

     int32_t methodlen = strlen(mRequestHead.Method().get());

     if ((methodlen != (endofmethod - method)) ||

         PL_strncmp(method,

                    mRequestHead.Method().get(),

                    endofmethod - method)) {

         LOG(("  Assoc-Req failure Method %s", method));

         if (mConnectionInfo)

             gHttpHandler->ConnMgr()->

                 PipelineFeedbackInfo(mConnectionInfo,

                                      nsHttpConnectionMgr::RedCorruptedContent,

                                      nullptr, 0);

         nsCOMPtr<nsIConsoleService> consoleService =

             do_GetService(NS_CONSOLESERVICE_CONTRACTID);

         if (consoleService) {

             nsAutoString message

                 (NS_LITERAL_STRING("Failed Assoc-Req. Received "));

             AppendASCIItoUTF16(

                 mResponseHead->PeekHeader(nsHttp::Assoc_Req),

                 message);

             message += NS_LITERAL_STRING(" expected method ");

             AppendASCIItoUTF16(mRequestHead.Method().get(), message);

             consoleService->LogStringMessage(message.get());

         }

         if (gHttpHandler->EnforceAssocReq())

             return NS_ERROR_CORRUPTED_CONTENT;

         return NS_OK;

     }

     // check the URL

     nsCOMPtr<nsIURI> assoc_url;

     if (NS_FAILED(NS_NewURI(getter_AddRefs(assoc_url), assoc_val)) ||

         !assoc_url)

         return NS_OK;

     mURI->Equals(assoc_url, &equals);

     if (!equals) {

         LOG(("  Assoc-Req failure URL %s", assoc_val));

         if (mConnectionInfo)

             gHttpHandler->ConnMgr()->

                 PipelineFeedbackInfo(mConnectionInfo,

                                      nsHttpConnectionMgr::RedCorruptedContent,

                                      nullptr, 0);

         nsCOMPtr<nsIConsoleService> consoleService =

             do_GetService(NS_CONSOLESERVICE_CONTRACTID);

         if (consoleService) {

             nsAutoString message

                 (NS_LITERAL_STRING("Failed Assoc-Req. Received "));

             AppendASCIItoUTF16(

                 mResponseHead->PeekHeader(nsHttp::Assoc_Req),

                 message);

             message += NS_LITERAL_STRING(" expected URL ");

             AppendASCIItoUTF16(mSpec.get(), message);

             consoleService->LogStringMessage(message.get());

         }

         if (gHttpHandler->EnforceAssocReq())

             return NS_ERROR_CORRUPTED_CONTENT;

     }

     return NS_OK;

 }

 //-----------------------------------------------------------------------------

 // nsHttpChannel <byte-range>

 //-----------------------------------------------------------------------------

 bool

 nsHttpChannel::IsResumable(int64_t partialLen, int64_t contentLength,

                            bool ignoreMissingPartialLen) const

 {

     bool hasContentEncoding =

         mCachedResponseHead->PeekHeader(nsHttp::Content_Encoding)

         != nullptr;

     return (partialLen < contentLength) &&

            (partialLen > 0 || ignoreMissingPartialLen) &&

            !hasContentEncoding &&

            mCachedResponseHead->IsResumable() &&

            !mCustomConditionalRequest &&

            !mCachedResponseHead->NoStore();

 }

 nsresult

 nsHttpChannel::MaybeSetupByteRangeRequest(int64_t partialLen, int64_t contentLength)

 {

     // Be pesimistic

     mIsPartialRequest = false;

     if (!IsResumable(partialLen, contentLength))

       return NS_ERROR_NOT_RESUMABLE;

     // looks like a partial entry we can reuse; add If-Range

     // and Range headers.

     nsresult rv = SetupByteRangeRequest(partialLen);

     if (NS_FAILED(rv)) {

         // Make the request unconditional again.

         mRequestHead.ClearHeader(nsHttp::Range);

         mRequestHead.ClearHeader(nsHttp::If_Range);

     }

     return rv;

 }

 nsresult

 nsHttpChannel::SetupByteRangeRequest(int64_t partialLen)

 {

     // cached content has been found to be partial, add necessary request

     // headers to complete cache entry.

     // use strongest validator available...

     const char *val = mCachedResponseHead->PeekHeader(nsHttp::ETag);

     if (!val)

         val = mCachedResponseHead->PeekHeader(nsHttp::Last_Modified);

     if (!val) {

         // if we hit this code it means mCachedResponseHead->IsResumable() is

         // either broken or not being called.

         NS_NOTREACHED("no cache validator");

         mIsPartialRequest = false;

         return NS_ERROR_FAILURE;

     }

     char buf[64];

     PR_snprintf(buf, sizeof(buf), "bytes=%lld-", partialLen);

     mRequestHead.SetHeader(nsHttp::Range, nsDependentCString(buf));

     mRequestHead.SetHeader(nsHttp::If_Range, nsDependentCString(val));

     mIsPartialRequest = true;

     return NS_OK;

 }

 nsresult

 nsHttpChannel::ProcessPartialContent()

 {

     // ok, we've just received a 206

     //

     // we need to stream whatever data is in the cache out first, and then

     // pick up whatever data is on the wire, writing it into the cache.

     LOG(("nsHttpChannel::ProcessPartialContent [this=%p]\n", this));

     NS_ENSURE_TRUE(mCachedResponseHead, NS_ERROR_NOT_INITIALIZED);

     NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_INITIALIZED);

     // Make sure to clear bogus content-encodings before looking at the header

     ClearBogusContentEncodingIfNeeded();

     // Check if the content-encoding we now got is different from the one we

     // got before

     if (PL_strcasecmp(mResponseHead->PeekHeader(nsHttp::Content_Encoding),

                       mCachedResponseHead->PeekHeader(nsHttp::Content_Encoding))

                       != 0) {

         Cancel(NS_ERROR_INVALID_CONTENT_ENCODING);

         return CallOnStartRequest();

     }

     nsresult rv;

     int64_t cachedContentLength = mCachedResponseHead->ContentLength();

     int64_t entitySize = mResponseHead->TotalEntitySize();

     LOG(("nsHttpChannel::ProcessPartialContent [this=%p trans=%p] "

          "original content-length %lld, entity-size %lld, content-range %s\n",

          this, mTransaction.get(), cachedContentLength, entitySize,

          mResponseHead->PeekHeader(nsHttp::Content_Range)));

     if ((entitySize >= 0) && (cachedContentLength >= 0) &&

         (entitySize != cachedContentLength)) {

         LOG(("nsHttpChannel::ProcessPartialContent [this=%p] "

              "206 has different total entity size than the content length "

              "of the original partially cached entity.\n", this));

         mCacheEntry->AsyncDoom(nullptr);

         Cancel(NS_ERROR_CORRUPTED_CONTENT);

         return CallOnStartRequest();

     }

     if (mConcurentCacheAccess) {

         // We started to read cached data sooner than its write has been done.

         // But the concurrent write has not finished completely, so we had to

         // do a range request.  Now let the content coming from the network

         // be presented to consumers and also stored to the cache entry.

         rv = InstallCacheListener(mLogicalOffset);

         if (NS_FAILED(rv)) return rv;

         if (mOfflineCacheEntry) {

             rv = InstallOfflineCacheListener(mLogicalOffset);

             if (NS_FAILED(rv)) return rv;

         }

         // merge any new headers with the cached response headers

         rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());

         if (NS_FAILED(rv)) return rv;

         // update the cached response head

         nsAutoCString head;

         mCachedResponseHead->Flatten(head, true);

         rv = mCacheEntry->SetMetaDataElement("response-head", head.get());

         if (NS_FAILED(rv)) return rv;

         UpdateInhibitPersistentCachingFlag();

         rv = UpdateExpirationTime();

         if (NS_FAILED(rv)) return rv;

         mCachedContentIsPartial = false;

         // notify observers interested in looking at a response that has been

         // merged with any cached headers (http-on-examine-merged-response).

         gHttpHandler->OnExamineMergedResponse(this);

     }

     else {

         // suspend the current transaction

         rv = mTransactionPump->Suspend();

         if (NS_FAILED(rv)) return rv;

         // merge any new headers with the cached response headers

         rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());

         if (NS_FAILED(rv)) return rv;

         // update the cached response head

         nsAutoCString head;

         mCachedResponseHead->Flatten(head, true);

         rv = mCacheEntry->SetMetaDataElement("response-head", head.get());

         if (NS_FAILED(rv)) return rv;

         // make the cached response be the current response

         mResponseHead = mCachedResponseHead;

         UpdateInhibitPersistentCachingFlag();

         rv = UpdateExpirationTime();

         if (NS_FAILED(rv)) return rv;

         // notify observers interested in looking at a response that has been

         // merged with any cached headers (http-on-examine-merged-response).

         gHttpHandler->OnExamineMergedResponse(this);

         // the cached content is valid, although incomplete.

         mCachedContentIsValid = true;

         rv = ReadFromCache(false);

     }

     return rv;

 }

 nsresult

 nsHttpChannel::OnDoneReadingPartialCacheEntry(bool *streamDone)

 {

     nsresult rv;

     LOG(("nsHttpChannel::OnDoneReadingPartialCacheEntry [this=%p]", this));

     // by default, assume we would have streamed all data or failed...

     *streamDone = true;

     // setup cache listener to append to cache entry

     int64_t size;

     rv = mCacheEntry->GetDataSize(&size);

     if (NS_FAILED(rv)) return rv;

     rv = InstallCacheListener(size);

     if (NS_FAILED(rv)) return rv;

     // Entry is valid, do it now, after the output stream has been opened,

     // otherwise when done earlier, pending readers would consider the cache

     // entry still as partial (CacheEntry::GetDataSize would return the partial

     // data size) and consumers would do the conditional request again.

     rv = mCacheEntry->SetValid();

     if (NS_FAILED(rv)) return rv;

     // need to track the logical offset of the data being sent to our listener

     mLogicalOffset = size;

     // we're now completing the cached content, so we can clear this flag.

     // this puts us in the state of a regular download.

     mCachedContentIsPartial = false;

     // resume the transaction if it exists, otherwise the pipe contained the

     // remaining part of the document and we've now streamed all of the data.

     if (mTransactionPump) {

         rv = mTransactionPump->Resume();

         if (NS_SUCCEEDED(rv))

             *streamDone = false;

     }

     else

         NS_NOTREACHED("no transaction");

     return rv;

 }

 //-----------------------------------------------------------------------------

 // nsHttpChannel <cache>

 //-----------------------------------------------------------------------------

 nsresult

 nsHttpChannel::ProcessNotModified()

 {

     nsresult rv;

     LOG(("nsHttpChannel::ProcessNotModified [this=%p]\n", this));

     if (mCustomConditionalRequest) {

         LOG(("Bypassing ProcessNotModified due to custom conditional headers"));

         return NS_ERROR_FAILURE;

     }

     if (!mDidReval) {

         LOG(("Server returned a 304 response even though we did not send a "

              "conditional request"));

         return NS_ERROR_FAILURE;

     }

     MOZ_ASSERT(mCachedResponseHead);

     MOZ_ASSERT(mCacheEntry);

     NS_ENSURE_TRUE(mCachedResponseHead && mCacheEntry, NS_ERROR_UNEXPECTED);

     // If the 304 response contains a Last-Modified different than the

     // one in our cache that is pretty suspicious and is, in at least the

     // case of bug 716840, a sign of the server having previously corrupted

     // our cache with a bad response. Take the minor step here of just dooming

     // that cache entry so there is a fighting chance of getting things on the

     // right track as well as disabling pipelining for that host.

     nsAutoCString lastModifiedCached;

     nsAutoCString lastModified304;

     rv = mCachedResponseHead->GetHeader(nsHttp::Last_Modified,

                                         lastModifiedCached);

     if (NS_SUCCEEDED(rv)) {

         rv = mResponseHead->GetHeader(nsHttp::Last_Modified,

                                       lastModified304);

     }

     if (NS_SUCCEEDED(rv) && !lastModified304.Equals(lastModifiedCached)) {

         LOG(("Cache Entry and 304 Last-Modified Headers Do Not Match "

              "[%s] and [%s]\n",

              lastModifiedCached.get(), lastModified304.get()));

         mCacheEntry->AsyncDoom(nullptr);

         if (mConnectionInfo)

             gHttpHandler->ConnMgr()->

                 PipelineFeedbackInfo(mConnectionInfo,

                                      nsHttpConnectionMgr::RedCorruptedContent,

                                      nullptr, 0);

         Telemetry::Accumulate(Telemetry::CACHE_LM_INCONSISTENT, true);

     }

     // merge any new headers with the cached response headers

     rv = mCachedResponseHead->UpdateHeaders(mResponseHead->Headers());

     if (NS_FAILED(rv)) return rv;

     // update the cached response head

     nsAutoCString head;

     mCachedResponseHead->Flatten(head, true);

     rv = mCacheEntry->SetMetaDataElement("response-head", head.get());

     if (NS_FAILED(rv)) return rv;

     // make the cached response be the current response

     mResponseHead = mCachedResponseHead;

     UpdateInhibitPersistentCachingFlag();

     rv = UpdateExpirationTime();

     if (NS_FAILED(rv)) return rv;

     rv = AddCacheEntryHeaders(mCacheEntry);

     if (NS_FAILED(rv)) return rv;

     // notify observers interested in looking at a reponse that has been

     // merged with any cached headers

     gHttpHandler->OnExamineMergedResponse(this);

     mCachedContentIsValid = true;

     // Tell other consumers the entry is OK to use

     rv = mCacheEntry->SetValid();

     if (NS_FAILED(rv)) return rv;

     rv = ReadFromCache(false);

     if (NS_FAILED(rv)) return rv;

     mTransactionReplaced = true;

     return NS_OK;

 }

 nsresult

 nsHttpChannel::ProcessFallback(bool *waitingForRedirectCallback)

 {

     LOG(("nsHttpChannel::ProcessFallback [this=%p]\n", this));

     nsresult rv;

     *waitingForRedirectCallback = false;

     mFallingBack = false;

     // At this point a load has failed (either due to network problems

     // or an error returned on the server).  Perform an application

     // cache fallback if we have a URI to fall back to.

     if (!mApplicationCache || mFallbackKey.IsEmpty() || mFallbackChannel) {

         LOG(("  choosing not to fallback [%p,%s,%d]",

              mApplicationCache.get(), mFallbackKey.get(), mFallbackChannel));

         return NS_OK;

     }

     // Make sure the fallback entry hasn't been marked as a foreign

     // entry.

     uint32_t fallbackEntryType;

     rv = mApplicationCache->GetTypes(mFallbackKey, &fallbackEntryType);

     NS_ENSURE_SUCCESS(rv, rv);

     if (fallbackEntryType & nsIApplicationCache::ITEM_FOREIGN) {

         // This cache points to a fallback that refers to a different

         // manifest.  Refuse to fall back.

         return NS_OK;

     }

     MOZ_ASSERT(fallbackEntryType & nsIApplicationCache::ITEM_FALLBACK,

                "Fallback entry not marked correctly!");

     // Kill any offline cache entry, and disable offline caching for the

     // fallback.

     if (mOfflineCacheEntry) {

         mOfflineCacheEntry->AsyncDoom(nullptr);

         mOfflineCacheEntry = nullptr;

     }

     mApplicationCacheForWrite = nullptr;

     mOfflineCacheEntry = nullptr;

     // Close the current cache entry.

     CloseCacheEntry(true);

     // Create a new channel to load the fallback entry.

     nsRefPtr<nsIChannel> newChannel;

     rv = gHttpHandler->NewChannel(mURI, getter_AddRefs(newChannel));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = SetupReplacementChannel(mURI, newChannel, true);

     NS_ENSURE_SUCCESS(rv, rv);

     // Make sure the new channel loads from the fallback key.

     nsCOMPtr<nsIHttpChannelInternal> httpInternal =

         do_QueryInterface(newChannel, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = httpInternal->SetupFallbackChannel(mFallbackKey.get());

     NS_ENSURE_SUCCESS(rv, rv);

     // ... and fallbacks should only load from the cache.

     uint32_t newLoadFlags = mLoadFlags | LOAD_REPLACE | LOAD_ONLY_FROM_CACHE;

     rv = newChannel->SetLoadFlags(newLoadFlags);

     // Inform consumers about this fake redirect

     mRedirectChannel = newChannel;

     uint32_t redirectFlags = nsIChannelEventSink::REDIRECT_INTERNAL;

     PushRedirectAsyncFunc(&nsHttpChannel::ContinueProcessFallback);

     rv = gHttpHandler->AsyncOnChannelRedirect(this, newChannel, redirectFlags);

     if (NS_SUCCEEDED(rv))

         rv = WaitForRedirectCallback();

     if (NS_FAILED(rv)) {

         AutoRedirectVetoNotifier notifier(this);

         PopRedirectAsyncFunc(&nsHttpChannel::ContinueProcessFallback);

         return rv;

     }

     // Indicate we are now waiting for the asynchronous redirect callback

     // if all went OK.

     *waitingForRedirectCallback = true;

     return NS_OK;

 }

 nsresult

 nsHttpChannel::ContinueProcessFallback(nsresult rv)

 {

     AutoRedirectVetoNotifier notifier(this);

     if (NS_FAILED(rv))

         return rv;

     NS_PRECONDITION(mRedirectChannel, "No redirect channel?");

     // Make sure to do this _after_ calling OnChannelRedirect

     mRedirectChannel->SetOriginalURI(mOriginalURI);

     rv = mRedirectChannel->AsyncOpen(mListener, mListenerContext);

     if (NS_FAILED(rv))

         return rv;

     if (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI) {

         Telemetry::Accumulate(Telemetry::HTTP_OFFLINE_CACHE_DOCUMENT_LOAD,

                               true);

     }

     // close down this channel

     Cancel(NS_BINDING_REDIRECTED);

     notifier.RedirectSucceeded();

     ReleaseListeners();

     mFallingBack = true;

     return NS_OK;

 }

 // Determines if a request is a byte range request for a subrange,

 // i.e. is a byte range request, but not a 0- byte range request.

 static bool

 IsSubRangeRequest(nsHttpRequestHead &aRequestHead)

 {

     if (!aRequestHead.PeekHeader(nsHttp::Range))

         return false;

     nsAutoCString byteRange;

     aRequestHead.GetHeader(nsHttp::Range, byteRange);

     return !byteRange.EqualsLiteral("bytes=0-");

 }

 nsresult

 nsHttpChannel::OpenCacheEntry(bool usingSSL)

 {

     MOZ_EVENT_TRACER_EXEC(this, "net::http::OpenCacheEntry");

     // Handle correctly mCacheEntriesToWaitFor

     AutoCacheWaitFlags waitFlags(this);

     // Drop this flag here

     mConcurentCacheAccess = 0;

     nsresult rv;

     mLoadedFromApplicationCache = false;

     mHasQueryString = HasQueryString(mRequestHead.ParsedMethod(), mURI);

     LOG(("nsHttpChannel::OpenCacheEntry [this=%p]", this));

     // make sure we're not abusing this function

     NS_PRECONDITION(!mCacheEntry, "cache entry already open");

     nsAutoCString cacheKey;

     if (mRequestHead.IsPost()) {

         // If the post id is already set then this is an attempt to replay

         // a post transaction via the cache.  Otherwise, we need a unique

         // post id for this transaction.

         if (mPostID == 0)

             mPostID = gHttpHandler->GenerateUniqueID();

     }

     else if (!mRequestHead.IsGet() && !mRequestHead.IsHead()) {

         // don't use the cache for other types of requests

         return NS_OK;

     }

     if (mResuming) {

         // We don't support caching for requests initiated

         // via nsIResumableChannel.

         return NS_OK;

     }

     // Don't cache byte range requests which are subranges, only cache 0-

     // byte range requests.

     if (IsSubRangeRequest(mRequestHead))

         return NS_OK;

     // Pick up an application cache from the notification

     // callbacks if available

     if (!mApplicationCache && mInheritApplicationCache) {

         nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer;

         GetCallback(appCacheContainer);

         if (appCacheContainer) {

             appCacheContainer->GetApplicationCache(getter_AddRefs(mApplicationCache));

         }

     }

     nsCOMPtr<nsICacheStorageService> cacheStorageService =

         do_GetService("@mozilla.org/netwerk/cache-storage-service;1", &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     nsRefPtr<LoadContextInfo> info = GetLoadContextInfo(this);

     nsCOMPtr<nsICacheStorage> cacheStorage;

     nsCOMPtr<nsIURI> openURI;

     /* Obtain optional third party isolation domain */

     nsAutoCString cacheDomain;

     nsCOMPtr<nsIURI> firstPartyIsolationURI;

     nsCOMPtr<mozIThirdPartyUtil> thirdPartySvc

          = do_GetService(THIRDPARTYUTIL_CONTRACTID);

     rv = thirdPartySvc->GetFirstPartyIsolationURI(this, nullptr,

                                            getter_AddRefs(firstPartyIsolationURI));

     if (NS_SUCCEEDED(rv) && firstPartyIsolationURI) {

         thirdPartySvc->GetFirstPartyHostForIsolation(firstPartyIsolationURI,

                 cacheDomain);

     }

     if (!mFallbackKey.IsEmpty() && mFallbackChannel) {

         // This is a fallback channel, open fallback URI instead

         rv = NS_NewURI(getter_AddRefs(openURI), mFallbackKey);

         NS_ENSURE_SUCCESS(rv, rv);

     }

     else {

         openURI = mURI;

     }

     uint32_t cacheEntryOpenFlags;

     bool offline = gIOService->IsOffline();

     if (offline || (mLoadFlags & INHIBIT_CACHING)) {

         if (BYPASS_LOCAL_CACHE(mLoadFlags) && !offline) {

             goto bypassCacheEntryOpen;

         }

         cacheEntryOpenFlags = nsICacheStorage::OPEN_READONLY;

         mCacheEntryIsReadOnly = true;

     }

     else if (BYPASS_LOCAL_CACHE(mLoadFlags) && !mApplicationCache) {

         cacheEntryOpenFlags = nsICacheStorage::OPEN_TRUNCATE;

     }

     else {

         cacheEntryOpenFlags = nsICacheStorage::OPEN_NORMALLY

                             | nsICacheStorage::CHECK_MULTITHREADED;

     }

     if (mApplicationCache) {

         rv = cacheStorageService->AppCacheStorage(info, 

             mApplicationCache,

             getter_AddRefs(cacheStorage));

     }

     else if (mLoadFlags & INHIBIT_PERSISTENT_CACHING) {

         rv = cacheStorageService->MemoryCacheStorage(info, // ? choose app cache as well...

             getter_AddRefs(cacheStorage));

     }

     else {

         rv = cacheStorageService->DiskCacheStorage(info,

             mChooseApplicationCache || (mLoadFlags & LOAD_CHECK_OFFLINE_CACHE),

             getter_AddRefs(cacheStorage));

     }

     NS_ENSURE_SUCCESS(rv, rv);

     // Don't consider mLoadUnblocked here, since it's not indication of a demand

     // to load prioritly. It's mostly used to load XHR requests, but those should

     // not be considered as influencing the page load performance.

     if (mLoadAsBlocking || (mLoadFlags & LOAD_INITIAL_DOCUMENT_URI))

         cacheEntryOpenFlags |= nsICacheStorage::OPEN_PRIORITY;

     // Only for backward compatibility with the old cache back end.

     // When removed, remove the flags and related code snippets.

     if (mLoadFlags & LOAD_BYPASS_LOCAL_CACHE_IF_BUSY)

         cacheEntryOpenFlags |= nsICacheStorage::OPEN_BYPASS_IF_BUSY;

     rv = cacheStorage->AsyncOpenURI(

         openURI, nsPrintfCString("%s@%d", cacheDomain.get(), mPostID),

         cacheEntryOpenFlags, this);

     NS_ENSURE_SUCCESS(rv, rv);

     waitFlags.Keep(WAIT_FOR_CACHE_ENTRY);

 bypassCacheEntryOpen:

     if (!mApplicationCacheForWrite)

         return NS_OK;

     // If there is an app cache to write to, open the entry right now in parallel.

     // make sure we're not abusing this function

     NS_PRECONDITION(!mOfflineCacheEntry, "cache entry already open");

     if (offline) {

         // only put things in the offline cache while online

         return NS_OK;

     }