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

/* vim:set ts=4 sw=4 sts=4 et 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 "prsystem.h"

#include "nsError.h"

#include "nsHttp.h"

#include "nsHttpHandler.h"

#include "nsHttpChannel.h"

#include "nsHttpAuthCache.h"

#include "nsStandardURL.h"

#include "nsIDOMWindow.h"

#include "nsINetworkProperties.h"

#include "nsIHttpChannel.h"

#include "nsIStandardURL.h"

#include "LoadContextInfo.h"

#include "nsCategoryManagerUtils.h"

#include "nsIPrefService.h"

#include "nsIPrefBranch.h"

#include "nsIPrefLocalizedString.h"

#include "nsISocketProviderService.h"

#include "nsISocketProvider.h"

#include "nsPrintfCString.h"

#include "nsCOMPtr.h"

#include "nsNetCID.h"

#include "mozilla/ClearOnShutdown.h"

#include "mozilla/Printf.h"

#include "mozilla/Sprintf.h"

#include "nsAsyncRedirectVerifyHelper.h"

#include "nsSocketTransportService2.h"

#include "nsAlgorithm.h"

#include "ASpdySession.h"

#include "EventTokenBucket.h"

#include "Tickler.h"

#include "nsIXULAppInfo.h"

#include "nsICookieService.h"

#include "nsIObserverService.h"

#include "nsISiteSecurityService.h"

#include "nsIStreamConverterService.h"

#include "nsCRT.h"

#include "nsIMemoryReporter.h"

#include "nsIParentalControlsService.h"

#include "nsPIDOMWindow.h"

#include "nsINetworkLinkService.h"

#include "nsHttpChannelAuthProvider.h"

#include "nsServiceManagerUtils.h"

#include "nsComponentManagerUtils.h"

#include "nsSocketTransportService2.h"

#include "nsIOService.h"

#include "nsISupportsPrimitives.h"

#include "nsIXULRuntime.h"

#include "nsCharSeparatedTokenizer.h"

#include "nsRFPService.h"

#include "rust-helper/src/helper.h"

#include "mozilla/net/NeckoChild.h"

#include "mozilla/net/NeckoParent.h"

#include "mozilla/ipc/URIUtils.h"

#include "mozilla/Telemetry.h"

#include "mozilla/Unused.h"

#include "mozilla/BasePrincipal.h"

#include "mozilla/dom/ContentParent.h"

#include "mozilla/dom/Navigator.h"

#include "nsNSSComponent.h"

#if defined(XP_UNIX)

#include <sys/utsname.h>

#endif

#if defined(XP_WIN)

#include <windows.h>

#include "mozilla/WindowsVersion.h"

#endif

#if defined(XP_MACOSX)

#include <CoreServices/CoreServices.h>

#include "nsCocoaFeatures.h"

#endif

#ifdef MOZ_TASK_TRACER

#include "GeckoTaskTracer.h"

#endif

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

#include "mozilla/net/HttpChannelChild.h"

#define UA_PREF_PREFIX          "general.useragent."

#ifdef XP_WIN

#define UA_SPARE_PLATFORM

#endif

#define HTTP_PREF_PREFIX        "network.http."

#define INTL_ACCEPT_LANGUAGES   "intl.accept_languages"

#define BROWSER_PREF_PREFIX     "browser.cache."

#define DONOTTRACK_HEADER_ENABLED "privacy.donottrackheader.enabled"

#define H2MANDATORY_SUITE        "security.ssl3.ecdhe_rsa_aes_128_gcm_sha256"

#define TELEMETRY_ENABLED        "toolkit.telemetry.enabled"

#define ALLOW_EXPERIMENTS        "network.allow-experiments"

#define SAFE_HINT_HEADER_VALUE   "safeHint.enabled"

#define SECURITY_PREFIX          "security."

#define TCP_FAST_OPEN_ENABLE         "network.tcp.tcp_fastopen_enable"

#define TCP_FAST_OPEN_FAILURE_LIMIT  "network.tcp.tcp_fastopen_consecutive_failure_limit"

#define TCP_FAST_OPEN_STALLS_LIMIT   "network.tcp.tcp_fastopen_http_stalls_limit"

#define TCP_FAST_OPEN_STALLS_IDLE    "network.tcp.tcp_fastopen_http_check_for_stalls_only_if_idle_for"

#define TCP_FAST_OPEN_STALLS_TIMEOUT "network.tcp.tcp_fastopen_http_stalls_timeout"

#define UA_PREF(_pref) UA_PREF_PREFIX _pref

#define HTTP_PREF(_pref) HTTP_PREF_PREFIX _pref

#define BROWSER_PREF(_pref) BROWSER_PREF_PREFIX _pref

#define NS_HTTP_PROTOCOL_FLAGS (URI_STD | ALLOWS_PROXY | ALLOWS_PROXY_HTTP | URI_LOADABLE_BY_ANYONE)

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

using mozilla::Telemetry::LABELS_NETWORK_HTTP_REDIRECT_TO_SCHEME;

namespace mozilla {

namespace net {

LazyLogModule gHttpLog("nsHttp");

static nsresult

NewURI(const nsACString &aSpec,

       const char *aCharset,

       nsIURI *aBaseURI,

       int32_t aDefaultPort,

       nsIURI **aURI)

{

    nsCOMPtr<nsIURI> base(aBaseURI);

    return NS_MutateURI(new nsStandardURL::Mutator())

        .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,

                                nsIStandardURL::URLTYPE_AUTHORITY,

                                aDefaultPort, nsCString(aSpec), aCharset,

                                base, nullptr))

        .Finalize(aURI);

}

#ifdef ANDROID

static nsCString

GetDeviceModelId() {

    // Assumed to be running on the main thread

    // We need the device property in either case

    nsAutoCString deviceModelId;

    nsCOMPtr<nsIPropertyBag2> infoService = do_GetService("@mozilla.org/system-info;1");

    MOZ_ASSERT(infoService, "Could not find a system info service");

    nsAutoString androidDevice;

    nsresult rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("device"), androidDevice);

    if (NS_SUCCEEDED(rv)) {

        deviceModelId = NS_LossyConvertUTF16toASCII(androidDevice);

    }

    nsAutoCString deviceString;

    rv = Preferences::GetCString(UA_PREF("device_string"), deviceString);

    if (NS_SUCCEEDED(rv)) {

        deviceString.Trim(" ", true, true);

        deviceString.ReplaceSubstring(NS_LITERAL_CSTRING("%DEVICEID%"), deviceModelId);

        return deviceString;

    }

    return deviceModelId;

}

#endif

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

// nsHttpHandler <public>

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

StaticRefPtr<nsHttpHandler> gHttpHandler;

/* static */ already_AddRefed<nsHttpHandler>

