diff options
Diffstat (limited to 'netwerk/base/nsPACMan.cpp')
| -rw-r--r-- | netwerk/base/nsPACMan.cpp | 1009 |
1 files changed, 1009 insertions, 0 deletions
diff --git a/netwerk/base/nsPACMan.cpp b/netwerk/base/nsPACMan.cpp new file mode 100644 index 0000000000..0cf66c8ee6 --- /dev/null +++ b/netwerk/base/nsPACMan.cpp @@ -0,0 +1,1009 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/. */ + +#include "nsPACMan.h" + +#include "mozilla/Preferences.h" +#include "nsContentUtils.h" +#include "nsComponentManagerUtils.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsIAuthPrompt.h" +#include "nsIDHCPClient.h" +#include "nsIHttpChannel.h" +#include "nsIPrefBranch.h" +#include "nsIPromptFactory.h" +#include "nsIProtocolProxyService.h" +#include "nsISystemProxySettings.h" +#include "nsIOService.h" +#include "nsNetUtil.h" +#include "nsThreadUtils.h" +#include "mozilla/ResultExtensions.h" +#include "mozilla/StaticPrefs_network.h" +#include "mozilla/Telemetry.h" +#include "mozilla/Try.h" + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +LazyLogModule gProxyLog("proxy"); + +#undef LOG +#define LOG(args) MOZ_LOG(gProxyLog, LogLevel::Debug, args) +#define MOZ_WPAD_URL "http://wpad/wpad.dat" +#define MOZ_DHCP_WPAD_OPTION 252 + +// These pointers are declared in nsProtocolProxyService.cpp +extern const char kProxyType_HTTPS[]; +extern const char kProxyType_DIRECT[]; + +// The PAC thread does evaluations of both PAC files and +// nsISystemProxySettings because they can both block the calling thread and we +// don't want that on the main thread + +// Check to see if the underlying request was not an error page in the case of +// a HTTP request. For other types of channels, just return true. +static bool HttpRequestSucceeded(nsIStreamLoader* loader) { + nsCOMPtr<nsIRequest> request; + loader->GetRequest(getter_AddRefs(request)); + + bool result = true; // default to assuming success + + nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(request); + if (httpChannel) { + // failsafe + Unused << httpChannel->GetRequestSucceeded(&result); + } + + return result; +} + +// Read preference setting of extra JavaScript context heap size. +// PrefService tends to be run on main thread, where ProxyAutoConfig runs on +// ProxyResolution thread, so it's read here and passed to ProxyAutoConfig. +static uint32_t GetExtraJSContextHeapSize() { + MOZ_ASSERT(NS_IsMainThread()); + + static int32_t extraSize = -1; + + if (extraSize < 0) { + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + int32_t value; + + if (prefs && + NS_SUCCEEDED(prefs->GetIntPref( + "network.proxy.autoconfig_extra_jscontext_heap_size", &value))) { + LOG(("autoconfig_extra_jscontext_heap_size: %d\n", value)); + + extraSize = value; + } + } + + return extraSize < 0 ? 0 : extraSize; +} + +// Read network proxy type from preference +// Used to verify that the preference is WPAD in nsPACMan::ConfigureWPAD +nsresult GetNetworkProxyTypeFromPref(int32_t* type) { + *type = 0; + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + + if (!prefs) { + LOG(("Failed to get a preference service object")); + return NS_ERROR_FACTORY_NOT_REGISTERED; + } + nsresult rv = prefs->GetIntPref("network.proxy.type", type); + if (NS_FAILED(rv)) { + LOG(("Failed to retrieve network.proxy.type from prefs")); + return rv; + } + LOG(("network.proxy.type pref retrieved: %d\n", *type)); + return NS_OK; +} + +//----------------------------------------------------------------------------- + +// The ExecuteCallback runnable is triggered by +// nsPACManCallback::OnQueryComplete on the Main thread when its completion is +// discovered on the pac thread + +class ExecuteCallback final : public Runnable { + public: + ExecuteCallback(nsPACManCallback* aCallback, nsresult status) + : Runnable("net::ExecuteCallback"), + mCallback(aCallback), + mStatus(status) {} + + void SetPACString(const nsACString& pacString) { mPACString = pacString; } + + void SetPACURL(const nsACString& pacURL) { mPACURL = pacURL; } + + NS_IMETHOD Run() override { + mCallback->OnQueryComplete(mStatus, mPACString, mPACURL); + mCallback = nullptr; + return NS_OK; + } + + private: + RefPtr<nsPACManCallback> mCallback; + nsresult mStatus; + nsCString mPACString; + nsCString mPACURL; +}; + +//----------------------------------------------------------------------------- + +// The PAC thread must be deleted from the main thread, this class +// acts as a proxy to do that, as the PACMan is reference counted +// and might be destroyed on either thread + +class ShutdownThread final : public Runnable { + public: + explicit ShutdownThread(nsIThread* thread) + : Runnable("net::ShutdownThread"), mThread(thread) {} + + NS_IMETHOD Run() override { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mThread->Shutdown(); + return NS_OK; + } + + private: + nsCOMPtr<nsIThread> mThread; +}; + +// Dispatch this to wait until the PAC thread shuts down. + +class WaitForThreadShutdown final : public Runnable { + public: + explicit WaitForThreadShutdown(nsPACMan* aPACMan) + : Runnable("net::WaitForThreadShutdown"), mPACMan(aPACMan) {} + + NS_IMETHOD Run() override { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + if (mPACMan->mPACThread) { + mPACMan->mPACThread->Shutdown(); + mPACMan->mPACThread = nullptr; + } + return NS_OK; + } + + private: + RefPtr<nsPACMan> mPACMan; +}; + +//----------------------------------------------------------------------------- + +// PACLoadComplete allows the PAC thread to tell the main thread that +// the javascript PAC file has been installed (perhaps unsuccessfully) +// and that there is no reason to queue executions anymore + +class PACLoadComplete final : public Runnable { + public: + explicit PACLoadComplete(nsPACMan* aPACMan) + : Runnable("net::PACLoadComplete"), mPACMan(aPACMan) {} + + NS_IMETHOD Run() override { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + { + auto loader = mPACMan->mLoader.Lock(); + loader.ref() = nullptr; + } + mPACMan->PostProcessPendingQ(); + return NS_OK; + } + + private: + RefPtr<nsPACMan> mPACMan; +}; + +//----------------------------------------------------------------------------- + +// ConfigureWPADComplete allows the PAC thread to tell the main thread that +// the URL for the PAC file has been found +class ConfigureWPADComplete final : public Runnable { + public: + ConfigureWPADComplete(nsPACMan* aPACMan, const nsACString& aPACURISpec) + : Runnable("net::ConfigureWPADComplete"), + mPACMan(aPACMan), + mPACURISpec(aPACURISpec) {} + + NS_IMETHOD Run() override { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mPACMan->AssignPACURISpec(mPACURISpec); + mPACMan->ContinueLoadingAfterPACUriKnown(); + return NS_OK; + } + + private: + RefPtr<nsPACMan> mPACMan; + nsCString mPACURISpec; +}; + +//----------------------------------------------------------------------------- + +// ExecutePACThreadAction is used to proxy actions from the main +// thread onto the PAC thread. There are 4 options: process the queue, +// cancel the queue, query DHCP for the PAC option +// and setup the javascript context with a new PAC file + +class ExecutePACThreadAction final : public Runnable { + public: + // by default we just process the queue + explicit ExecutePACThreadAction(nsPACMan* aPACMan) + : Runnable("net::ExecutePACThreadAction"), + mPACMan(aPACMan), + mCancel(false), + mCancelStatus(NS_OK), + mSetupPAC(false), + mExtraHeapSize(0), + mConfigureWPAD(false), + mShutdown(false) {} + + void CancelQueue(nsresult status, bool aShutdown) { + mCancel = true; + mCancelStatus = status; + mShutdown = aShutdown; + } + + void SetupPAC(const char* data, uint32_t dataLen, const nsACString& pacURI, + uint32_t extraHeapSize) { + mSetupPAC = true; + mSetupPACData.Assign(data, dataLen); + mSetupPACURI = pacURI; + mExtraHeapSize = extraHeapSize; + } + + void ConfigureWPAD() { mConfigureWPAD = true; } + + NS_IMETHOD Run() override { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + if (mCancel) { + mPACMan->CancelPendingQ(mCancelStatus, mShutdown); + mCancel = false; + return NS_OK; + } + + if (mSetupPAC) { + mSetupPAC = false; + + nsCOMPtr<nsISerialEventTarget> target = mPACMan->GetNeckoTarget(); + mPACMan->mPAC->ConfigurePAC(mSetupPACURI, mSetupPACData, + mPACMan->mIncludePath, mExtraHeapSize, + target); + + RefPtr<PACLoadComplete> runnable = new PACLoadComplete(mPACMan); + mPACMan->Dispatch(runnable.forget()); + return NS_OK; + } + + if (mConfigureWPAD) { + nsAutoCString spec; + mConfigureWPAD = false; + mPACMan->ConfigureWPAD(spec); + RefPtr<ConfigureWPADComplete> runnable = + new ConfigureWPADComplete(mPACMan, spec); + mPACMan->Dispatch(runnable.forget()); + return NS_OK; + } + + mPACMan->ProcessPendingQ(); + return NS_OK; + } + + private: + RefPtr<nsPACMan> mPACMan; + + bool mCancel; + nsresult mCancelStatus; + + bool mSetupPAC; + uint32_t mExtraHeapSize; + nsCString mSetupPACData; + nsCString mSetupPACURI; + bool mConfigureWPAD; + bool mShutdown; +}; + +//----------------------------------------------------------------------------- + +PendingPACQuery::PendingPACQuery(nsPACMan* pacMan, nsIURI* uri, + nsPACManCallback* callback, uint32_t flags, + bool mainThreadResponse) + : Runnable("net::PendingPACQuery"), + mPort(0), + mFlags(flags), + mPACMan(pacMan), + mCallback(callback), + mOnMainThreadOnly(mainThreadResponse) { + uri->GetAsciiSpec(mSpec); + uri->GetAsciiHost(mHost); + uri->GetScheme(mScheme); + uri->GetPort(&mPort); +} + +void PendingPACQuery::Complete(nsresult status, const nsACString& pacString) { + if (!mCallback) return; + RefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, status); + runnable->SetPACString(pacString); + if (mOnMainThreadOnly) { + mPACMan->Dispatch(runnable.forget()); + } else { + runnable->Run(); + } +} + +void PendingPACQuery::UseAlternatePACFile(const nsACString& pacURL) { + if (!mCallback) return; + + RefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, NS_OK); + runnable->SetPACURL(pacURL); + if (mOnMainThreadOnly) { + mPACMan->Dispatch(runnable.forget()); + } else { + runnable->Run(); + } +} + +NS_IMETHODIMP +PendingPACQuery::Run() { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + mPACMan->PostQuery(this); + return NS_OK; +} + +//----------------------------------------------------------------------------- + +static bool sThreadLocalSetup = false; +static uint32_t sThreadLocalIndex = 0xdeadbeef; // out of range + +static const char* kPACIncludePath = + "network.proxy.autoconfig_url.include_path"; + +nsPACMan::nsPACMan(nsISerialEventTarget* mainThreadEventTarget) + : NeckoTargetHolder(mainThreadEventTarget), + mLoader("nsPACMan::mLoader"), + mLoadPending(false), + mShutdown(false), + mLoadFailureCount(0), + mInProgress(false), + mAutoDetect(false), + mWPADOverDHCPEnabled(false), + mProxyConfigType(0) { + MOZ_ASSERT(NS_IsMainThread(), "pacman must be created on main thread"); + mIncludePath = Preferences::GetBool(kPACIncludePath, false); + if (StaticPrefs::network_proxy_parse_pac_on_socket_process() && + gIOService->SocketProcessReady()) { + mPAC = MakeUnique<RemoteProxyAutoConfig>(); + } else { + mPAC = MakeUnique<ProxyAutoConfig>(); + if (!sThreadLocalSetup) { + sThreadLocalSetup = true; + PR_NewThreadPrivateIndex(&sThreadLocalIndex, nullptr); + } + mPAC->SetThreadLocalIndex(sThreadLocalIndex); + } +} + +nsPACMan::~nsPACMan() { + MOZ_ASSERT(mShutdown, "Shutdown must be called before dtor."); + + if (mPACThread) { + if (NS_IsMainThread()) { + mPACThread->Shutdown(); + mPACThread = nullptr; + } else { + RefPtr<ShutdownThread> runnable = new ShutdownThread(mPACThread); + Dispatch(runnable.forget()); + } + } + +#ifdef DEBUG + { + auto loader = mLoader.Lock(); + NS_ASSERTION(loader.ref() == nullptr, "pac man not shutdown properly"); + } +#endif + + NS_ASSERTION(mPendingQ.isEmpty(), "pac man not shutdown properly"); +} + +void nsPACMan::Shutdown() { + MOZ_ASSERT(NS_IsMainThread(), "pacman must be shutdown on main thread"); + if (mShutdown) { + return; + } + + CancelExistingLoad(); + + if (mPACThread) { + PostCancelPendingQ(NS_ERROR_ABORT, /*aShutdown =*/true); + + // Shutdown is initiated from an observer. We don't want to block the + // observer service on thread shutdown so we post a shutdown runnable that + // will run after we return instead. + RefPtr<WaitForThreadShutdown> runnable = new WaitForThreadShutdown(this); + Dispatch(runnable.forget()); + } + + mShutdown = true; +} + +nsresult nsPACMan::DispatchToPAC(already_AddRefed<nsIRunnable> aEvent, + bool aSync) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + + nsCOMPtr<nsIRunnable> e(aEvent); + + if (mShutdown) { + return NS_ERROR_NOT_AVAILABLE; + } + + // Lazily create the PAC thread. This method is main-thread only so we don't + // have to worry about threading issues here. + if (!mPACThread) { + MOZ_TRY(NS_NewNamedThread("ProxyResolution", getter_AddRefs(mPACThread))); + nsresult rv = mPAC->Init(mPACThread); + if (NS_FAILED(rv)) { + return rv; + } + } + + if (aSync) { + return NS_DispatchAndSpinEventLoopUntilComplete( + "nsPACMan::DispatchToPAC"_ns, mPACThread, e.forget()); + } else { + return mPACThread->Dispatch(e.forget()); + } +} + +nsresult nsPACMan::AsyncGetProxyForURI(nsIURI* uri, nsPACManCallback* callback, + uint32_t flags, + bool mainThreadResponse) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + if (mShutdown) return NS_ERROR_NOT_AVAILABLE; + + // Maybe Reload PAC + if (!mPACURISpec.IsEmpty() && !mScheduledReload.IsNull() && + TimeStamp::Now() > mScheduledReload) { + LOG(("nsPACMan::AsyncGetProxyForURI reload as scheduled\n")); + + LoadPACFromURI(mAutoDetect ? ""_ns : mPACURISpec, false); + } + + RefPtr<PendingPACQuery> query = + new PendingPACQuery(this, uri, callback, flags, mainThreadResponse); + + if (IsPACURI(uri)) { + // deal with this directly instead of queueing it + query->Complete(NS_OK, ""_ns); + return NS_OK; + } + + return DispatchToPAC(query.forget()); +} + +nsresult nsPACMan::PostQuery(PendingPACQuery* query) { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + + if (mShutdown) { + query->Complete(NS_ERROR_NOT_AVAILABLE, ""_ns); + return NS_OK; + } + + // add a reference to the query while it is in the pending list + RefPtr<PendingPACQuery> addref(query); + mPendingQ.insertBack(addref.forget().take()); + ProcessPendingQ(); + return NS_OK; +} + +nsresult nsPACMan::LoadPACFromURI(const nsACString& aSpec) { + return LoadPACFromURI(aSpec, true); +} + +nsresult nsPACMan::LoadPACFromURI(const nsACString& aSpec, + bool aResetLoadFailureCount) { + NS_ENSURE_STATE(!mShutdown); + + nsCOMPtr<nsIStreamLoader> loader = + do_CreateInstance(NS_STREAMLOADER_CONTRACTID); + NS_ENSURE_STATE(loader); + + LOG(("nsPACMan::LoadPACFromURI aSpec: %s, aResetLoadFailureCount: %s\n", + aSpec.BeginReading(), aResetLoadFailureCount ? "true" : "false")); + + CancelExistingLoad(); + + { + auto locked = mLoader.Lock(); + locked.ref() = loader.forget(); + } + mPACURIRedirectSpec.Truncate(); + mNormalPACURISpec.Truncate(); // set at load time + if (aResetLoadFailureCount) { + mLoadFailureCount = 0; + } + mAutoDetect = aSpec.IsEmpty(); + mPACURISpec.Assign(aSpec); + + // reset to Null + mScheduledReload = TimeStamp(); + + // if we're on the main thread here so we can get hold of prefs, + // we check that we have WPAD preffed on if we're auto-detecting + if (mAutoDetect && NS_IsMainThread()) { + nsresult rv = GetNetworkProxyTypeFromPref(&mProxyConfigType); + if (NS_FAILED(rv)) { + return rv; + } + if (mProxyConfigType != nsIProtocolProxyService::PROXYCONFIG_WPAD) { + LOG( + ("LoadPACFromURI - Aborting WPAD autodetection because the pref " + "doesn't match anymore")); + return NS_BINDING_ABORTED; + } + } + // Since we might get called from nsProtocolProxyService::Init, we need to + // post an event back to the main thread before we try to use the IO service. + // + // But, we need to flag ourselves as loading, so that we queue up any PAC + // queries the enter between now and when we actually load the PAC file. + + if (!mLoadPending) { + nsCOMPtr<nsIRunnable> runnable = NewRunnableMethod( + "nsPACMan::StartLoading", this, &nsPACMan::StartLoading); + nsresult rv = + NS_IsMainThread() + ? Dispatch(runnable.forget()) + : GetCurrentSerialEventTarget()->Dispatch(runnable.forget()); + if (NS_FAILED(rv)) return rv; + mLoadPending = true; + } + + return NS_OK; +} + +nsresult nsPACMan::GetPACFromDHCP(nsACString& aSpec) { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + if (!mDHCPClient) { + LOG( + ("nsPACMan::GetPACFromDHCP DHCP option %d query failed because there " + "is no DHCP client available\n", + MOZ_DHCP_WPAD_OPTION)); + return NS_ERROR_NOT_IMPLEMENTED; + } + nsresult rv; + rv = mDHCPClient->GetOption(MOZ_DHCP_WPAD_OPTION, aSpec); + if (NS_FAILED(rv)) { + LOG(( + "nsPACMan::GetPACFromDHCP DHCP option %d query failed with result %d\n", + MOZ_DHCP_WPAD_OPTION, (uint32_t)rv)); + } else { + LOG( + ("nsPACMan::GetPACFromDHCP DHCP option %d query succeeded, finding PAC " + "URL %s\n", + MOZ_DHCP_WPAD_OPTION, aSpec.BeginReading())); + } + return rv; +} + +nsresult nsPACMan::ConfigureWPAD(nsACString& aSpec) { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + + if (mProxyConfigType != nsIProtocolProxyService::PROXYCONFIG_WPAD) { + LOG( + ("ConfigureWPAD - Aborting WPAD autodetection because the pref " + "doesn't match anymore")); + return NS_BINDING_ABORTED; + } + + aSpec.Truncate(); + if (mWPADOverDHCPEnabled) { + GetPACFromDHCP(aSpec); + } + + if (aSpec.IsEmpty()) { + // We diverge from the WPAD spec here in that we don't walk the + // hosts's FQDN, stripping components until we hit a TLD. Doing so + // is dangerous in the face of an incomplete list of TLDs, and TLDs + // get added over time. We could consider doing only a single + // substitution of the first component, if that proves to help + // compatibility. + aSpec.AssignLiteral(MOZ_WPAD_URL); + } + return NS_OK; +} + +void nsPACMan::AssignPACURISpec(const nsACString& aSpec) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mPACURISpec.Assign(aSpec); +} + +void nsPACMan::StartLoading() { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mLoadPending = false; + + { + // CancelExistingLoad was called... + nsCOMPtr<nsIStreamLoader> loader; + { + auto locked = mLoader.Lock(); + loader = locked.ref(); + } + if (!loader) { + PostCancelPendingQ(NS_ERROR_ABORT); + return; + } + } + + if (mAutoDetect) { + nsresult rv = GetNetworkProxyTypeFromPref(&mProxyConfigType); + if (NS_FAILED(rv)) { + NS_WARNING( + "Could not retrieve Network Proxy Type pref when auto-detecting " + "proxy. Halting."); + return; + } + RefPtr<ExecutePACThreadAction> wpadConfigurer = + new ExecutePACThreadAction(this); + wpadConfigurer->ConfigureWPAD(); + DispatchToPAC(wpadConfigurer.forget()); + } else { + ContinueLoadingAfterPACUriKnown(); + } +} + +void nsPACMan::ContinueLoadingAfterPACUriKnown() { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + + nsCOMPtr<nsIStreamLoader> loader; + { + auto locked = mLoader.Lock(); + loader = locked.ref(); + } + + // CancelExistingLoad was called... + if (!loader) { + PostCancelPendingQ(NS_ERROR_ABORT); + return; + } + if (NS_SUCCEEDED(loader->Init(this, nullptr))) { + // Always hit the origin server when loading PAC. + nsCOMPtr<nsIIOService> ios = do_GetIOService(); + if (ios) { + nsCOMPtr<nsIChannel> channel; + nsCOMPtr<nsIURI> pacURI; + NS_NewURI(getter_AddRefs(pacURI), mPACURISpec); + + // NOTE: This results in GetProxyForURI being called + if (pacURI) { + nsresult rv = pacURI->GetSpec(mNormalPACURISpec); + MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv)); + NS_NewChannel(getter_AddRefs(channel), pacURI, + nsContentUtils::GetSystemPrincipal(), + nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL, + nsIContentPolicy::TYPE_OTHER, + nullptr, // nsICookieJarSettings + nullptr, // PerformanceStorage + nullptr, // aLoadGroup + nullptr, // aCallbacks + nsIRequest::LOAD_NORMAL, ios); + } else { + LOG(("nsPACMan::StartLoading Failed pacspec uri conversion %s\n", + mPACURISpec.get())); + } + + if (channel) { + // allow deprecated HTTP request from SystemPrincipal + nsCOMPtr<nsILoadInfo> loadInfo = channel->LoadInfo(); + loadInfo->SetAllowDeprecatedSystemRequests(true); + loadInfo->SetHttpsOnlyStatus(nsILoadInfo::HTTPS_ONLY_EXEMPT); + + channel->SetLoadFlags(nsIRequest::LOAD_BYPASS_CACHE); + channel->SetNotificationCallbacks(this); + if (NS_SUCCEEDED(channel->AsyncOpen(loader))) return; + } + } + } + + CancelExistingLoad(); + PostCancelPendingQ(NS_ERROR_UNEXPECTED); +} + +void nsPACMan::OnLoadFailure() { + int32_t minInterval = 5; // 5 seconds + int32_t maxInterval = 300; // 5 minutes + + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (prefs) { + prefs->GetIntPref("network.proxy.autoconfig_retry_interval_min", + &minInterval); + prefs->GetIntPref("network.proxy.autoconfig_retry_interval_max", + &maxInterval); + } + + int32_t interval = minInterval << mLoadFailureCount++; // seconds + if (!interval || interval > maxInterval) interval = maxInterval; + + mScheduledReload = TimeStamp::Now() + TimeDuration::FromSeconds(interval); + + LOG(("OnLoadFailure: retry in %d seconds (%d fails)\n", interval, + (uint32_t)mLoadFailureCount)); + + // while we wait for the retry queued members should try direct + // even if that means fast failure. + PostCancelPendingQ(NS_ERROR_NOT_AVAILABLE); +} + +void nsPACMan::CancelExistingLoad() { + nsCOMPtr<nsIStreamLoader> loader; + { + auto locked = mLoader.Lock(); + loader.swap(*locked); + } + if (loader) { + nsCOMPtr<nsIRequest> request; + loader->GetRequest(getter_AddRefs(request)); + if (request) { + request->Cancel(NS_ERROR_ABORT); + } + } +} + +void nsPACMan::PostProcessPendingQ() { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + RefPtr<ExecutePACThreadAction> pending = new ExecutePACThreadAction(this); + DispatchToPAC(pending.forget()); +} + +void nsPACMan::PostCancelPendingQ(nsresult status, bool aShutdown) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + RefPtr<ExecutePACThreadAction> pending = new ExecutePACThreadAction(this); + pending->CancelQueue(status, aShutdown); + DispatchToPAC(pending.forget()); +} + +void nsPACMan::CancelPendingQ(nsresult status, bool aShutdown) { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + RefPtr<PendingPACQuery> query; + + while (!mPendingQ.isEmpty()) { + query = dont_AddRef(mPendingQ.popLast()); + query->Complete(status, ""_ns); + } + + if (aShutdown) { + mPAC->Shutdown(); + } +} + +void nsPACMan::ProcessPendingQ() { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + while (ProcessPending()) { + ; + } + + if (mShutdown) { + mPAC->Shutdown(); + } else { + // do GC while the thread has nothing pending + mPAC->GC(); + } +} + +// returns true if progress was made by shortening the queue +bool nsPACMan::ProcessPending() { + if (mPendingQ.isEmpty()) return false; + + // queue during normal load, but if we are retrying a failed load then + // fast fail the queries + if (mInProgress || (IsLoading() && !mLoadFailureCount)) return false; + + RefPtr<PendingPACQuery> query(dont_AddRef(mPendingQ.popFirst())); + + // Having |mLoadFailureCount > 0| means we haven't had a sucessful PAC load + // yet. We should use DIRECT instead. + if (mShutdown || IsLoading() || mLoadFailureCount > 0) { + query->Complete(NS_ERROR_NOT_AVAILABLE, ""_ns); + return true; + } + + nsAutoCString pacString; + bool completed = false; + mInProgress = true; + nsAutoCString PACURI; + + // first we need to consider the system proxy changing the pac url + if (mSystemProxySettings && + NS_SUCCEEDED(mSystemProxySettings->GetPACURI(PACURI)) && + !PACURI.IsEmpty() && !PACURI.Equals(mPACURISpec)) { + query->UseAlternatePACFile(PACURI); + LOG(("Use PAC from system settings: %s\n", PACURI.get())); + completed = true; + } + + // now try the system proxy settings for this particular url if + // PAC was not specified + if (!completed && mSystemProxySettings && PACURI.IsEmpty() && + NS_SUCCEEDED(mSystemProxySettings->GetProxyForURI( + query->mSpec, query->mScheme, query->mHost, query->mPort, + pacString))) { + if (query->mFlags & nsIProtocolProxyService::RESOLVE_PREFER_SOCKS_PROXY && + query->mFlags & nsIProtocolProxyService::RESOLVE_PREFER_HTTPS_PROXY) { + if (StringBeginsWith(pacString, nsDependentCString(kProxyType_DIRECT), + nsCaseInsensitiveUTF8StringComparator)) { + // DIRECT indicates that system proxy settings are not configured to use + // SOCKS proxy. Try https proxy as a secondary preferrable proxy. This + // is mainly for websocket whose precedence is SOCKS > HTTPS > DIRECT. + NS_SUCCEEDED(mSystemProxySettings->GetProxyForURI( + query->mSpec, nsDependentCString(kProxyType_HTTPS), query->mHost, + query->mPort, pacString)); + } + } + LOG(("Use proxy from system settings: %s\n", pacString.get())); + query->Complete(NS_OK, pacString); + completed = true; + } + + // the systemproxysettings didn't complete the resolution. try via PAC + if (!completed) { + auto callback = [query(query)](nsresult aStatus, + const nsACString& aResult) { + LOG(("Use proxy from PAC: %s\n", PromiseFlatCString(aResult).get())); + query->Complete(aStatus, aResult); + }; + mPAC->GetProxyForURIWithCallback(query->mSpec, query->mHost, + std::move(callback)); + } + + mInProgress = false; + return true; +} + +NS_IMPL_ISUPPORTS(nsPACMan, nsIStreamLoaderObserver, nsIInterfaceRequestor, + nsIChannelEventSink) + +NS_IMETHODIMP +nsPACMan::OnStreamComplete(nsIStreamLoader* loader, nsISupports* context, + nsresult status, uint32_t dataLen, + const uint8_t* data) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + + bool loadSucceeded = NS_SUCCEEDED(status) && HttpRequestSucceeded(loader); + { + auto locked = mLoader.Lock(); + if (locked.ref() != loader) { + // If this happens, then it means that LoadPACFromURI was called more + // than once before the initial call completed. In this case, status + // should be NS_ERROR_ABORT, and if so, then we know that we can and + // should delay any processing. + LOG(("OnStreamComplete: called more than once\n")); + if (status == NS_ERROR_ABORT) { + return NS_OK; + } + } else if (!loadSucceeded) { + // We have to clear the loader to indicate that we are not loading PAC + // currently. + // Note that we can only clear the loader when |loader| and |mLoader| are + // the same one. + locked.ref() = nullptr; + } + } + + LOG(("OnStreamComplete: entry\n")); + + if (loadSucceeded) { + // Get the URI spec used to load this PAC script. + nsAutoCString pacURI; + { + nsCOMPtr<nsIRequest> request; + loader->GetRequest(getter_AddRefs(request)); + nsCOMPtr<nsIChannel> channel = do_QueryInterface(request); + if (channel) { + nsCOMPtr<nsIURI> uri; + channel->GetURI(getter_AddRefs(uri)); + if (uri) uri->GetAsciiSpec(pacURI); + } + } + + nsCOMPtr<nsIProtocolProxyService> pps = + do_GetService(NS_PROTOCOLPROXYSERVICE_CONTRACTID); + MOZ_ASSERT(pps); + if (pps) { + pps->NotifyProxyConfigChangedInternal(); + } + + // We succeeded in loading the pac file using a bunch of interfaces that are + // main thread only. Unfortunately, we have to initialize the instance of + // the PAC evaluator (NS_PROXYAUTOCONFIG_CONTRACTID) on the PAC thread, + // because that's where it will be used. + RefPtr<ExecutePACThreadAction> pending = new ExecutePACThreadAction(this); + pending->SetupPAC(reinterpret_cast<const char*>(data), dataLen, pacURI, + GetExtraJSContextHeapSize()); + DispatchToPAC(pending.forget()); + + LOG(("OnStreamComplete: process the PAC contents\n")); + + // Even if the PAC file could not be parsed, we did succeed in loading the + // data for it. + mLoadFailureCount = 0; + } else { + // We were unable to load the PAC file (presumably because of a network + // failure). Try again a little later. + LOG(("OnStreamComplete: unable to load PAC, retry later\n")); + OnLoadFailure(); + } + + if (NS_SUCCEEDED(status)) { + PostProcessPendingQ(); + } else { + PostCancelPendingQ(status); + } + + return NS_OK; +} + +NS_IMETHODIMP +nsPACMan::GetInterface(const nsIID& iid, void** result) { + // In case loading the PAC file requires authentication. + if (iid.Equals(NS_GET_IID(nsIAuthPrompt))) { + nsCOMPtr<nsIPromptFactory> promptFac = + do_GetService("@mozilla.org/prompter;1"); + NS_ENSURE_TRUE(promptFac, NS_ERROR_NO_INTERFACE); + nsresult rv = + promptFac->GetPrompt(nullptr, iid, reinterpret_cast<void**>(result)); + if (NS_FAILED(rv)) { + return NS_ERROR_NO_INTERFACE; + } + return NS_OK; + } + + // In case loading the PAC file results in a redirect. + if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) { + NS_ADDREF_THIS(); + *result = static_cast<nsIChannelEventSink*>(this); + return NS_OK; + } + + return NS_ERROR_NO_INTERFACE; +} + +NS_IMETHODIMP +nsPACMan::AsyncOnChannelRedirect(nsIChannel* oldChannel, nsIChannel* newChannel, + uint32_t flags, + nsIAsyncVerifyRedirectCallback* callback) { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + + nsresult rv = NS_OK; + nsCOMPtr<nsIURI> pacURI; + if (NS_FAILED((rv = newChannel->GetURI(getter_AddRefs(pacURI))))) return rv; + + rv = pacURI->GetSpec(mPACURIRedirectSpec); + if (NS_FAILED(rv)) return rv; + + LOG(("nsPACMan redirect from original %s to redirected %s\n", + mPACURISpec.get(), mPACURIRedirectSpec.get())); + + // do not update mPACURISpec - that needs to stay as the + // configured URI so that we can determine when the config changes. + // However do track the most recent URI in the redirect change + // as mPACURIRedirectSpec so that URI can be allowed to bypass + // the proxy and actually fetch the pac file. + + callback->OnRedirectVerifyCallback(NS_OK); + return NS_OK; +} + +nsresult nsPACMan::Init(nsISystemProxySettings* systemProxySettings) { + mSystemProxySettings = systemProxySettings; + mDHCPClient = do_GetService(NS_DHCPCLIENT_CONTRACTID); + return NS_OK; +} + +} // namespace net +} // namespace mozilla |