diff options
Diffstat (limited to 'netwerk/base/nsPACMan.cpp')
| -rw-r--r-- | netwerk/base/nsPACMan.cpp | 769 |
1 files changed, 769 insertions, 0 deletions
diff --git a/netwerk/base/nsPACMan.cpp b/netwerk/base/nsPACMan.cpp new file mode 100644 index 000000000..37d3e8b6b --- /dev/null +++ b/netwerk/base/nsPACMan.cpp @@ -0,0 +1,769 @@ +/* -*- 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 "nsThreadUtils.h" +#include "nsIAuthPrompt.h" +#include "nsIPromptFactory.h" +#include "nsIHttpChannel.h" +#include "nsIPrefService.h" +#include "nsIPrefBranch.h" +#include "nsNetUtil.h" +#include "nsIAsyncVerifyRedirectCallback.h" +#include "nsISystemProxySettings.h" +#include "nsContentUtils.h" +#include "mozilla/Preferences.h" + +//----------------------------------------------------------------------------- + +namespace mozilla { +namespace net { + +LazyLogModule gProxyLog("proxy"); + +#undef LOG +#define LOG(args) MOZ_LOG(gProxyLog, LogLevel::Debug, args) + +// 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) + httpChannel->GetRequestSucceeded(&result); + + return result; +} + +//----------------------------------------------------------------------------- + +// 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) + : mCallback(aCallback) + , mStatus(status) + { + } + + void SetPACString(const nsCString &pacString) + { + mPACString = pacString; + } + + void SetPACURL(const nsCString &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) + : 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) + : 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) + : mPACMan(aPACMan) + { + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mPACMan->mLoader = nullptr; + mPACMan->PostProcessPendingQ(); + return NS_OK; + } + +private: + RefPtr<nsPACMan> mPACMan; +}; + +//----------------------------------------------------------------------------- + +// ExecutePACThreadAction is used to proxy actions from the main +// thread onto the PAC thread. There are 3 options: process the queue, +// cancel the queue, 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) + : mPACMan(aPACMan) + , mCancel(false) + , mCancelStatus(NS_OK) + , mSetupPAC(false) + { } + + void CancelQueue (nsresult status) + { + mCancel = true; + mCancelStatus = status; + } + + void SetupPAC (const char *text, uint32_t datalen, nsCString &pacURI) + { + mSetupPAC = true; + mSetupPACData.Assign(text, datalen); + mSetupPACURI = pacURI; + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + if (mCancel) { + mPACMan->CancelPendingQ(mCancelStatus); + mCancel = false; + return NS_OK; + } + + if (mSetupPAC) { + mSetupPAC = false; + + mPACMan->mPAC.Init(mSetupPACURI, + mSetupPACData, + mPACMan->mIncludePath); + + RefPtr<PACLoadComplete> runnable = new PACLoadComplete(mPACMan); + NS_DispatchToMainThread(runnable); + return NS_OK; + } + + mPACMan->ProcessPendingQ(); + return NS_OK; + } + +private: + RefPtr<nsPACMan> mPACMan; + + bool mCancel; + nsresult mCancelStatus; + + bool mSetupPAC; + nsCString mSetupPACData; + nsCString mSetupPACURI; +}; + +//----------------------------------------------------------------------------- + +PendingPACQuery::PendingPACQuery(nsPACMan *pacMan, nsIURI *uri, + nsPACManCallback *callback, + bool mainThreadResponse) + : mPACMan(pacMan) + , mCallback(callback) + , mOnMainThreadOnly(mainThreadResponse) +{ + uri->GetAsciiSpec(mSpec); + uri->GetAsciiHost(mHost); + uri->GetScheme(mScheme); + uri->GetPort(&mPort); +} + +void +PendingPACQuery::Complete(nsresult status, const nsCString &pacString) +{ + if (!mCallback) + return; + RefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, status); + runnable->SetPACString(pacString); + if (mOnMainThreadOnly) + NS_DispatchToMainThread(runnable); + else + runnable->Run(); +} + +void +PendingPACQuery::UseAlternatePACFile(const nsCString &pacURL) +{ + if (!mCallback) + return; + + RefPtr<ExecuteCallback> runnable = new ExecuteCallback(mCallback, NS_OK); + runnable->SetPACURL(pacURL); + if (mOnMainThreadOnly) + NS_DispatchToMainThread(runnable); + 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() + : mLoadPending(false) + , mShutdown(false) + , mLoadFailureCount(0) + , mInProgress(false) +{ + MOZ_ASSERT(NS_IsMainThread(), "pacman must be created on main thread"); + if (!sThreadLocalSetup){ + sThreadLocalSetup = true; + PR_NewThreadPrivateIndex(&sThreadLocalIndex, nullptr); + } + mPAC.SetThreadLocalIndex(sThreadLocalIndex); + mIncludePath = Preferences::GetBool(kPACIncludePath, false); +} + +nsPACMan::~nsPACMan() +{ + if (mPACThread) { + if (NS_IsMainThread()) { + mPACThread->Shutdown(); + } + else { + RefPtr<ShutdownThread> runnable = new ShutdownThread(mPACThread); + NS_DispatchToMainThread(runnable); + } + } + + NS_ASSERTION(mLoader == nullptr, "pac man not shutdown properly"); + 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; + } + mShutdown = true; + CancelExistingLoad(); + PostCancelPendingQ(NS_ERROR_ABORT); + + RefPtr<WaitForThreadShutdown> runnable = new WaitForThreadShutdown(this); + NS_DispatchToMainThread(runnable); +} + +nsresult +nsPACMan::AsyncGetProxyForURI(nsIURI *uri, + nsPACManCallback *callback, + 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(EmptyCString()); + } + + RefPtr<PendingPACQuery> query = + new PendingPACQuery(this, uri, callback, mainThreadResponse); + + if (IsPACURI(uri)) { + // deal with this directly instead of queueing it + query->Complete(NS_OK, EmptyCString()); + return NS_OK; + } + + return mPACThread->Dispatch(query, nsIEventTarget::DISPATCH_NORMAL); +} + +nsresult +nsPACMan::PostQuery(PendingPACQuery *query) +{ + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + + if (mShutdown) { + query->Complete(NS_ERROR_NOT_AVAILABLE, EmptyCString()); + 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 nsCString &spec) +{ + NS_ENSURE_STATE(!mShutdown); + NS_ENSURE_ARG(!spec.IsEmpty() || !mPACURISpec.IsEmpty()); + + nsCOMPtr<nsIStreamLoader> loader = + do_CreateInstance(NS_STREAMLOADER_CONTRACTID); + NS_ENSURE_STATE(loader); + + LOG(("nsPACMan::LoadPACFromURI %s\n", spec.get())); + // 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) { + nsresult rv; + if (NS_FAILED(rv = NS_DispatchToCurrentThread(NewRunnableMethod(this, &nsPACMan::StartLoading)))) + return rv; + mLoadPending = true; + } + + CancelExistingLoad(); + + mLoader = loader; + if (!spec.IsEmpty()) { + mPACURISpec = spec; + mPACURIRedirectSpec.Truncate(); + mNormalPACURISpec.Truncate(); // set at load time + mLoadFailureCount = 0; // reset + } + + // reset to Null + mScheduledReload = TimeStamp(); + return NS_OK; +} + +void +nsPACMan::StartLoading() +{ + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + mLoadPending = false; + + // CancelExistingLoad was called... + if (!mLoader) { + PostCancelPendingQ(NS_ERROR_ABORT); + return; + } + + if (NS_SUCCEEDED(mLoader->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_DATA_IS_NULL, + nsIContentPolicy::TYPE_OTHER, + nullptr, // aLoadGroup + nullptr, // aCallbacks + nsIRequest::LOAD_NORMAL, + ios); + } + else { + LOG(("nsPACMan::StartLoading Failed pacspec uri conversion %s\n", + mPACURISpec.get())); + } + + if (channel) { + channel->SetLoadFlags(nsIRequest::LOAD_BYPASS_CACHE); + channel->SetNotificationCallbacks(this); + if (NS_SUCCEEDED(channel->AsyncOpen2(mLoader))) + 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, 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() +{ + if (mLoader) { + nsCOMPtr<nsIRequest> request; + mLoader->GetRequest(getter_AddRefs(request)); + if (request) + request->Cancel(NS_ERROR_ABORT); + mLoader = nullptr; + } +} + +void +nsPACMan::PostProcessPendingQ() +{ + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + RefPtr<ExecutePACThreadAction> pending = + new ExecutePACThreadAction(this); + if (mPACThread) + mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL); +} + +void +nsPACMan::PostCancelPendingQ(nsresult status) +{ + MOZ_ASSERT(NS_IsMainThread(), "wrong thread"); + RefPtr<ExecutePACThreadAction> pending = + new ExecutePACThreadAction(this); + pending->CancelQueue(status); + if (mPACThread) + mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL); +} + +void +nsPACMan::CancelPendingQ(nsresult status) +{ + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + RefPtr<PendingPACQuery> query; + + while (!mPendingQ.isEmpty()) { + query = dont_AddRef(mPendingQ.popLast()); + query->Complete(status, EmptyCString()); + } + + if (mShutdown) + 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())); + + if (mShutdown || IsLoading()) { + query->Complete(NS_ERROR_NOT_AVAILABLE, EmptyCString()); + 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))) { + 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) { + nsresult status = mPAC.GetProxyForURI(query->mSpec, query->mHost, + pacString); + LOG(("Use proxy from PAC: %s\n", pacString.get())); + query->Complete(status, pacString); + } + + 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"); + if (mLoader != 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; + } + + LOG(("OnStreamComplete: entry\n")); + + if (NS_SUCCEEDED(status) && HttpRequestSucceeded(loader)) { + // 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); + } + } + + // We assume that the PAC text is ASCII (or ISO-Latin-1). We've had this + // assumption forever, and some real-world PAC scripts actually have some + // non-ASCII text in comment blocks (see bug 296163). + const char *text = (const char *) data; + + // we have 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 is where it will be used. + + RefPtr<ExecutePACThreadAction> pending = + new ExecutePACThreadAction(this); + pending->SetupPAC(text, dataLen, pacURI); + if (mPACThread) + mPACThread->Dispatch(pending, nsIEventTarget::DISPATCH_NORMAL); + + 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_FAILURE); + return promptFac->GetPrompt(nullptr, iid, reinterpret_cast<void**>(result)); + } + + // 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; +} + +void +nsPACMan::NamePACThread() +{ + MOZ_ASSERT(!NS_IsMainThread(), "wrong thread"); + PR_SetCurrentThreadName("Proxy Resolution"); +} + +nsresult +nsPACMan::Init(nsISystemProxySettings *systemProxySettings) +{ + mSystemProxySettings = systemProxySettings; + + nsresult rv = NS_NewThread(getter_AddRefs(mPACThread), nullptr); + if (NS_FAILED(rv)) + return rv; + + // don't check return value as it is not a big deal for this to fail. + mPACThread->Dispatch(NewRunnableMethod(this, &nsPACMan::NamePACThread), + nsIEventTarget::DISPATCH_NORMAL); + + return NS_OK; +} + +} // namespace net +} // namespace mozilla |