nsHttpHandler::GetInstance()

{

    if (!gHttpHandler) {

        gHttpHandler = new nsHttpHandler();

        DebugOnly<nsresult> rv = gHttpHandler->Init();

        MOZ_ASSERT(NS_SUCCEEDED(rv));

        ClearOnShutdown(&gHttpHandler);

    }

    RefPtr<nsHttpHandler> httpHandler = gHttpHandler;

    return httpHandler.forget();

}

nsHttpHandler::nsHttpHandler()

    : mHttpVersion(HttpVersion::v1_1)

    , mProxyHttpVersion(HttpVersion::v1_1)

    , mCapabilities(NS_HTTP_ALLOW_KEEPALIVE)

    , mReferrerLevel(0xff) // by default we always send a referrer

    , mSpoofReferrerSource(false)

    , mHideOnionReferrerSource(false)

    , mReferrerTrimmingPolicy(0)

    , mReferrerXOriginTrimmingPolicy(0)

    , mReferrerXOriginPolicy(0)

    , mFastFallbackToIPv4(false)

    , mIdleTimeout(PR_SecondsToInterval(10))

    , mSpdyTimeout(PR_SecondsToInterval(180))

    , mResponseTimeout(PR_SecondsToInterval(300))

    , mResponseTimeoutEnabled(false)

    , mNetworkChangedTimeout(5000)

    , mMaxRequestAttempts(6)

    , mMaxRequestDelay(10)

    , mIdleSynTimeout(250)

    , mFallbackSynTimeout(5)

    , mH2MandatorySuiteEnabled(false)

    , mMaxUrgentExcessiveConns(3)

    , mMaxConnections(24)

    , mMaxPersistentConnectionsPerServer(2)

    , mMaxPersistentConnectionsPerProxy(4)

    , mThrottleEnabled(true)

    , mThrottleVersion(2)

    , mThrottleSuspendFor(3000)

    , mThrottleResumeFor(200)

    , mThrottleReadLimit(8000)

    , mThrottleReadInterval(500)

    , mThrottleHoldTime(600)

    , mThrottleMaxTime(3000)

    , mSendWindowSize(1024)

    , mUrgentStartEnabled(true)

    , mTailBlockingEnabled(true)

    , mTailDelayQuantum(600)

    , mTailDelayQuantumAfterDCL(100)

    , mTailDelayMax(6000)

    , mTailTotalMax(0)

    , mRedirectionLimit(10)

    , mPhishyUserPassLength(1)

    , mQoSBits(0x00)

    , mEnforceAssocReq(false)

    , mLastUniqueID(NowInSeconds())

    , mSessionStartTime(0)

    , mLegacyAppName("Mozilla")

    , mLegacyAppVersion("5.0")

    , mProduct("Gecko")

    , mCompatFirefoxEnabled(false)

    , mUserAgentIsDirty(true)

    , mAcceptLanguagesIsDirty(true)

    , mPromptTempRedirect(true)

    , mEnablePersistentHttpsCaching(false)

    , mDoNotTrackEnabled(false)

    , mSafeHintEnabled(false)

    , mParentalControlEnabled(false)

    , mHandlerActive(false)

    , mTelemetryEnabled(false)

    , mAllowExperiments(true)

    , mDebugObservations(false)

    , mEnableSpdy(false)

    , mHttp2Enabled(true)

    , mUseH2Deps(true)

    , mEnforceHttp2TlsProfile(true)

    , mCoalesceSpdy(true)

    , mSpdyPersistentSettings(false)

    , mAllowPush(true)

    , mEnableAltSvc(false)

    , mEnableAltSvcOE(false)

    , mEnableOriginExtension(false)

    , mSpdySendingChunkSize(ASpdySession::kSendingChunkSize)

    , mSpdySendBufferSize(ASpdySession::kTCPSendBufferSize)

    , mSpdyPushAllowance(131072) // match default pref

    , mSpdyPullAllowance(ASpdySession::kInitialRwin)

    , mDefaultSpdyConcurrent(ASpdySession::kDefaultMaxConcurrent)

    , mSpdyPingThreshold(PR_SecondsToInterval(58))

    , mSpdyPingTimeout(PR_SecondsToInterval(8))

    , mConnectTimeout(90000)

    , mTLSHandshakeTimeout(30000)

    , mParallelSpeculativeConnectLimit(6)

    , mSpeculativeConnectEnabled(true)

    , mRequestTokenBucketEnabled(true)

    , mRequestTokenBucketMinParallelism(6)

    , mRequestTokenBucketHz(100)

    , mRequestTokenBucketBurst(32)

    , mCriticalRequestPrioritization(true)

    , mTCPKeepaliveShortLivedEnabled(false)

    , mTCPKeepaliveShortLivedTimeS(60)

    , mTCPKeepaliveShortLivedIdleTimeS(10)

    , mTCPKeepaliveLongLivedEnabled(false)

    , mTCPKeepaliveLongLivedIdleTimeS(600)

    , mEnforceH1Framing(FRAMECHECK_BARELY)

    , mDefaultHpackBuffer(4096)

    , mMaxHttpResponseHeaderSize(393216)

    , mFocusedWindowTransactionRatio(0.9f)

    , mUseFastOpen(true)

    , mFastOpenConsecutiveFailureLimit(5)

    , mFastOpenConsecutiveFailureCounter(0)

    , mFastOpenStallsLimit(3)

    , mFastOpenStallsCounter(0)

    , mFastOpenStallsIdleTime(10)

    , mFastOpenStallsTimeout(20)

    , mActiveTabPriority(true)

    , mProcessId(0)

    , mNextChannelId(1)

    , mLastActiveTabLoadOptimizationLock("nsHttpConnectionMgr::LastActiveTabLoadOptimization")

{

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

    mUserAgentOverride.SetIsVoid(true);

    MOZ_ASSERT(!gHttpHandler, "HTTP handler already created!");

    nsCOMPtr<nsIXULRuntime> runtime = do_GetService("@mozilla.org/xre/runtime;1");

    if (runtime) {

        runtime->GetProcessID(&mProcessId);

    }

    SetFastOpenOSSupport();

}

void

nsHttpHandler::SetFastOpenOSSupport()

{

    mFastOpenSupported = false;

#if !defined(XP_WIN) && !defined(XP_LINUX) && !defined(ANDROID) && !defined(HAS_CONNECTX)

    return;

#elif defined(XP_WIN)

    mFastOpenSupported = IsWindows10BuildOrLater(16299);

    if (mFastOpenSupported) {

        // We have some problems with lavasoft software and tcp fast open.

        if (GetModuleHandleW(L"pmls64.dll") || GetModuleHandleW(L"rlls64.dll")) {

            mFastOpenSupported = false;

        }

    }

#else

    nsAutoCString version;

    nsresult rv;

#ifdef ANDROID

    nsCOMPtr<nsIPropertyBag2> infoService =

        do_GetService("@mozilla.org/system-info;1");

    MOZ_ASSERT(infoService, "Could not find a system info service");

    rv = infoService->GetPropertyAsACString(

        NS_LITERAL_STRING("sdk_version"), version);

#else

    char buf[SYS_INFO_BUFFER_LENGTH];

    if (PR_GetSystemInfo(PR_SI_RELEASE, buf, sizeof(buf)) == PR_SUCCESS) {

        version = buf;

        rv = NS_OK;

    } else {

        rv = NS_ERROR_FAILURE;

    }

#endif

    LOG(("nsHttpHandler::SetFastOpenOSSupport version %s", version.get()));

    if (NS_SUCCEEDED(rv)) {

        // set min version minus 1.

#if XP_MACOSX

        int min_version[] = {17, 5}; // High Sierra 10.13.4

#elif ANDROID

        int min_version[] = {4, 4};

#elif XP_LINUX

        int min_version[] = {3, 6};

#endif

        int inx = 0;

        nsCCharSeparatedTokenizer tokenizer(version, '.');

        while ((inx < 2) && tokenizer.hasMoreTokens()) {

            nsAutoCString token(tokenizer.nextToken());

            const char* nondigit = NS_strspnp("0123456789", token.get());

            if (nondigit && *nondigit) {

                break;

            }

            nsresult rv;

            int32_t ver = token.ToInteger(&rv);

            if (NS_FAILED(rv)) {

                break;

            }

            if (ver > min_version[inx]) {

                mFastOpenSupported = true;

                break;

            } else if (ver == min_version[inx] && inx == 1) {

                mFastOpenSupported = true;

            } else if (ver < min_version[inx]) {

                break;

            }

            inx++;

        }

    }

#endif

    LOG(("nsHttpHandler::SetFastOpenOSSupport %s supported.\n",

         mFastOpenSupported ? "" : "not"));

}

void

nsHttpHandler::EnsureUAOverridesInit()

{

    MOZ_ASSERT(XRE_IsParentProcess());

    MOZ_ASSERT(NS_IsMainThread());

    nsresult rv;

    nsCOMPtr<nsISupports> bootstrapper

        = do_GetService("@mozilla.org/network/ua-overrides-bootstrapper;1", &rv);

    MOZ_ASSERT(bootstrapper);

    MOZ_ASSERT(NS_SUCCEEDED(rv));

}

nsHttpHandler::~nsHttpHandler()

{

    LOG(("Deleting nsHttpHandler [this=%p]\n", this));

    // make sure the connection manager is shutdown

    if (mConnMgr) {

        nsresult rv = mConnMgr->Shutdown();

        if (NS_FAILED(rv)) {

            LOG(("nsHttpHandler [this=%p] "

                 "failed to shutdown connection manager (%08x)\n",

                 this, static_cast<uint32_t>(rv)));

        }

        mConnMgr = nullptr;

    }

    // Note: don't call NeckoChild::DestroyNeckoChild() here, as it's too late

    // and it'll segfault.  NeckoChild will get cleaned up by process exit.

    nsHttp::DestroyAtomTable();

}

static const char* gCallbackPrefs[] = {

    HTTP_PREF_PREFIX,

    UA_PREF_PREFIX,

    INTL_ACCEPT_LANGUAGES,

    BROWSER_PREF("disk_cache_ssl"),

    DONOTTRACK_HEADER_ENABLED,

    TELEMETRY_ENABLED,

    H2MANDATORY_SUITE,

    HTTP_PREF("tcp_keepalive.short_lived_connections"),

    HTTP_PREF("tcp_keepalive.long_lived_connections"),

    SAFE_HINT_HEADER_VALUE,

    SECURITY_PREFIX,

    TCP_FAST_OPEN_ENABLE,

    TCP_FAST_OPEN_FAILURE_LIMIT,

    TCP_FAST_OPEN_STALLS_LIMIT,

    TCP_FAST_OPEN_STALLS_IDLE,

    TCP_FAST_OPEN_STALLS_TIMEOUT,

    nullptr,

};

nsresult

nsHttpHandler::Init()

{

    nsresult rv;

    LOG(("nsHttpHandler::Init\n"));

    MOZ_ASSERT(NS_IsMainThread());

    rv = nsHttp::CreateAtomTable();

    if (NS_FAILED(rv))

        return rv;

    nsCOMPtr<nsIIOService> service = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);

    if (NS_FAILED(rv)) {

        NS_WARNING("unable to continue without io service");

        return rv;

    }

    mIOService = new nsMainThreadPtrHolder<nsIIOService>(

      "nsHttpHandler::mIOService", service);

    if (IsNeckoChild())

        NeckoChild::InitNeckoChild();

    InitUserAgentComponents();

    // This perference is only used in parent process.

    if (!IsNeckoChild()) {

        mActiveTabPriority =

            Preferences::GetBool(HTTP_PREF("active_tab_priority"), true);

    }

    // monitor some preference changes

    Preferences::RegisterPrefixCallbacks(

        PREF_CHANGE_METHOD(nsHttpHandler::PrefsChanged),

        gCallbackPrefs,

        this);

    PrefsChanged(nullptr);

    mMisc.AssignLiteral("rv:" MOZILLA_UAVERSION);

    mCompatFirefox.AssignLiteral("Firefox/" MOZILLA_UAVERSION);

    nsCOMPtr<nsIXULAppInfo> appInfo =

        do_GetService("@mozilla.org/xre/app-info;1");

    mAppName.AssignLiteral(MOZ_APP_UA_NAME);

    if (mAppName.Length() == 0 && appInfo) {

        // Try to get the UA name from appInfo, falling back to the name

        appInfo->GetUAName(mAppName);

        if (mAppName.Length() == 0) {

          appInfo->GetName(mAppName);

        }

        appInfo->GetVersion(mAppVersion);

        mAppName.StripChars(R"( ()<>@,;:\"/[]?={})");

    } else {

        mAppVersion.AssignLiteral(MOZ_APP_UA_VERSION);

    }

    // Generating the spoofed User Agent for fingerprinting resistance.

    rv = nsRFPService::GetSpoofedUserAgent(mSpoofedUserAgent);

    if (NS_FAILED(rv)) {

      // Empty mSpoofedUserAgent to make sure the unsuccessful spoofed UA string

      // will not be used anywhere.

      mSpoofedUserAgent.Truncate();

    }

    mSessionStartTime = NowInSeconds();

    mHandlerActive = true;

    rv = InitConnectionMgr();

    if (NS_FAILED(rv)) return rv;

    mRequestContextService =

        do_GetService("@mozilla.org/network/request-context-service;1");

#if defined(ANDROID)

    mProductSub.AssignLiteral(MOZILLA_UAVERSION);

#else

    mProductSub.AssignLiteral(LEGACY_BUILD_ID);

#endif

#if DEBUG

    // dump user agent prefs

    LOG(("> legacy-app-name = %s\n", mLegacyAppName.get()));

    LOG(("> legacy-app-version = %s\n", mLegacyAppVersion.get()));

    LOG(("> platform = %s\n", mPlatform.get()));

    LOG(("> oscpu = %s\n", mOscpu.get()));

    LOG(("> misc = %s\n", mMisc.get()));

    LOG(("> product = %s\n", mProduct.get()));

    LOG(("> product-sub = %s\n", mProductSub.get()));

    LOG(("> app-name = %s\n", mAppName.get()));

    LOG(("> app-version = %s\n", mAppVersion.get()));

    LOG(("> compat-firefox = %s\n", mCompatFirefox.get()));

    LOG(("> user-agent = %s\n", UserAgent().get()));

#endif

    // Startup the http category

    // Bring alive the objects in the http-protocol-startup category

    NS_CreateServicesFromCategory(NS_HTTP_STARTUP_CATEGORY,

                                  static_cast<nsISupports*>(static_cast<void*>(this)),

                                  NS_HTTP_STARTUP_TOPIC);

    nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();

    if (obsService) {

        // register the handler object as a weak callback as we don't need to worry

        // about shutdown ordering.

        obsService->AddObserver(this, "profile-change-net-teardown", true);

        obsService->AddObserver(this, "profile-change-net-restore", true);

        obsService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);

        obsService->AddObserver(this, "net:clear-active-logins", true);

        obsService->AddObserver(this, "net:prune-dead-connections", true);

        // Sent by the TorButton add-on in the Tor Browser

        obsService->AddObserver(this, "net:prune-all-connections", true);

        obsService->AddObserver(this, "net:cancel-all-connections", true);

        obsService->AddObserver(this, "last-pb-context-exited", true);

        obsService->AddObserver(this, "browser:purge-session-history", true);

        obsService->AddObserver(this, NS_NETWORK_LINK_TOPIC, true);

        obsService->AddObserver(this, "application-background", true);

        obsService->AddObserver(this, "psm:user-certificate-added", true);

        obsService->AddObserver(this, "psm:user-certificate-deleted", true);

        obsService->AddObserver(this, "intl:app-locales-changed", true);

        if (!IsNeckoChild()) {

            obsService->AddObserver(this,

                                    "net:current-toplevel-outer-content-windowid",

                                    true);

        }

        if (mFastOpenSupported) {

            obsService->AddObserver(this, "captive-portal-login", true);

            obsService->AddObserver(this, "captive-portal-login-success", true);

        }

        // disabled as its a nop right now

        // obsService->AddObserver(this, "net:failed-to-process-uri-content", true);

    }

    MakeNewRequestTokenBucket();

    mWifiTickler = new Tickler();

    if (NS_FAILED(mWifiTickler->Init()))

        mWifiTickler = nullptr;

    nsCOMPtr<nsIParentalControlsService> pc = do_CreateInstance("@mozilla.org/parental-controls-service;1");

    if (pc) {

        pc->GetParentalControlsEnabled(&mParentalControlEnabled);

    }

    return NS_OK;

}

void

nsHttpHandler::MakeNewRequestTokenBucket()

{

    LOG(("nsHttpHandler::MakeNewRequestTokenBucket this=%p child=%d\n",

         this, IsNeckoChild()));

    if (!mConnMgr || IsNeckoChild()) {

        return;

    }

    RefPtr<EventTokenBucket> tokenBucket =

        new EventTokenBucket(RequestTokenBucketHz(), RequestTokenBucketBurst());

    // NOTE The thread or socket may be gone already.

    nsresult rv = mConnMgr->UpdateRequestTokenBucket(tokenBucket);

    if (NS_FAILED(rv)) {

        LOG(("    failed to update request token bucket\n"));

    }

}

nsresult

nsHttpHandler::InitConnectionMgr()

{

    // Init ConnectionManager only on parent!

    if (IsNeckoChild()) {

        return NS_OK;

    }

    nsresult rv;

    if (!mConnMgr) {

        mConnMgr = new nsHttpConnectionMgr();

    }

    rv = mConnMgr->Init(mMaxUrgentExcessiveConns,

                        mMaxConnections,

                        mMaxPersistentConnectionsPerServer,

                        mMaxPersistentConnectionsPerProxy,

                        mMaxRequestDelay,

                        mThrottleEnabled,

                        mThrottleVersion,

                        mThrottleSuspendFor,

                        mThrottleResumeFor,

                        mThrottleReadLimit,

                        mThrottleReadInterval,

                        mThrottleHoldTime,

                        mThrottleMaxTime);

    return rv;

}

nsresult

nsHttpHandler::AddStandardRequestHeaders(nsHttpRequestHead *request, bool isSecure)

{

    nsresult rv;

    // Add the "User-Agent" header

    rv = request->SetHeader(nsHttp::User_Agent, UserAgent(),

                            false, nsHttpHeaderArray::eVarietyRequestDefault);

    if (NS_FAILED(rv)) return rv;

    // MIME based content negotiation lives!

    // Add the "Accept" header.  Note, this is set as an override because the

    // service worker expects to see it.  The other "default" headers are

    // hidden from service worker interception.

    rv = request->SetHeader(nsHttp::Accept, mAccept,

                            false, nsHttpHeaderArray::eVarietyRequestOverride);

    if (NS_FAILED(rv)) return rv;

    // Add the "Accept-Language" header.  This header is also exposed to the

    // service worker.

    if (mAcceptLanguagesIsDirty) {

        rv = SetAcceptLanguages();

        MOZ_ASSERT(NS_SUCCEEDED(rv));

    }

    // Add the "Accept-Language" header

    if (!mAcceptLanguages.IsEmpty()) {

        rv = request->SetHeader(nsHttp::Accept_Language, mAcceptLanguages,

                                false,

                                nsHttpHeaderArray::eVarietyRequestOverride);

        if (NS_FAILED(rv)) return rv;

    }

    // Add the "Accept-Encoding" header

    if (isSecure) {

        rv = request->SetHeader(nsHttp::Accept_Encoding, mHttpsAcceptEncodings,

                                false,

                                nsHttpHeaderArray::eVarietyRequestDefault);

    } else {

        rv = request->SetHeader(nsHttp::Accept_Encoding, mHttpAcceptEncodings,

                                false,

                                nsHttpHeaderArray::eVarietyRequestDefault);

    }

    if (NS_FAILED(rv)) return rv;

    // add the "Send Hint" header

    if (mSafeHintEnabled || mParentalControlEnabled) {

      rv = request->SetHeader(nsHttp::Prefer, NS_LITERAL_CSTRING("safe"),

                              false,

                              nsHttpHeaderArray::eVarietyRequestDefault);

      if (NS_FAILED(rv)) return rv;

    }

    return NS_OK;

}

nsresult

nsHttpHandler::AddConnectionHeader(nsHttpRequestHead *request,

                                   uint32_t caps)

{

    // RFC2616 section 19.6.2 states that the "Connection: keep-alive"

    // and "Keep-alive" request headers should not be sent by HTTP/1.1

    // user-agents.  But this is not a problem in practice, and the

    // alternative proxy-connection is worse. see 570283

    NS_NAMED_LITERAL_CSTRING(close, "close");

    NS_NAMED_LITERAL_CSTRING(keepAlive, "keep-alive");

    const nsLiteralCString *connectionType = &close;

    if (caps & NS_HTTP_ALLOW_KEEPALIVE) {

        connectionType = &keepAlive;

    }

    return request->SetHeader(nsHttp::Connection, *connectionType);

}

bool

nsHttpHandler::IsAcceptableEncoding(const char *enc, bool isSecure)

{

    if (!enc)

        return false;

    // we used to accept x-foo anytime foo was acceptable, but that's just

    // continuing bad behavior.. so limit it to known x-* patterns

    bool rv;

    if (isSecure) {

        rv = nsHttp::FindToken(mHttpsAcceptEncodings.get(), enc, HTTP_LWS ",") != nullptr;

    } else {

        rv = nsHttp::FindToken(mHttpAcceptEncodings.get(), enc, HTTP_LWS ",") != nullptr;

    }

    // gzip and deflate are inherently acceptable in modern HTTP - always

    // process them if a stream converter can also be found.

    if (!rv &&

        (!PL_strcasecmp(enc, "gzip") || !PL_strcasecmp(enc, "deflate") ||

         !PL_strcasecmp(enc, "x-gzip") || !PL_strcasecmp(enc, "x-deflate"))) {

        rv = true;

    }

    LOG(("nsHttpHandler::IsAceptableEncoding %s https=%d %d\n",

         enc, isSecure, rv));

    return rv;

}

void

nsHttpHandler::IncrementFastOpenConsecutiveFailureCounter()

{

    LOG(("nsHttpHandler::IncrementFastOpenConsecutiveFailureCounter - "

         "failed=%d failure_limit=%d", mFastOpenConsecutiveFailureCounter,

         mFastOpenConsecutiveFailureLimit));

    if (mFastOpenConsecutiveFailureCounter < mFastOpenConsecutiveFailureLimit) {

        mFastOpenConsecutiveFailureCounter++;

        if (mFastOpenConsecutiveFailureCounter == mFastOpenConsecutiveFailureLimit) {

            LOG(("nsHttpHandler::IncrementFastOpenConsecutiveFailureCounter - "

                 "Fast open failed too many times"));

        }

    }

}

void

nsHttpHandler::IncrementFastOpenStallsCounter()

{

  LOG(("nsHttpHandler::IncrementFastOpenStallsCounter - failed=%d "

        "failure_limit=%d", mFastOpenStallsCounter, mFastOpenStallsLimit));

  if (mFastOpenStallsCounter < mFastOpenStallsLimit) {

    mFastOpenStallsCounter++;

    if (mFastOpenStallsCounter == mFastOpenStallsLimit) {

      LOG(("nsHttpHandler::IncrementFastOpenStallsCounter - "

           "There are too many stalls involving TFO and TLS."));

    }

  }

}

nsresult

nsHttpHandler::GetStreamConverterService(nsIStreamConverterService **result)

{

    if (!mStreamConvSvc) {

        nsresult rv;

        nsCOMPtr<nsIStreamConverterService> service =

            do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);

        if (NS_FAILED(rv))

            return rv;

        mStreamConvSvc = new nsMainThreadPtrHolder<nsIStreamConverterService>(

          "nsHttpHandler::mStreamConvSvc", service);

    }

    *result = mStreamConvSvc;

    NS_ADDREF(*result);

    return NS_OK;

}

nsISiteSecurityService*

nsHttpHandler::GetSSService()

{

    if (!mSSService) {

        nsCOMPtr<nsISiteSecurityService> service = do_GetService(NS_SSSERVICE_CONTRACTID);

        mSSService = new nsMainThreadPtrHolder<nsISiteSecurityService>(

          "nsHttpHandler::mSSService", service);

    }

    return mSSService;

}

nsICookieService *

nsHttpHandler::GetCookieService()

{

    if (!mCookieService) {

        nsCOMPtr<nsICookieService> service = do_GetService(NS_COOKIESERVICE_CONTRACTID);

        mCookieService = new nsMainThreadPtrHolder<nsICookieService>(

          "nsHttpHandler::mCookieService", service);

    }

    return mCookieService;

}

nsresult

nsHttpHandler::GetIOService(nsIIOService** result)

{

    NS_ENSURE_ARG_POINTER(result);

    NS_ADDREF(*result = mIOService);

    return NS_OK;

}

uint32_t

nsHttpHandler::Get32BitsOfPseudoRandom()

{

    // only confirm rand seeding on socket thread

    MOZ_ASSERT(OnSocketThread(), "not on socket thread");

    // rand() provides different amounts of PRNG on different platforms.

    // 15 or 31 bits are common amounts.

    static_assert(RAND_MAX >= 0xfff, "RAND_MAX should be >= 12 bits");

#if RAND_MAX < 0xffffU

    return ((uint16_t) rand() << 20) |

            (((uint16_t) rand() & 0xfff) << 8) |

            ((uint16_t) rand() & 0xff);

#elif RAND_MAX < 0xffffffffU

    return ((uint16_t) rand() << 16) | ((uint16_t) rand() & 0xffff);

#else

    return (uint32_t) rand();

#endif

}

void

nsHttpHandler::NotifyObservers(nsIHttpChannel *chan, const char *event)

{

    LOG(("nsHttpHandler::NotifyObservers [chan=%p event=\"%s\"]\n", chan, event));

    nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();

    if (obsService)

        obsService->NotifyObservers(chan, event, nullptr);

}

nsresult

nsHttpHandler::AsyncOnChannelRedirect(nsIChannel* oldChan,

                                      nsIChannel* newChan,

                                      uint32_t flags,

                                      nsIEventTarget* mainThreadEventTarget)

{

  MOZ_ASSERT(NS_IsMainThread() && (oldChan && newChan));

  nsCOMPtr<nsIURI> newURI;

  newChan->GetURI(getter_AddRefs(newURI));

  MOZ_ASSERT(newURI);

  nsAutoCString scheme;

  newURI->GetScheme(scheme);

  MOZ_ASSERT(!scheme.IsEmpty());

  Telemetry::AccumulateCategoricalKeyed(

    scheme,

    oldChan->IsDocument()

      ? LABELS_NETWORK_HTTP_REDIRECT_TO_SCHEME::topLevel

      : LABELS_NETWORK_HTTP_REDIRECT_TO_SCHEME::subresource);

  // TODO E10S This helper has to be initialized on the other process

  RefPtr<nsAsyncRedirectVerifyHelper> redirectCallbackHelper =

    new nsAsyncRedirectVerifyHelper();

  return redirectCallbackHelper->Init(

    oldChan, newChan, flags, mainThreadEventTarget);

}

/* static */ nsresult

nsHttpHandler::GenerateHostPort(const nsCString& host, int32_t port,

                                nsACString& hostLine)

{

    return NS_GenerateHostPort(host, port, hostLine);

}

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

// nsHttpHandler <private>

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

const nsCString&

nsHttpHandler::UserAgent()

{

    if (nsContentUtils::ShouldResistFingerprinting() &&

        !mSpoofedUserAgent.IsEmpty()) {

        LOG(("using spoofed userAgent : %s\n", mSpoofedUserAgent.get()));

        return mSpoofedUserAgent;

    }

    if (!mUserAgentOverride.IsVoid()) {

        LOG(("using general.useragent.override : %s\n", mUserAgentOverride.get()));

        return mUserAgentOverride;

    }

    if (mUserAgentIsDirty) {

        BuildUserAgent();

        mUserAgentIsDirty = false;

    }

    return mUserAgent;

}

void

nsHttpHandler::BuildUserAgent()

{

    LOG(("nsHttpHandler::BuildUserAgent\n"));

    MOZ_ASSERT(!mLegacyAppName.IsEmpty() &&

               !mLegacyAppVersion.IsEmpty(),

               "HTTP cannot send practical requests without this much");

    // preallocate to worst-case size, which should always be better

    // than if we didn't preallocate at all.

    mUserAgent.SetCapacity(mLegacyAppName.Length() +

                           mLegacyAppVersion.Length() +

#ifndef UA_SPARE_PLATFORM

                           mPlatform.Length() +

#endif

                           mOscpu.Length() +

                           mMisc.Length() +

                           mProduct.Length() +

                           mProductSub.Length() +

                           mAppName.Length() +

                           mAppVersion.Length() +

                           mCompatFirefox.Length() +

                           mCompatDevice.Length() +

                           mDeviceModelId.Length() +

                           13);

    // Application portion

    mUserAgent.Assign(mLegacyAppName);

    mUserAgent += '/';

    mUserAgent += mLegacyAppVersion;

    mUserAgent += ' ';

    // Application comment

    mUserAgent += '(';

#ifndef UA_SPARE_PLATFORM

    if (!mPlatform.IsEmpty()) {

      mUserAgent += mPlatform;

      mUserAgent.AppendLiteral("; ");

    }

#endif

    if (!mCompatDevice.IsEmpty()) {

        mUserAgent += mCompatDevice;

        mUserAgent.AppendLiteral("; ");

    }

    else if (!mOscpu.IsEmpty()) {

      mUserAgent += mOscpu;

      mUserAgent.AppendLiteral("; ");

    }

    if (!mDeviceModelId.IsEmpty()) {

        mUserAgent += mDeviceModelId;

        mUserAgent.AppendLiteral("; ");

    }

    mUserAgent += mMisc;

    mUserAgent += ')';

    // Product portion

    mUserAgent += ' ';

    mUserAgent += mProduct;

    mUserAgent += '/';

    mUserAgent += mProductSub;

    bool isFirefox = mAppName.EqualsLiteral("Firefox");

    if (isFirefox || mCompatFirefoxEnabled) {

        // "Firefox/x.y" (compatibility) app token

        mUserAgent += ' ';

        mUserAgent += mCompatFirefox;

    }

    if (!isFirefox) {

        // App portion

        mUserAgent += ' ';